Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy
Rust
bridge cursor reads through claude read
Raine Virtab8dd8d029a83
diff --git a/src/providers/cursor/client.ts b/src/providers/cursor/client.tsindex 82a95a3..66066c6 100644--- a/src/providers/cursor/client.ts+++ b/src/providers/cursor/client.ts@@ -18,6 +18,7 @@ export interface CursorRunOptions {ctx: RequestContext;proto?: CursorProto;openRunStream?: CursorRunStreamFactory;+ readHandler?: CursorReadHandler;shellStreamHandler?: CursorShellStreamHandler;writeHandler?: CursorWriteHandler;}@@ -53,6 +54,22 @@ export interface CursorShellStreamResult {export type CursorAppendMessage = (messageJson: unknown) => Promise<void>;+export interface CursorReadExec {+ id?: number;+ execId?: string;+ message?: { case?: string; value?: unknown };+}++export interface CursorReadToolResult {+ success: boolean;+ error?: string;+}++export type CursorReadHandler = (+ exec: CursorReadExec,+ append: CursorAppendMessage,+) => Promise<void>;+export type CursorShellStreamHandler = (exec: CursorShellStreamExec,append: CursorAppendMessage,@@ -191,18 +208,27 @@ export async function runCursorAgent(opts: CursorRunOptions): Promise<ReadableStasync transform(chunk, controller) {opts.ctx.traffic?.writeBytes("030-cursor-run-response-chunk", chunk);controller.enqueue(chunk);- await processServerControlFrames(chunk, proto, append, opts.ctx, opts.shellStreamHandler, opts.writeHandler, (text) => {- if (!text || controller.desiredSize === null) return;- try {- opts.ctx.traffic?.writeJsonEvent("038-cursor-tool-trace", { text });- const messageBytes = proto.AgentServerMessage.fromJson({- interactionUpdate: { textDelta: { text } },- }).toBinary();- controller.enqueue(encodeConnectFrame(messageBytes));- } catch {- // Downstream cancellation can close the transformed stream while a Cursor exec is still finishing.- }- });+ await processServerControlFrames(+ chunk,+ proto,+ append,+ opts.ctx,+ opts.readHandler,+ opts.shellStreamHandler,+ opts.writeHandler,+ (text) => {+ if (!text || controller.desiredSize === null) return;+ try {+ opts.ctx.traffic?.writeJsonEvent("038-cursor-tool-trace", { text });+ const messageBytes = proto.AgentServerMessage.fromJson({+ interactionUpdate: { textDelta: { text } },+ }).toBinary();+ controller.enqueue(encodeConnectFrame(messageBytes));+ } catch {+ // Downstream cancellation can close the transformed stream while a Cursor exec is still finishing.+ }+ },+ );},flush() {cleanup();@@ -370,6 +396,7 @@ async function processServerControlFrames(proto: CursorProto,append: (messageJson: unknown) => Promise<void>,ctx?: RequestContext,+ readHandler?: CursorReadHandler,shellStreamHandler?: CursorShellStreamHandler,writeHandler?: CursorWriteHandler,emitTrace?: (text: string) => void,@@ -404,8 +431,12 @@ async function processServerControlFrames(await append({ execClientMessage: buildRequestContextResult(oneof.value) });await append({ execClientControlMessage: { streamClose: {} } });} else if (oneof.value?.message?.case === "readArgs") {- await append({ execClientMessage: await buildReadResult(oneof.value) });- await append({ execClientControlMessage: { streamClose: { id: oneof.value.id } } });+ if (readHandler) {+ await readHandler(oneof.value, append);+ } else {+ await append({ execClientMessage: await buildReadResult(oneof.value) });+ await append({ execClientControlMessage: { streamClose: { id: oneof.value.id } } });+ }} else if (oneof.value?.message?.case === "writeArgs") {if (writeHandler) {await writeHandler(oneof.value, append);@@ -452,6 +483,14 @@ export function cursorShellStreamArgs(exec: CursorShellStreamExec): {return { command, workingDirectory, timeoutMs };}+export function cursorReadArgs(exec: CursorReadExec): {+ path: string;+} {+ const args = asRecord(exec.message?.value);+ const path = typeof args?.path === "string" ? args.path : "";+ return { path };+}+export function cursorWriteArgs(exec: CursorWriteExec): {path: string;content: string;@@ -552,6 +591,37 @@ function lineCount(content: string): number {return content.length === 0 ? 0 : content.split("\n").length;}+export async function appendCursorReadResult(+ exec: CursorReadExec,+ result: CursorReadToolResult,+ append: CursorAppendMessage,+): Promise<void> {+ await append({ execClientMessage: await buildReadResultFromTool(exec, result) });+ await append({ execClientControlMessage: { streamClose: { id: exec.id } } });+}++async function buildReadResultFromTool(+ exec: CursorReadExec,+ result: CursorReadToolResult,+): Promise<Record<string, unknown>> {+ if (result.success) return buildReadResult(exec);++ const { path } = cursorReadArgs(exec);+ const content = result.error || `Error reading ${path}`;+ return {+ ...(typeof exec.id === "number" ? { id: exec.id } : {}),+ ...(typeof exec.execId === "string" ? { execId: exec.execId } : {}),+ readResult: {+ success: {+ path,+ content,+ totalLines: lineCount(content),+ fileSize: String(Buffer.byteLength(content, "utf8")),+ },+ },+ };+}+export async function appendCursorWriteResult(exec: CursorWriteExec,result: CursorWriteResult,diff --git a/src/providers/cursor/index.test.ts b/src/providers/cursor/index.test.tsindex 8def762..b50eaed 100644--- a/src/providers/cursor/index.test.ts+++ b/src/providers/cursor/index.test.ts@@ -395,6 +395,197 @@ describe("Cursor provider messages", () => {expect(resumeEvents.find((event) => event.event === "message_delta")?.data.delta.stop_reason).toBe("end_turn");expect(resumeEvents.at(-1)?.event).toBe("message_stop");});++ it("bridges Cursor readArgs before writeArgs so Claude Write can edit existing files", async () => {+ let serverController!: ReadableStreamDefaultController<Uint8Array>;+ const sentFrames: Array<Record<string, any>> = [];+ let writeRequested = false;+ let finalResponseSent = false;+ const dir = await mkdtemp(join(tmpdir(), "cursor-read-write-bridge-"));+ const file = join(dir, "README.md");+ const originalContent = "# Demo\n\nOld detail.\n";+ const updatedContent = "# Demo\n\nUpdated detail.\n";+ await writeFile(file, originalContent, "utf8");+ const serverReadable = new ReadableStream<Uint8Array>({+ start(controller) {+ serverController = controller;+ queueMicrotask(() => {+ controller.enqueue(frame({+ message: {+ case: "execServerMessage",+ value: {+ id: 21,+ execId: "exec-read",+ message: { case: "readArgs", value: { path: file } },+ },+ },+ }));+ });+ },+ });+ const provider = createCursorProvider({+ loadAuth: async () => ({ accessToken: "token", source: "test" }),+ runAgent: async (opts) =>+ runCursorAgent({+ ...opts,+ proto: fakeProto,+ openRunStream: async () => ({+ readable: serverReadable,+ status: Promise.resolve({ status: 200 }),+ async write(frameBytes) {+ const message = decodeFrameJson(frameBytes) as Record<string, any>;+ sentFrames.push(message);+ if (message.execClientMessage?.readResult?.success && !writeRequested) {+ writeRequested = true;+ serverController.enqueue(frame({+ message: {+ case: "execServerMessage",+ value: {+ id: 22,+ execId: "exec-write",+ message: {+ case: "writeArgs",+ value: {+ path: file,+ fileText: updatedContent,+ returnFileContentAfterWrite: true,+ },+ },+ },+ },+ }));+ }+ if (message.execClientMessage?.writeResult?.success && !finalResponseSent) {+ finalResponseSent = true;+ serverController.enqueue(frame({+ interactionUpdate: { textDelta: { text: "edited existing file" } },+ }));+ serverController.enqueue(frame({+ interactionUpdate: { turnEnded: { inputTokens: "8", outputTokens: "5" } },+ }));+ serverController.close();+ }+ },+ close() {},+ }),+ }),+ proto: fakeProto,+ });++ const initial = await provider.handleMessages(+ {+ model: "cursor",+ stream: true,+ tools: [+ { name: "Read", input_schema: { type: "object" } },+ { name: "Write", input_schema: { type: "object" } },+ ],+ messages: [{ role: "user", content: "edit readme" }],+ },+ fakeCtx(),+ );+ const initialEvents = await collectSse(initial);+ const readToolStart = initialEvents.find((event) => event.event === "content_block_start"+ && event.data.content_block?.type === "tool_use");+ const readToolInput = initialEvents.find((event) => event.event === "content_block_delta"+ && event.data.delta?.type === "input_json_delta");++ expect(readToolStart?.data.content_block.name).toBe("Read");+ expect(JSON.parse(readToolInput?.data.delta.partial_json)).toEqual({ file_path: file });+ expect(sentFrames.some((message) => message.execClientMessage?.readResult)).toBe(false);++ const afterRead = await provider.handleMessages(+ {+ model: "cursor",+ stream: true,+ messages: [+ {+ role: "assistant",+ content: [{+ type: "tool_use",+ id: readToolStart!.data.content_block.id,+ name: "Read",+ input: { file_path: file },+ }],+ },+ {+ role: "user",+ content: [{+ type: "tool_result",+ tool_use_id: readToolStart!.data.content_block.id,+ content: originalContent,+ is_error: false,+ }],+ },+ ],+ },+ fakeCtx(),+ );+ const afterReadEvents = await collectSse(afterRead);+ const readResult = sentFrames.find((message) => message.execClientMessage?.readResult)+ ?.execClientMessage.readResult.success;+ const writeToolStart = afterReadEvents.find((event) => event.event === "content_block_start"+ && event.data.content_block?.type === "tool_use");+ const writeToolInput = afterReadEvents.find((event) => event.event === "content_block_delta"+ && event.data.delta?.type === "input_json_delta");++ expect(readResult).toEqual({+ path: file,+ content: originalContent,+ totalLines: 4,+ fileSize: "20",+ });+ expect(writeToolStart?.data.content_block.name).toBe("Write");+ expect(JSON.parse(writeToolInput?.data.delta.partial_json)).toEqual({+ file_path: file,+ content: updatedContent,+ });++ await writeFile(file, updatedContent, "utf8");+ const afterWrite = await provider.handleMessages(+ {+ model: "cursor",+ stream: true,+ messages: [+ {+ role: "assistant",+ content: [{+ type: "tool_use",+ id: writeToolStart!.data.content_block.id,+ name: "Write",+ input: { file_path: file, content: updatedContent },+ }],+ },+ {+ role: "user",+ content: [{+ type: "tool_result",+ tool_use_id: writeToolStart!.data.content_block.id,+ content: `Wrote 3 lines to ${file}`,+ is_error: false,+ }],+ },+ ],+ },+ fakeCtx(),+ );+ const afterWriteEvents = await collectSse(afterWrite);+ const writeResult = sentFrames.find((message) => message.execClientMessage?.writeResult)+ ?.execClientMessage.writeResult.success;++ expect(writeResult).toEqual({+ path: file,+ linesCreated: 4,+ fileSize: 24,+ fileContentAfterWrite: updatedContent,+ });+ expect(afterWriteEvents.find((event) => event.event === "content_block_delta")?.data.delta.text).toBe(+ "edited existing file",+ );+ expect(afterWriteEvents.find((event) => event.event === "message_delta")?.data.delta.stop_reason).toBe(+ "end_turn",+ );+ });});function fakeCtx(): RequestContext {diff --git a/src/providers/cursor/index.ts b/src/providers/cursor/index.tsindex 935c885..d05d6f7 100644--- a/src/providers/cursor/index.ts+++ b/src/providers/cursor/index.ts@@ -28,6 +28,7 @@ import {import {canBridgeCursorBashTool,canBridgeCursorNativeTools,+ canBridgeCursorReadTool,canBridgeCursorWriteTool,createCursorShellToolBridge,resumeCursorShellToolBridge,@@ -102,6 +103,7 @@ async function handleMessages(onSession,}): undefined;+ const bridgeRead = canBridgeCursorReadTool(body);const bridgeBash = canBridgeCursorBashTool(body);const bridgeWrite = canBridgeCursorWriteTool(body);@@ -114,6 +116,7 @@ async function handleMessages(model: selection.requestedModel,auth,ctx,+ readHandler: bridgeRead ? nativeToolBridge?.readHandler : undefined,shellStreamHandler: bridgeBash ? nativeToolBridge?.shellStreamHandler : undefined,writeHandler: bridgeWrite ? nativeToolBridge?.writeHandler : undefined,});diff --git a/src/providers/cursor/tool-bridge.ts b/src/providers/cursor/tool-bridge.tsindex 58578a5..0022fde 100644--- a/src/providers/cursor/tool-bridge.ts+++ b/src/providers/cursor/tool-bridge.ts@@ -3,12 +3,15 @@ import type { AnthropicRequest, AnthropicToolResultBlock } from "../../anthropicimport type { Logger } from "../../log.ts";import type { RequestContext } from "../types.ts";import {+ appendCursorReadResult,appendCursorShellStreamResult,appendCursorWriteResult,+ cursorReadArgs,cursorShellStreamArgs,cursorWriteArgs,decodeCursorStream,type CursorAppendMessage,+ type CursorReadExec,type CursorShellStreamExec,type CursorStreamEvent,type CursorUsage,@@ -25,6 +28,12 @@ interface PendingToolBase {result: Promise<NativeToolResult>;}+interface PendingReadTool extends PendingToolBase {+ kind: "Read";+ exec: CursorReadExec;+ path: string;+}+interface PendingShellTool extends PendingToolBase {kind: "Bash";exec: CursorShellStreamExec;@@ -40,7 +49,7 @@ interface PendingWriteTool extends PendingToolBase {content: string;}-type PendingNativeTool = PendingShellTool | PendingWriteTool;+type PendingNativeTool = PendingReadTool | PendingShellTool | PendingWriteTool;interface NativeToolResult {content: string;@@ -63,7 +72,15 @@ interface CursorBridgeState {const bridgeStates = new Map<string, CursorBridgeState>();export function canBridgeCursorNativeTools(body: AnthropicRequest, ctx: RequestContext): boolean {- return Boolean(ctx.sessionId && body.stream && body.tools?.some((tool) => tool.name === "Bash" || tool.name === "Write"));+ return Boolean(+ ctx.sessionId && body.stream && body.tools?.some((tool) =>+ tool.name === "Read" || tool.name === "Bash" || tool.name === "Write"+ ),+ );+}++export function canBridgeCursorReadTool(body: AnthropicRequest): boolean {+ return Boolean(body.tools?.some((tool) => tool.name === "Read"));}export function canBridgeCursorBashTool(body: AnthropicRequest): boolean {@@ -83,6 +100,7 @@ export function createCursorShellToolBridge(opts: {proto?: CursorProto;onSession?: (sessionId: string) => void;}): {+ readHandler: (exec: CursorReadExec, append: CursorAppendMessage) => Promise<void>;shellStreamHandler: (exec: CursorShellStreamExec, append: CursorAppendMessage) => Promise<void>;writeHandler: (exec: CursorWriteExec, append: CursorAppendMessage) => Promise<void>;stream: (upstream: ReadableStream<Uint8Array>, signal?: AbortSignal) => ReadableStream<Uint8Array>;@@ -104,6 +122,45 @@ export function createCursorShellToolBridge(opts: {};return {+ async readHandler(exec, append) {+ const { path } = cursorReadArgs(exec);+ const toolUseId = `call_cursor_${crypto.randomUUID().replace(/-/g, "")}`;+ let resolve!: (result: NativeToolResult) => void;+ const result = new Promise<NativeToolResult>((r) => {+ resolve = r;+ });+ const tool: PendingReadTool = {+ kind: "Read",+ toolUseId,+ exec,+ path,+ startedAt: Date.now(),+ append,+ resolve,+ result,+ };+ opts.traffic?.writeJsonEvent("038-cursor-tool-bridge-pause", {+ kind: tool.kind,+ toolUseId,+ path,+ });+ notifyTool(tool);+ const readResult = await result;+ await appendCursorReadResult(+ exec,+ {+ success: !readResult.isError,+ error: readResult.isError ? readResult.content : undefined,+ },+ append,+ );+ opts.traffic?.writeJsonEvent("038-cursor-tool-bridge-resume", {+ kind: tool.kind,+ toolUseId,+ isError: readResult.isError,+ contentChars: readResult.content.length,+ });+ },async shellStreamHandler(exec, append) {const { command, workingDirectory, timeoutMs } = cursorShellStreamArgs(exec);const toolUseId = `call_cursor_${crypto.randomUUID().replace(/-/g, "")}`;@@ -451,6 +508,11 @@ function renderToolResultContent(content: AnthropicToolResultBlock["content"]):}function toolUseInput(tool: PendingNativeTool): string {+ if (tool.kind === "Read") {+ return JSON.stringify({+ file_path: tool.path,+ });+ }if (tool.kind === "Write") {return JSON.stringify({file_path: tool.path,