Skip to content

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.ts
index 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<ReadableSt
async 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.ts
index 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.ts
index 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.ts
index 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 "../../anthropic
import 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,