Skip to content

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

Rust

deny unadvertised cursor exec tools

Raine Virtad84a2c0a5e97
diff --git a/src/providers/cursor/index.test.ts b/src/providers/cursor/index.test.ts
index b50eaed..e7d209f 100644
--- a/src/providers/cursor/index.test.ts
+++ b/src/providers/cursor/index.test.ts
@@ -4,7 +4,7 @@ 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 { mkdir, mkdtemp, stat, writeFile } from "node:fs/promises";
import { tmpdir } from "node:os";
import { join } from "node:path";
@@ -265,6 +265,89 @@ describe("Cursor provider messages", () => {
expect(resumeEvents.at(-1)?.event).toBe("message_stop");
});
+ it("denies Cursor shellStreamArgs instead of executing internally when Claude did not advertise Bash", async () => {
+ let serverController!: ReadableStreamDefaultController<Uint8Array>;
+ const sentFrames: Array<Record<string, any>> = [];
+ let finalResponseSent = false;
+ const dir = await mkdtemp(join(tmpdir(), "cursor-denied-shell-"));
+ const file = join(dir, "hidden-edit.txt");
+ const serverReadable = new ReadableStream<Uint8Array>({
+ start(controller) {
+ serverController = controller;
+ queueMicrotask(() => {
+ controller.enqueue(frame({
+ message: {
+ case: "execServerMessage",
+ value: {
+ id: 13,
+ execId: "exec-shell-denied",
+ message: {
+ case: "shellStreamArgs",
+ value: {
+ command: `printf hidden > ${JSON.stringify(file)}`,
+ workingDirectory: dir,
+ timeout: 5000,
+ },
+ },
+ },
+ },
+ }));
+ });
+ },
+ });
+ 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?.shellStream?.exit && !finalResponseSent) {
+ finalResponseSent = true;
+ serverController.enqueue(frame({
+ interactionUpdate: { textDelta: { text: "shell was denied" } },
+ }));
+ serverController.enqueue(frame({
+ interactionUpdate: { turnEnded: { inputTokens: "4", outputTokens: "3" } },
+ }));
+ serverController.close();
+ }
+ },
+ close() {},
+ }),
+ }),
+ proto: fakeProto,
+ });
+
+ const response = await provider.handleMessages(
+ {
+ model: "cursor",
+ stream: true,
+ tools: [{ name: "Read", input_schema: { type: "object" } }],
+ messages: [{ role: "user", content: "try hidden shell edit" }],
+ },
+ fakeCtx(),
+ );
+ const events = await collectSse(response);
+
+ expect(events.some((event) =>
+ event.event === "content_block_start" && event.data.content_block?.name === "Bash"
+ )).toBe(false);
+ expect(sentFrames.some((message) =>
+ String(message.execClientMessage?.shellStream?.stderr?.data ?? "").includes("did not advertise the Bash tool")
+ )).toBe(true);
+ expect(sentFrames.find((message) => message.execClientMessage?.shellStream?.exit)
+ ?.execClientMessage.shellStream.exit.code).toBe(1);
+ expect(await exists(file)).toBe(false);
+ expect(events.find((event) => event.event === "content_block_delta")?.data.delta.text).toBe("shell was denied");
+ expect(events.find((event) => event.event === "message_delta")?.data.delta.stop_reason).toBe("end_turn");
+ });
+
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>> = [];
@@ -613,6 +696,15 @@ async function collectSse(response: Response): Promise<Array<{ event: string; da
return events;
}
+async function exists(path: string): Promise<boolean> {
+ try {
+ await stat(path);
+ return true;
+ } catch {
+ return false;
+ }
+}
+
function jwt(payload: Record<string, unknown>): string {
return [
Buffer.from(JSON.stringify({ alg: "none", typ: "JWT" })).toString("base64url"),
diff --git a/src/providers/cursor/index.ts b/src/providers/cursor/index.ts
index d05d6f7..d58d67d 100644
--- a/src/providers/cursor/index.ts
+++ b/src/providers/cursor/index.ts
@@ -31,6 +31,9 @@ import {
canBridgeCursorReadTool,
canBridgeCursorWriteTool,
createCursorShellToolBridge,
+ denyCursorBashTool,
+ denyCursorReadTool,
+ denyCursorWriteTool,
resumeCursorShellToolBridge,
} from "./tool-bridge.ts";
import type { CursorAuth } from "./auth/token-store.ts";
@@ -106,6 +109,7 @@ async function handleMessages(
const bridgeRead = canBridgeCursorReadTool(body);
const bridgeBash = canBridgeCursorBashTool(body);
const bridgeWrite = canBridgeCursorWriteTool(body);
+ const denyUnadvertisedNativeTools = Boolean(wantStream && ctx.sessionId);
let upstream: ReadableStream<Uint8Array>;
try {
@@ -116,9 +120,21 @@ async function handleMessages(
model: selection.requestedModel,
auth,
ctx,
- readHandler: bridgeRead ? nativeToolBridge?.readHandler : undefined,
- shellStreamHandler: bridgeBash ? nativeToolBridge?.shellStreamHandler : undefined,
- writeHandler: bridgeWrite ? nativeToolBridge?.writeHandler : undefined,
+ readHandler: bridgeRead
+ ? nativeToolBridge?.readHandler
+ : denyUnadvertisedNativeTools
+ ? denyCursorReadTool
+ : undefined,
+ shellStreamHandler: bridgeBash
+ ? nativeToolBridge?.shellStreamHandler
+ : denyUnadvertisedNativeTools
+ ? denyCursorBashTool
+ : undefined,
+ writeHandler: bridgeWrite
+ ? nativeToolBridge?.writeHandler
+ : denyUnadvertisedNativeTools
+ ? denyCursorWriteTool
+ : undefined,
});
} catch (err) {
if (err instanceof CursorError) {
diff --git a/src/providers/cursor/tool-bridge.ts b/src/providers/cursor/tool-bridge.ts
index 0022fde..26f7a78 100644
--- a/src/providers/cursor/tool-bridge.ts
+++ b/src/providers/cursor/tool-bridge.ts
@@ -91,6 +91,41 @@ export function canBridgeCursorWriteTool(body: AnthropicRequest): boolean {
return Boolean(body.tools?.some((tool) => tool.name === "Write"));
}
+export async function denyCursorReadTool(exec: CursorReadExec, append: CursorAppendMessage): Promise<void> {
+ await appendCursorReadResult(
+ exec,
+ {
+ success: false,
+ error: "Cursor requested Read, but Claude did not advertise the Read tool",
+ },
+ append,
+ );
+}
+
+export async function denyCursorBashTool(exec: CursorShellStreamExec, append: CursorAppendMessage): Promise<void> {
+ await appendCursorShellStreamResult(
+ exec,
+ {
+ stderr: "Cursor requested Bash, but Claude did not advertise the Bash tool",
+ exitCode: 1,
+ cwd: cursorShellStreamArgs(exec).workingDirectory,
+ localExecutionTimeMs: 0,
+ },
+ append,
+ );
+}
+
+export async function denyCursorWriteTool(exec: CursorWriteExec, append: CursorAppendMessage): Promise<void> {
+ await appendCursorWriteResult(
+ exec,
+ {
+ success: false,
+ error: "Cursor requested Write, but Claude did not advertise the Write tool",
+ },
+ append,
+ );
+}
+
export function createCursorShellToolBridge(opts: {
sessionId: string;
messageId: string;