@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.c18009cd

package/src/resources/extensions/cursor-cli/index.ts

@@ -0,0 +1,18 @@
+import type { ExtensionAPI } from "@gsd/pi-coding-agent";
+import { CURSOR_AGENT_MODELS } from "./models.js";
+import { isCursorAgentReady } from "./readiness.js";
+import { streamViaCursorAgent } from "./stream-adapter.js";
+
+export default function cursorCli(pi: ExtensionAPI): void {
+	if (process.env.GSD_CURSOR_DISABLE === "1") return;
+
+	pi.registerProvider("cursor-agent", {
+		name: "Cursor Agent",
+		authMode: "externalCli",
+		api: "cursor-stream-json",
+		baseUrl: "local://cursor-agent",
+		isReady: isCursorAgentReady,
+		streamSimple: streamViaCursorAgent,
+		models: CURSOR_AGENT_MODELS,
+	});
+}

package/src/resources/extensions/cursor-cli/models.ts

@@ -0,0 +1,65 @@
+const ZERO_COST = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+};
+
+const CURSOR_INPUT: ("text" | "image")[] = ["text"];
+
+export const CURSOR_AGENT_MODELS = [
+	{
+		id: "composer-2.5",
+		name: "Composer 2.5 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 64_000,
+	},
+	{
+		id: "claude-sonnet-4-6",
+		name: "Claude Sonnet 4.6 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 64_000,
+	},
+	{
+		id: "claude-opus-4-7",
+		name: "Claude Opus 4.7 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 128_000,
+	},
+	{
+		id: "gpt-5.5",
+		name: "GPT-5.5 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 128_000,
+	},
+	{
+		id: "gemini-2.5-pro",
+		name: "Gemini 2.5 Pro (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 1_000_000,
+		maxTokens: 65_536,
+	},
+	{
+		id: "grok-4",
+		name: "Grok 4 (via Cursor)",
+		reasoning: true,
+		input: CURSOR_INPUT,
+		cost: ZERO_COST,
+		contextWindow: 256_000,
+		maxTokens: 64_000,
+	},
+];

package/src/resources/extensions/cursor-cli/package.json

@@ -0,0 +1,11 @@
+{
+  "name": "@gsd/cursor-cli",
+  "private": true,
+  "version": "1.0.0",
+  "type": "module",
+  "pi": {
+    "extensions": [
+      "./index.ts"
+    ]
+  }
+}

package/src/resources/extensions/cursor-cli/readiness.ts

@@ -0,0 +1,143 @@
+import { execFileSync } from "node:child_process";
+
+const VERSION_TIMEOUT_MS = 5_000;
+const STATUS_TIMEOUT_MS = 10_000;
+const CHECK_INTERVAL_MS = 30_000;
+
+let cachedBinaryPresent: boolean | null = null;
+let cachedAuthed: boolean | null = null;
+let lastCheckMs = 0;
+
+export function getCursorAgentCommand(platform: NodeJS.Platform = process.platform): string {
+	return platform === "win32" ? "cursor-agent.cmd" : "cursor-agent";
+}
+
+export function getCursorAgentCommandCandidates(platform: NodeJS.Platform = process.platform): string[] {
+	const command = getCursorAgentCommand(platform);
+	return platform === "win32" ? [command, "cursor-agent.exe", "cursor-agent"] : [command];
+}
+
+export function buildCursorAgentSpawnInvocation(
+	command: string,
+	args: string[],
+	platform: NodeJS.Platform = process.platform,
+): { command: string; args: string[] } {
+	if (platform === "win32") {
+		return { command: "cmd", args: ["/c", command, ...args] };
+	}
+	return { command, args };
+}
+
+function debugLog(...parts: unknown[]): void {
+	if (process.env.GSD_CURSOR_DEBUG) {
+		process.stderr.write(`[cursor-readiness] ${parts.map((part) => String(part)).join(" ")}\n`);
+	}
+}
+
+function spawnCursorAgent(command: string, args: string[], timeout: number): Buffer {
+	const invocation = buildCursorAgentSpawnInvocation(command, args);
+	return execFileSync(invocation.command, invocation.args, { timeout, stdio: "pipe" });
+}
+
+function findWorkingCommand(): string | null {
+	for (const command of getCursorAgentCommandCandidates()) {
+		try {
+			spawnCursorAgent(command, ["--version"], VERSION_TIMEOUT_MS);
+			debugLog("version probe ok via", command);
+			return command;
+		} catch (error) {
+			debugLog("version probe failed for", command, (error as Error).message?.slice(0, 200));
+		}
+	}
+	return null;
+}
+
+export function parseCursorAgentStatus(output: string): boolean | null {
+	const trimmed = output.trim();
+	if (!trimmed) return null;
+
+	if (trimmed.startsWith("{")) {
+		try {
+			const parsed = JSON.parse(trimmed) as Record<string, unknown>;
+			for (const key of ["authenticated", "loggedIn", "logged_in", "isAuthenticated"]) {
+				if (typeof parsed[key] === "boolean") return parsed[key];
+			}
+		} catch {
+			// Fall through to text heuristics.
+		}
+	}
+
+	const lower = trimmed.toLowerCase();
+	if (/not authenticated|not logged in|no credentials|logged out|unauthenticated/.test(lower)) return false;
+	if (/authenticated|logged in|signed in|cursor account|subscription/.test(lower)) return true;
+	return null;
+}
+
+export function isCursorAgentApiKeyValue(value: string | undefined): boolean {
+	const trimmed = value?.trim();
+	return Boolean(trimmed && trimmed !== "cli");
+}
+
+function hasCursorApiKey(): boolean {
+	return isCursorAgentApiKeyValue(process.env.CURSOR_API_KEY);
+}
+
+function probeAuth(command: string): boolean | null {
+	if (hasCursorApiKey()) return true;
+
+	for (const args of [["agent", "status", "--json"], ["status", "--json"], ["agent", "status"], ["status"]]) {
+		try {
+			const out = spawnCursorAgent(command, args, STATUS_TIMEOUT_MS).toString();
+			debugLog("status output", args.join(" "), out.slice(0, 200));
+			const parsed = parseCursorAgentStatus(out);
+			if (parsed !== null) return parsed;
+		} catch (error) {
+			debugLog("status failed", args.join(" "), (error as Error).message?.slice(0, 200));
+		}
+	}
+
+	return null;
+}
+
+export function isCursorAgentReadyUncached(): boolean {
+	const command = findWorkingCommand();
+	if (!command) return false;
+	return probeAuth(command) === true;
+}
+
+function refreshCache(): void {
+	const now = Date.now();
+	if (cachedBinaryPresent !== null && now - lastCheckMs < CHECK_INTERVAL_MS) return;
+	lastCheckMs = now;
+
+	const command = findWorkingCommand();
+	if (!command) {
+		cachedBinaryPresent = false;
+		cachedAuthed = false;
+		return;
+	}
+
+	cachedBinaryPresent = true;
+	const authed = probeAuth(command);
+	if (authed === null) {
+		if (cachedAuthed === null) cachedAuthed = false;
+		return;
+	}
+	cachedAuthed = authed;
+}
+
+export function isCursorAgentBinaryPresent(): boolean {
+	refreshCache();
+	return cachedBinaryPresent ?? false;
+}
+
+export function isCursorAgentReady(): boolean {
+	refreshCache();
+	return (cachedBinaryPresent ?? false) && (cachedAuthed ?? false);
+}
+
+export function clearCursorAgentReadinessCache(): void {
+	cachedBinaryPresent = null;
+	cachedAuthed = null;
+	lastCheckMs = 0;
+}

package/src/resources/extensions/cursor-cli/stream-adapter.ts

@@ -0,0 +1,440 @@
+import { spawn } from "node:child_process";
+import type {
+	Api,
+	AssistantMessage,
+	AssistantMessageEventStream,
+	Context,
+	Message,
+	Model,
+	SimpleStreamOptions,
+	TextContent,
+	ToolCall,
+} from "@gsd/pi-ai";
+import { createAssistantMessageEventStream } from "@gsd/pi-ai";
+import { buildCursorAgentSpawnInvocation } from "./readiness.js";
+
+interface CursorAgentRunResult {
+	stdout: string;
+	stderr: string;
+	code: number | null;
+	signal: NodeJS.Signals | null;
+}
+
+export type CursorAgentLineHandler = (line: string) => void;
+
+export interface CursorAgentRunPlan {
+	command: string;
+	args: string[];
+}
+
+export interface CursorAgentStreamOptions extends SimpleStreamOptions {
+	_cursorAgentRunnerForTest?: (
+		plan: CursorAgentRunPlan,
+		options: SimpleStreamOptions | undefined,
+		onLine: CursorAgentLineHandler,
+	) => Promise<CursorAgentRunResult>;
+}
+
+type ExternalToolResult = NonNullable<ToolCall["externalResult"]>;
+
+type ParsedCursorAgentLine =
+	| { type: "text"; text: string }
+	| { type: "tool_call"; toolCall: ToolCall }
+	| { type: "tool_result"; toolCallId: string; result: ExternalToolResult }
+	| { type: "usage"; usage: Partial<AssistantMessage["usage"]> }
+	| { type: "error"; message: string }
+	| { type: "ignore" };
+
+const ZERO_USAGE: AssistantMessage["usage"] = {
+	input: 0,
+	output: 0,
+	cacheRead: 0,
+	cacheWrite: 0,
+	totalTokens: 0,
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
+};
+
+function textBlocks(content: (TextContent | { type: string })[]): string {
+	return content
+		.map((block) => block.type === "text" ? (block as TextContent).text : `[${block.type} omitted]`)
+		.join("\n");
+}
+
+function messageToText(message: Message): string {
+	if (message.role === "user") {
+		const content = typeof message.content === "string" ? message.content : textBlocks(message.content);
+		return `User:\n${content}`;
+	}
+
+	if (message.role === "assistant") {
+		const text = message.content
+			.map((block) => {
+				if (block.type === "text") return block.text;
+				if (block.type === "thinking") return "[thinking omitted]";
+				if (block.type === "toolCall") return `[tool call: ${block.name}]`;
+				if (block.type === "serverToolUse") return `[server tool: ${block.name}]`;
+				if (block.type === "webSearchResult") return "[web search result omitted]";
+				return `[${(block as { type: string }).type} omitted]`;
+			})
+			.join("\n");
+		return `Assistant:\n${text}`;
+	}
+
+	return `Tool result (${message.toolName}):\n${textBlocks(message.content)}`;
+}
+
+export function buildCursorPrompt(context: Context): string {
+	const parts: string[] = [];
+	if (context.systemPrompt?.trim()) parts.push(`System instructions:\n${context.systemPrompt.trim()}`);
+	if (context.messages.length > 0) parts.push(context.messages.map(messageToText).join("\n\n"));
+	if (context.tools?.length) {
+		parts.push(
+			`The external Cursor agent may execute its own tools. ` +
+			`GSD will not redispatch Cursor-owned internal tool events locally. ` +
+			`Requested GSD tools: ${context.tools.map((tool) => tool.name).join(", ")}`,
+		);
+	}
+	return parts.join("\n\n").trim();
+}
+
+export function buildCursorSpawnInvocation(
+	command: string,
+	args: string[],
+	platform: NodeJS.Platform = process.platform,
+): CursorAgentRunPlan {
+	return buildCursorAgentSpawnInvocation(command, args, platform);
+}
+
+export function buildCursorAgentRunPlan(
+	modelId: string,
+	prompt: string,
+	cwd: string,
+	platform: NodeJS.Platform = process.platform,
+): CursorAgentRunPlan {
+	return buildCursorSpawnInvocation(
+		process.env.CURSOR_AGENT_BIN?.trim() || "cursor-agent",
+		["-p", prompt, "--output-format", "stream-json", "--model", modelId, "--workspace", cwd, "--trust"],
+		platform,
+	);
+}
+
+function emitCompleteLines(chunk: string, pending: { value: string }, onLine: CursorAgentLineHandler): void {
+	pending.value += chunk;
+	const lines = pending.value.split(/\r?\n/);
+	pending.value = lines.pop() ?? "";
+	for (const line of lines) onLine(line);
+}
+
+function flushPendingLine(pending: { value: string }, onLine: CursorAgentLineHandler): void {
+	if (!pending.value) return;
+	onLine(pending.value);
+	pending.value = "";
+}
+
+function runCursorAgent(
+	plan: CursorAgentRunPlan,
+	options: SimpleStreamOptions | undefined,
+	onLine: CursorAgentLineHandler,
+): Promise<CursorAgentRunResult> {
+	return new Promise((resolve, reject) => {
+		const child = spawn(plan.command, plan.args, {
+			cwd: options?.cwd || process.cwd(),
+			env: process.env,
+			stdio: ["ignore", "pipe", "pipe"],
+		});
+
+		let stdout = "";
+		let stderr = "";
+		let settled = false;
+		const pendingStdout = { value: "" };
+
+		const settle = (fn: () => void) => {
+			if (settled) return;
+			settled = true;
+			options?.signal?.removeEventListener("abort", onAbort);
+			fn();
+		};
+		const onAbort = () => {
+			child.kill("SIGTERM");
+			settle(() => reject(new Error("Request was aborted")));
+		};
+
+		if (options?.signal?.aborted) {
+			onAbort();
+			return;
+		}
+		options?.signal?.addEventListener("abort", onAbort);
+
+		child.stdout?.setEncoding("utf8");
+		child.stderr?.setEncoding("utf8");
+		child.stdout?.on("data", (chunk) => {
+			stdout += chunk;
+			try {
+				emitCompleteLines(chunk, pendingStdout, onLine);
+			} catch (error) {
+				child.kill("SIGTERM");
+				settle(() => reject(error));
+			}
+		});
+		child.stderr?.on("data", (chunk) => { stderr += chunk; });
+		child.on("error", (error) => settle(() => reject(error)));
+		child.on("close", (code, signal) => settle(() => {
+			try {
+				flushPendingLine(pendingStdout, onLine);
+			} catch (error) {
+				reject(error);
+				return;
+			}
+			resolve({ stdout, stderr, code, signal });
+		}));
+	});
+}
+
+function stringValue(...values: unknown[]): string | undefined {
+	for (const value of values) {
+		if (typeof value === "string" && value.length > 0) return value;
+	}
+	return undefined;
+}
+
+function objectValue(value: unknown): Record<string, unknown> | undefined {
+	return value && typeof value === "object" && !Array.isArray(value) ? value as Record<string, unknown> : undefined;
+}
+
+function extractText(value: unknown): string {
+	if (typeof value === "string") return value;
+	if (Array.isArray(value)) {
+		return value
+			.map((item) => stringValue(objectValue(item)?.text, objectValue(item)?.content, item))
+			.filter((item): item is string => Boolean(item))
+			.join("\n");
+	}
+	const obj = objectValue(value);
+	if (!obj) return "";
+	return stringValue(obj.text, obj.content, obj.message, obj.result) ?? "";
+}
+
+function mapUsage(raw: Record<string, unknown>): Partial<AssistantMessage["usage"]> {
+	const input = Number(raw.input_tokens ?? raw.input ?? raw.prompt_tokens ?? 0);
+	const output = Number(raw.output_tokens ?? raw.output ?? raw.completion_tokens ?? 0);
+	const cacheRead = Number(raw.cache_read_input_tokens ?? raw.cacheRead ?? 0);
+	const cacheWrite = Number(raw.cache_creation_input_tokens ?? raw.cacheWrite ?? 0);
+	return {
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+	};
+}
+
+function normalizeToolArguments(input: unknown): Record<string, unknown> {
+	return objectValue(input) ?? { input };
+}
+
+function normalizeToolResult(raw: Record<string, unknown>): ExternalToolResult {
+	const text = extractText(raw.content ?? raw.result ?? raw.output);
+	return {
+		content: text ? [{ type: "text", text }] : [],
+		isError: Boolean(raw.is_error ?? raw.isError ?? raw.error),
+	};
+}
+
+export function parseCursorAgentLine(line: string): ParsedCursorAgentLine {
+	const trimmed = line.trim();
+	if (!trimmed) return { type: "ignore" };
+
+	let event: Record<string, unknown>;
+	try {
+		event = JSON.parse(trimmed) as Record<string, unknown>;
+	} catch {
+		return { type: "text", text: trimmed };
+	}
+
+	const type = stringValue(event.type, event.event) ?? "";
+	if (type === "error") {
+		return { type: "error", message: stringValue(event.message, event.error) ?? "cursor_agent_error" };
+	}
+
+	if (type === "tool_call") {
+		if (event.call_id || event.subtype || event.tool_call) return { type: "ignore" };
+
+		const id = stringValue(event.id, event.tool_call_id) ?? `cursor_tool_${Date.now()}`;
+		const name = stringValue(event.name, event.tool_name) ?? "cursor_tool";
+		return {
+			type: "tool_call",
+			toolCall: { type: "toolCall", id, name, arguments: normalizeToolArguments(event.input ?? event.arguments) },
+		};
+	}
+
+	if (type === "tool_result") {
+		return {
+			type: "tool_result",
+			toolCallId: stringValue(event.tool_call_id, event.id) ?? "",
+			result: normalizeToolResult(event),
+		};
+	}
+
+	if (type === "result") {
+		const usage = objectValue(event.usage);
+		return usage ? { type: "usage", usage: mapUsage(usage) } : { type: "ignore" };
+	}
+
+	const text = extractText(event.delta ?? event.text ?? event.content ?? objectValue(event.message)?.content ?? event.message);
+	if (text) return { type: "text", text };
+
+	const usage = objectValue(event.usage);
+	if (usage) return { type: "usage", usage: mapUsage(usage) };
+
+	return { type: "ignore" };
+}
+
+function createUsage(partial?: Partial<AssistantMessage["usage"]>): AssistantMessage["usage"] {
+	const input = partial?.input ?? 0;
+	const output = partial?.output ?? 0;
+	const cacheRead = partial?.cacheRead ?? 0;
+	const cacheWrite = partial?.cacheWrite ?? 0;
+	return {
+		...ZERO_USAGE,
+		input,
+		output,
+		cacheRead,
+		cacheWrite,
+		totalTokens: input + output + cacheWrite,
+		cost: { ...ZERO_USAGE.cost },
+	};
+}
+
+function buildAssistantMessage(
+	model: Model<Api>,
+	content: AssistantMessage["content"],
+	usage?: Partial<AssistantMessage["usage"]>,
+	stopReason: AssistantMessage["stopReason"] = "stop",
+	errorMessage?: string,
+): AssistantMessage {
+	return {
+		role: "assistant",
+		content,
+		api: model.api,
+		provider: model.provider,
+		model: model.id,
+		usage: createUsage(usage),
+		stopReason,
+		...(errorMessage ? { errorMessage } : {}),
+		timestamp: Date.now(),
+	};
+}
+
+function emitDone(stream: AssistantMessageEventStream, message: AssistantMessage, text: string): void {
+	stream.push({ type: "start", partial: { ...message, content: [] } });
+	if (text) {
+		stream.push({ type: "text_start", contentIndex: 0, partial: message });
+		stream.push({ type: "text_delta", contentIndex: 0, delta: text, partial: message });
+		stream.push({ type: "text_end", contentIndex: 0, content: text, partial: message });
+	}
+	message.content.forEach((block, index) => {
+		if (block.type !== "toolCall") return;
+		stream.push({ type: "toolcall_start", contentIndex: index, partial: message });
+		stream.push({ type: "toolcall_end", contentIndex: index, toolCall: block, partial: message });
+	});
+	stream.push({ type: "done", reason: "stop", message });
+	stream.end(message);
+}
+
+function emitError(stream: AssistantMessageEventStream, model: Model<Api>, error: unknown): void {
+	const message = error instanceof Error ? error.message : String(error);
+	const output = buildAssistantMessage(model, [], undefined, "error", message);
+	stream.push({ type: "error", reason: "error", error: output });
+	stream.end(output);
+}
+
+export function streamViaCursorAgent(
+	model: Model<Api>,
+	context: Context,
+	options?: CursorAgentStreamOptions,
+): AssistantMessageEventStream {
+	const stream = createAssistantMessageEventStream();
+
+	queueMicrotask(async () => {
+		try {
+			const cwd = options?.cwd || process.cwd();
+			const prompt = buildCursorPrompt(context);
+			const plan = buildCursorAgentRunPlan(model.id, prompt, cwd);
+			const runForTest = options?._cursorAgentRunnerForTest;
+			let text = "";
+			let usage: Partial<AssistantMessage["usage"]> | undefined;
+			let streamStarted = false;
+			let textStarted = false;
+			const toolCalls = new Map<string, ToolCall>();
+			const content: AssistantMessage["content"] = [];
+
+			const partialMessage = (): AssistantMessage => {
+				const partialContent: AssistantMessage["content"] = text ? [{ type: "text", text }, ...content] : [...content];
+				return buildAssistantMessage(model, partialContent, usage);
+			};
+			const ensureStart = () => {
+				if (streamStarted) return;
+				streamStarted = true;
+				stream.push({ type: "start", partial: buildAssistantMessage(model, []) });
+			};
+			const handleLine = (line: string): void => {
+				const parsed = parseCursorAgentLine(line);
+				if (parsed.type === "ignore") return;
+				if (parsed.type === "error") throw new Error(parsed.message);
+				if (parsed.type === "text") {
+					ensureStart();
+					if (!textStarted) {
+						textStarted = true;
+						stream.push({ type: "text_start", contentIndex: 0, partial: partialMessage() });
+					}
+					text += parsed.text;
+					stream.push({ type: "text_delta", contentIndex: 0, delta: parsed.text, partial: partialMessage() });
+					return;
+				}
+				if (parsed.type === "usage") {
+					usage = { ...(usage ?? {}), ...parsed.usage };
+					return;
+				}
+				if (parsed.type === "tool_call") {
+					ensureStart();
+					toolCalls.set(parsed.toolCall.id, parsed.toolCall);
+					content.push(parsed.toolCall);
+					const index = text ? content.length : content.length - 1;
+					const partial = partialMessage();
+					stream.push({ type: "toolcall_start", contentIndex: index, partial });
+					stream.push({ type: "toolcall_end", contentIndex: index, toolCall: parsed.toolCall, partial });
+					return;
+				}
+				if (parsed.type === "tool_result") {
+					const toolCall = toolCalls.get(parsed.toolCallId);
+					if (toolCall) toolCall.externalResult = parsed.result;
+				}
+			};
+
+			const result = runForTest
+				? await runForTest(plan, options, handleLine)
+				: await runCursorAgent(plan, options, handleLine);
+
+			if (runForTest) {
+				for (const line of result.stdout.split(/\r?\n/)) handleLine(line);
+			}
+
+			if (result.code !== 0) {
+				throw new Error((result.stderr || result.stdout || `cursor-agent exited with code ${result.code}`).trim());
+			}
+
+			const finalContent: AssistantMessage["content"] = text ? [{ type: "text", text }, ...content] : content;
+			const finalMessage = buildAssistantMessage(model, finalContent, usage);
+			if (!streamStarted) {
+				emitDone(stream, finalMessage, text);
+				return;
+			}
+			if (textStarted) stream.push({ type: "text_end", contentIndex: 0, content: text, partial: finalMessage });
+			stream.push({ type: "done", reason: "stop", message: finalMessage });
+			stream.end(finalMessage);
+		} catch (error) {
+			emitError(stream, model, error);
+		}
+	});
+
+	return stream;
+}