Skip to content

Use Claude Code with your ChatGPT, Kimi, Cursor or Grok subscription via a local Anthropic-compatible proxy

Rust

bridge cursor writes through claude write

Raine Virta547247f69700
diff --git a/src/providers/cursor/client.ts b/src/providers/cursor/client.ts
index bc43abb..82a95a3 100644
--- a/src/providers/cursor/client.ts
+++ b/src/providers/cursor/client.ts
@@ -19,6 +19,7 @@ export interface CursorRunOptions {
proto?: CursorProto;
openRunStream?: CursorRunStreamFactory;
shellStreamHandler?: CursorShellStreamHandler;
+ writeHandler?: CursorWriteHandler;
}
export type CursorRunStreamFactory = (opts: {
@@ -57,6 +58,22 @@ export type CursorShellStreamHandler = (
append: CursorAppendMessage,
) => Promise<void>;
+export interface CursorWriteExec {
+ id?: number;
+ execId?: string;
+ message?: { case?: string; value?: unknown };
+}
+
+export interface CursorWriteResult {
+ success: boolean;
+ error?: string;
+}
+
+export type CursorWriteHandler = (
+ exec: CursorWriteExec,
+ append: CursorAppendMessage,
+) => Promise<void>;
+
export type CursorAgentMode = "AGENT_MODE_AGENT" | "AGENT_MODE_PLAN" | "AGENT_MODE_ASK";
export interface CursorModelRequest {
@@ -174,7 +191,7 @@ 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, (text) => {
+ 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 });
@@ -354,6 +371,7 @@ async function processServerControlFrames(
append: (messageJson: unknown) => Promise<void>,
ctx?: RequestContext,
shellStreamHandler?: CursorShellStreamHandler,
+ writeHandler?: CursorWriteHandler,
emitTrace?: (text: string) => void,
): Promise<void> {
const state = controlFrameState.get(append) ?? {
@@ -389,8 +407,12 @@ async function processServerControlFrames(
await append({ execClientMessage: await buildReadResult(oneof.value) });
await append({ execClientControlMessage: { streamClose: { id: oneof.value.id } } });
} else if (oneof.value?.message?.case === "writeArgs") {
- await append({ execClientMessage: await buildWriteResult(oneof.value) });
- await append({ execClientControlMessage: { streamClose: { id: oneof.value.id } } });
+ if (writeHandler) {
+ await writeHandler(oneof.value, append);
+ } else {
+ await append({ execClientMessage: await buildWriteResult(oneof.value) });
+ await append({ execClientControlMessage: { streamClose: { id: oneof.value.id } } });
+ }
} else if (oneof.value?.message?.case === "grepArgs") {
await append({ execClientMessage: await buildGrepResult(oneof.value) });
await append({ execClientControlMessage: { streamClose: { id: oneof.value.id } } });
@@ -430,6 +452,19 @@ export function cursorShellStreamArgs(exec: CursorShellStreamExec): {
return { command, workingDirectory, timeoutMs };
}
+export function cursorWriteArgs(exec: CursorWriteExec): {
+ path: string;
+ content: string;
+ returnFileContentAfterWrite: boolean;
+} {
+ const args = asRecord(exec.message?.value);
+ const path = typeof args?.path === "string" ? args.path : "";
+ const rawContent = writeContentFromArgs(args);
+ const content = typeof rawContent === "string" ? rawContent : rawContent.toString("utf8");
+ const returnFileContentAfterWrite = Boolean(args?.returnFileContentAfterWrite);
+ return { path, content, returnFileContentAfterWrite };
+}
+
async function buildReadResult(exec: {
id?: number;
execId?: string;
@@ -517,6 +552,47 @@ function lineCount(content: string): number {
return content.length === 0 ? 0 : content.split("\n").length;
}
+export async function appendCursorWriteResult(
+ exec: CursorWriteExec,
+ result: CursorWriteResult,
+ append: CursorAppendMessage,
+): Promise<void> {
+ await append({ execClientMessage: await buildWriteResultFromTool(exec, result) });
+ await append({ execClientControlMessage: { streamClose: { id: exec.id } } });
+}
+
+async function buildWriteResultFromTool(
+ exec: CursorWriteExec,
+ result: CursorWriteResult,
+): Promise<Record<string, unknown>> {
+ const { path, returnFileContentAfterWrite } = cursorWriteArgs(exec);
+ if (!result.success) {
+ return {
+ ...(typeof exec.id === "number" ? { id: exec.id } : {}),
+ ...(typeof exec.execId === "string" ? { execId: exec.execId } : {}),
+ writeResult: {
+ error: {
+ path,
+ error: result.error || "Write tool failed",
+ },
+ },
+ };
+ }
+
+ const content = await readFile(path, "utf8");
+ const success: Record<string, unknown> = {
+ path,
+ linesCreated: lineCount(content),
+ fileSize: Buffer.byteLength(content),
+ };
+ if (returnFileContentAfterWrite) success.fileContentAfterWrite = content;
+ return {
+ ...(typeof exec.id === "number" ? { id: exec.id } : {}),
+ ...(typeof exec.execId === "string" ? { execId: exec.execId } : {}),
+ writeResult: { success },
+ };
+}
+
async function runShellStream(
exec: {
id?: number;
diff --git a/src/providers/cursor/index.test.ts b/src/providers/cursor/index.test.ts
index 10e6ea9..8def762 100644
--- a/src/providers/cursor/index.test.ts
+++ b/src/providers/cursor/index.test.ts
@@ -4,6 +4,9 @@ import type { RequestContext } from "../types.ts";
import { encodeConnectFrame, runCursorAgent } from "./client.ts";
import type { CursorProto, ProtoClass, ProtoMessage } from "./proto-loader.ts";
import { parseSseStream } from "../../sse.ts";
+import { mkdir, mkdtemp, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
const originalToken = process.env.CCP_CURSOR_AUTH_TOKEN;
@@ -261,6 +264,137 @@ 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 writeArgs through Claude Write tool_use and resumes from tool_result", async () => {
+ let serverController!: ReadableStreamDefaultController<Uint8Array>;
+ const sentFrames: Array<Record<string, any>> = [];
+ let finalResponseSent = false;
+ const dir = await mkdtemp(join(tmpdir(), "cursor-write-bridge-"));
+ const file = join(dir, "history", "findings.md");
+ const fileContent = "finding one\nfinding two\n";
+ const serverReadable = new ReadableStream<Uint8Array>({
+ start(controller) {
+ serverController = controller;
+ queueMicrotask(() => {
+ controller.enqueue(frame({
+ message: {
+ case: "execServerMessage",
+ value: {
+ id: 12,
+ execId: "exec-write",
+ message: {
+ case: "writeArgs",
+ value: {
+ path: file,
+ fileText: fileContent,
+ returnFileContentAfterWrite: true,
+ },
+ },
+ },
+ },
+ }));
+ });
+ },
+ });
+ 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?.writeResult?.success && !finalResponseSent) {
+ finalResponseSent = true;
+ serverController.enqueue(frame({
+ interactionUpdate: { textDelta: { text: "resumed after native write" } },
+ }));
+ serverController.enqueue(frame({
+ interactionUpdate: { turnEnded: { inputTokens: "5", outputTokens: "4" } },
+ }));
+ serverController.close();
+ }
+ },
+ close() {},
+ }),
+ }),
+ proto: fakeProto,
+ });
+
+ const initial = await provider.handleMessages(
+ {
+ model: "cursor",
+ stream: true,
+ tools: [{ name: "Write", input_schema: { type: "object" } }],
+ messages: [{ role: "user", content: "write file" }],
+ },
+ fakeCtx(),
+ );
+ const initialEvents = await collectSse(initial);
+ const toolStart = initialEvents.find((event) => event.event === "content_block_start"
+ && event.data.content_block?.type === "tool_use");
+ const toolInputDelta = initialEvents.find((event) => event.event === "content_block_delta"
+ && event.data.delta?.type === "input_json_delta");
+
+ expect(toolStart?.data.content_block.name).toBe("Write");
+ expect(toolStart?.data.content_block.id).toStartWith("call_cursor_");
+ expect(JSON.parse(toolInputDelta?.data.delta.partial_json)).toEqual({
+ file_path: file,
+ content: fileContent,
+ });
+ expect(initialEvents.find((event) => event.event === "message_delta")?.data.delta.stop_reason).toBe("tool_use");
+ expect(sentFrames.some((message) => message.execClientMessage?.writeResult)).toBe(false);
+
+ await mkdir(join(dir, "history"), { recursive: true });
+ await writeFile(file, fileContent, "utf8");
+ const resume = await provider.handleMessages(
+ {
+ model: "cursor",
+ stream: true,
+ messages: [
+ {
+ role: "assistant",
+ content: [{
+ type: "tool_use",
+ id: toolStart!.data.content_block.id,
+ name: "Write",
+ input: { file_path: file, content: fileContent },
+ }],
+ },
+ {
+ role: "user",
+ content: [{
+ type: "tool_result",
+ tool_use_id: toolStart!.data.content_block.id,
+ content: `Wrote 3 lines to ${file}`,
+ is_error: false,
+ }],
+ },
+ ],
+ },
+ fakeCtx(),
+ );
+ const resumeEvents = await collectSse(resume);
+ const writeResult = sentFrames.find((message) => message.execClientMessage?.writeResult)
+ ?.execClientMessage.writeResult.success;
+
+ expect(writeResult).toEqual({
+ path: file,
+ linesCreated: 3,
+ fileSize: 24,
+ fileContentAfterWrite: fileContent,
+ });
+ expect(sentFrames.at(-1)).toEqual({ execClientControlMessage: { streamClose: { id: 12 } } });
+ expect(resumeEvents.find((event) => event.event === "content_block_delta")?.data.delta.text).toBe(
+ "resumed after native write",
+ );
+ expect(resumeEvents.find((event) => event.event === "message_delta")?.data.delta.stop_reason).toBe("end_turn");
+ expect(resumeEvents.at(-1)?.event).toBe("message_stop");
+ });
});
function fakeCtx(): RequestContext {
diff --git a/src/providers/cursor/index.ts b/src/providers/cursor/index.ts
index 84382ac..935c885 100644
--- a/src/providers/cursor/index.ts
+++ b/src/providers/cursor/index.ts
@@ -26,7 +26,9 @@ import {
recordCursorConversation,
} from "./session.ts";
import {
- canBridgeCursorShellTools,
+ canBridgeCursorBashTool,
+ canBridgeCursorNativeTools,
+ canBridgeCursorWriteTool,
createCursorShellToolBridge,
resumeCursorShellToolBridge,
} from "./tool-bridge.ts";
@@ -89,7 +91,7 @@ async function handleMessages(
recordCursorConversation(ctx.sessionId, cursorSessionId);
log.debug("cursor session observed", { cursorSessionId });
};
- const shellBridge = wantStream && ctx.sessionId && canBridgeCursorShellTools(body, ctx)
+ const nativeToolBridge = wantStream && ctx.sessionId && canBridgeCursorNativeTools(body, ctx)
? createCursorShellToolBridge({
sessionId: ctx.sessionId,
messageId,
@@ -100,6 +102,8 @@ async function handleMessages(
onSession,
})
: undefined;
+ const bridgeBash = canBridgeCursorBashTool(body);
+ const bridgeWrite = canBridgeCursorWriteTool(body);
let upstream: ReadableStream<Uint8Array>;
try {
@@ -110,7 +114,8 @@ async function handleMessages(
model: selection.requestedModel,
auth,
ctx,
- shellStreamHandler: shellBridge?.shellStreamHandler,
+ shellStreamHandler: bridgeBash ? nativeToolBridge?.shellStreamHandler : undefined,
+ writeHandler: bridgeWrite ? nativeToolBridge?.writeHandler : undefined,
});
} catch (err) {
if (err instanceof CursorError) {
@@ -126,7 +131,7 @@ async function handleMessages(
}
if (wantStream) {
- const stream = shellBridge?.stream(upstream, ctx.signal) ?? translateCursorStream(upstream, {
+ const stream = nativeToolBridge?.stream(upstream, ctx.signal) ?? translateCursorStream(upstream, {
messageId,
model: body.model,
log: ctx.childLogger("cursor.stream"),
diff --git a/src/providers/cursor/tool-bridge.ts b/src/providers/cursor/tool-bridge.ts
index 4ca3a74..58578a5 100644
--- a/src/providers/cursor/tool-bridge.ts
+++ b/src/providers/cursor/tool-bridge.ts
@@ -4,29 +4,45 @@ import type { Logger } from "../../log.ts";
import type { RequestContext } from "../types.ts";
import {
appendCursorShellStreamResult,
+ appendCursorWriteResult,
cursorShellStreamArgs,
+ cursorWriteArgs,
decodeCursorStream,
type CursorAppendMessage,
type CursorShellStreamExec,
type CursorStreamEvent,
type CursorUsage,
+ type CursorWriteExec,
} from "./client.ts";
import type { CursorProto } from "./proto-loader.ts";
import { cursorUsageToAnthropic } from "./translate/response.ts";
-interface PendingShellTool {
+interface PendingToolBase {
toolUseId: string;
+ startedAt: number;
+ append: CursorAppendMessage;
+ resolve(result: NativeToolResult): void;
+ result: Promise<NativeToolResult>;
+}
+
+interface PendingShellTool extends PendingToolBase {
+ kind: "Bash";
exec: CursorShellStreamExec;
command: string;
workingDirectory: string;
timeoutMs: number;
- startedAt: number;
- append: CursorAppendMessage;
- resolve(result: ShellToolResult): void;
- result: Promise<ShellToolResult>;
}
-interface ShellToolResult {
+interface PendingWriteTool extends PendingToolBase {
+ kind: "Write";
+ exec: CursorWriteExec;
+ path: string;
+ content: string;
+}
+
+type PendingNativeTool = PendingShellTool | PendingWriteTool;
+
+interface NativeToolResult {
content: string;
isError: boolean;
}
@@ -37,8 +53,8 @@ interface CursorBridgeState {
model: string;
iterator: AsyncGenerator<CursorStreamEvent>;
pendingNext?: Promise<IteratorResult<CursorStreamEvent>>;
- pendingTool?: PendingShellTool;
- waiters: Array<(tool: PendingShellTool) => void>;
+ pendingTool?: PendingNativeTool;
+ waiters: Array<(tool: PendingNativeTool) => void>;
log: Logger;
traffic?: RequestContext["traffic"];
onSession?: (sessionId: string) => void;
@@ -46,8 +62,16 @@ interface CursorBridgeState {
const bridgeStates = new Map<string, CursorBridgeState>();
-export function canBridgeCursorShellTools(body: AnthropicRequest, ctx: RequestContext): boolean {
- return Boolean(ctx.sessionId && body.stream && body.tools?.some((tool) => tool.name === "Bash"));
+export function canBridgeCursorNativeTools(body: AnthropicRequest, ctx: RequestContext): boolean {
+ return Boolean(ctx.sessionId && body.stream && body.tools?.some((tool) => tool.name === "Bash" || tool.name === "Write"));
+}
+
+export function canBridgeCursorBashTool(body: AnthropicRequest): boolean {
+ return Boolean(body.tools?.some((tool) => tool.name === "Bash"));
+}
+
+export function canBridgeCursorWriteTool(body: AnthropicRequest): boolean {
+ return Boolean(body.tools?.some((tool) => tool.name === "Write"));
}
export function createCursorShellToolBridge(opts: {
@@ -60,6 +84,7 @@ export function createCursorShellToolBridge(opts: {
onSession?: (sessionId: string) => void;
}): {
shellStreamHandler: (exec: CursorShellStreamExec, append: CursorAppendMessage) => Promise<void>;
+ writeHandler: (exec: CursorWriteExec, append: CursorAppendMessage) => Promise<void>;
stream: (upstream: ReadableStream<Uint8Array>, signal?: AbortSignal) => ReadableStream<Uint8Array>;
} {
const state: CursorBridgeState = {
@@ -73,7 +98,7 @@ export function createCursorShellToolBridge(opts: {
onSession: opts.onSession,
};
- const notifyTool = (tool: PendingShellTool) => {
+ const notifyTool = (tool: PendingNativeTool) => {
state.pendingTool = tool;
for (const waiter of state.waiters.splice(0)) waiter(tool);
};
@@ -82,11 +107,12 @@ export function createCursorShellToolBridge(opts: {
async shellStreamHandler(exec, append) {
const { command, workingDirectory, timeoutMs } = cursorShellStreamArgs(exec);
const toolUseId = `call_cursor_${crypto.randomUUID().replace(/-/g, "")}`;
- let resolve!: (result: ShellToolResult) => void;
- const result = new Promise<ShellToolResult>((r) => {
+ let resolve!: (result: NativeToolResult) => void;
+ const result = new Promise<NativeToolResult>((r) => {
resolve = r;
});
const tool: PendingShellTool = {
+ kind: "Bash",
toolUseId,
exec,
command,
@@ -98,6 +124,7 @@ export function createCursorShellToolBridge(opts: {
result,
};
opts.traffic?.writeJsonEvent("038-cursor-tool-bridge-pause", {
+ kind: tool.kind,
toolUseId,
command,
workingDirectory,
@@ -117,11 +144,53 @@ export function createCursorShellToolBridge(opts: {
append,
);
opts.traffic?.writeJsonEvent("038-cursor-tool-bridge-resume", {
+ kind: tool.kind,
toolUseId,
isError: shellResult.isError,
contentChars: shellResult.content.length,
});
},
+ async writeHandler(exec, append) {
+ const { path, content } = cursorWriteArgs(exec);
+ const toolUseId = `call_cursor_${crypto.randomUUID().replace(/-/g, "")}`;
+ let resolve!: (result: NativeToolResult) => void;
+ const result = new Promise<NativeToolResult>((r) => {
+ resolve = r;
+ });
+ const tool: PendingWriteTool = {
+ kind: "Write",
+ toolUseId,
+ exec,
+ path,
+ content,
+ startedAt: Date.now(),
+ append,
+ resolve,
+ result,
+ };
+ opts.traffic?.writeJsonEvent("038-cursor-tool-bridge-pause", {
+ kind: tool.kind,
+ toolUseId,
+ path,
+ contentChars: content.length,
+ });
+ notifyTool(tool);
+ const writeResult = await result;
+ await appendCursorWriteResult(
+ exec,
+ {
+ success: !writeResult.isError,
+ error: writeResult.isError ? writeResult.content : undefined,
+ },
+ append,
+ );
+ opts.traffic?.writeJsonEvent("038-cursor-tool-bridge-resume", {
+ kind: tool.kind,
+ toolUseId,
+ isError: writeResult.isError,
+ contentChars: writeResult.content.length,
+ });
+ },
stream(upstream, signal) {
state.iterator = decodeCursorStream(upstream, opts.proto, {
traffic: opts.traffic,
@@ -246,24 +315,18 @@ function streamBridgeUntilToolOrEnd(
}
};
- const emitToolUseAndPause = (tool: PendingShellTool) => {
+ const emitToolUseAndPause = (tool: PendingNativeTool) => {
closeOpenBlocks();
ensureStart();
const index = nextIndex++;
- const input = JSON.stringify({
- command: claudeBashCommand(tool),
- timeout: tool.timeoutMs,
- description: "Run Cursor-requested shell command",
- run_in_background: false,
- dangerouslyDisableSandbox: false,
- });
+ const input = toolUseInput(tool);
emit("content_block_start", {
type: "content_block_start",
index,
content_block: {
type: "tool_use",
id: tool.toolUseId,
- name: "Bash",
+ name: tool.kind,
input: {},
},
});
@@ -359,7 +422,7 @@ function streamBridgeUntilToolOrEnd(
});
}
-function waitForPendingTool(state: CursorBridgeState): Promise<PendingShellTool> {
+function waitForPendingTool(state: CursorBridgeState): Promise<PendingNativeTool> {
if (state.pendingTool) return Promise.resolve(state.pendingTool);
return new Promise((resolve) => state.waiters.push(resolve));
}
@@ -387,6 +450,22 @@ function renderToolResultContent(content: AnthropicToolResultBlock["content"]):
.join("\n");
}
+function toolUseInput(tool: PendingNativeTool): string {
+ if (tool.kind === "Write") {
+ return JSON.stringify({
+ file_path: tool.path,
+ content: tool.content,
+ });
+ }
+ return JSON.stringify({
+ command: claudeBashCommand(tool),
+ timeout: tool.timeoutMs,
+ description: "Run Cursor-requested shell command",
+ run_in_background: false,
+ dangerouslyDisableSandbox: false,
+ });
+}
+
function claudeBashCommand(tool: PendingShellTool): string {
if (!tool.workingDirectory || tool.workingDirectory === process.cwd()) return tool.command;
return `cd ${shellQuote(tool.workingDirectory)} && ${tool.command}`;