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.tsindex 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<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, (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.tsindex 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.tsindex 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.tsindex 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}`;