@opengsd/gsd-pi 1.3.0 → 1.4.0-dev.5fc22c6f

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

@@ -0,0 +1,166 @@
+import { test } from "node:test";
+import assert from "node:assert/strict";
+import type { Context, Model } from "@gsd/pi-ai";
+import {
+	buildCursorAgentRunPlan,
+	buildCursorPrompt,
+	buildCursorSpawnInvocation,
+	parseCursorAgentLine,
+	streamViaCursorAgent,
+} from "../stream-adapter.ts";
+
+const model = {
+	id: "composer-2.5",
+	name: "Composer 2.5",
+	api: "cursor-stream-json",
+	provider: "cursor-agent",
+	baseUrl: "local://cursor-agent",
+	reasoning: true,
+	input: ["text"],
+	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+	contextWindow: 1_000_000,
+	maxTokens: 64_000,
+} as Model<string>;
+
+const context = {
+	systemPrompt: "Be concise.",
+	messages: [{ role: "user", content: "Hello" }],
+	tools: [{ name: "gsd_plan_slice" }],
+} as Context;
+
+test("buildCursorAgentRunPlan invokes cursor-agent in stream-json prompt mode", () => {
+	const plan = buildCursorAgentRunPlan("composer-2.5", "Prompt", "/tmp/project", "linux");
+	assert.equal(plan.command, "cursor-agent");
+	assert.deepEqual(plan.args, ["-p", "Prompt", "--output-format", "stream-json", "--model", "composer-2.5", "--workspace", "/tmp/project", "--trust"]);
+});
+
+test("buildCursorSpawnInvocation uses cmd /c on Windows", () => {
+	assert.deepEqual(buildCursorSpawnInvocation("cursor-agent", ["--version"], "win32"), {
+		command: "cmd",
+		args: ["/c", "cursor-agent", "--version"],
+	});
+});
+
+test("buildCursorPrompt preserves system, message, and tool context", () => {
+	const prompt = buildCursorPrompt(context);
+	assert.match(prompt, /System instructions:\nBe concise\./);
+	assert.match(prompt, /User:\nHello/);
+	assert.match(prompt, /Requested GSD tools: gsd_plan_slice/);
+});
+
+test("parseCursorAgentLine maps text, legacy tool, result, usage, and errors", () => {
+	assert.deepEqual(parseCursorAgentLine('{"type":"assistant","message":{"content":[{"type":"text","text":"hi"}]}}'), {
+		type: "text",
+		text: "hi",
+	});
+	assert.deepEqual(parseCursorAgentLine('{"type":"tool_call","id":"tool_1","name":"edit","input":{"path":"a"}}'), {
+		type: "tool_call",
+		toolCall: { type: "toolCall", id: "tool_1", name: "edit", arguments: { path: "a" } },
+	});
+	assert.deepEqual(parseCursorAgentLine('{"type":"tool_result","tool_call_id":"tool_1","content":"ok","is_error":false}'), {
+		type: "tool_result",
+		toolCallId: "tool_1",
+		result: { content: [{ type: "text", text: "ok" }], isError: false },
+	});
+	assert.deepEqual(parseCursorAgentLine('{"type":"result","usage":{"input_tokens":3,"output_tokens":4}}'), {
+		type: "usage",
+		usage: { input: 3, output: 4, cacheRead: 0, cacheWrite: 0 },
+	});
+	assert.deepEqual(parseCursorAgentLine('{"type":"error","message":"boom"}'), { type: "error", message: "boom" });
+});
+
+test("parseCursorAgentLine ignores Cursor-owned nested tool events so GSD does not redispatch them", () => {
+	const started = parseCursorAgentLine(
+		'{"type":"tool_call","subtype":"started","call_id":"tool_1","tool_call":{"readToolCall":{"args":{"path":"a.ts"}}}}',
+	);
+
+	assert.deepEqual(started, { type: "ignore" });
+
+	const completed = parseCursorAgentLine(
+		'{"type":"tool_call","subtype":"completed","call_id":"tool_1","tool_call":{"readToolCall":{"args":{"path":"a.ts"}}},"result":{"content":"ok"}}',
+	);
+
+	assert.deepEqual(completed, { type: "ignore" });
+});
+
+test("streamViaCursorAgent does not surface Cursor-owned nested tool events as local tool calls", async () => {
+	const lines = [
+		'{"type":"assistant","message":{"content":[{"type":"text","text":"I will inspect the file."}]}}',
+		'{"type":"tool_call","subtype":"started","call_id":"tool_1","tool_call":{"readToolCall":{"args":{"path":"a.ts"}}}}',
+		'{"type":"tool_call","subtype":"completed","call_id":"tool_1","tool_call":{"readToolCall":{"args":{"path":"a.ts"}}},"result":{"content":"ok"}}',
+		'{"type":"assistant","message":{"content":[{"type":"text","text":"Done."}]}}',
+	];
+	const stream = streamViaCursorAgent(model, context, {
+		_cursorAgentRunnerForTest: async () => ({ stdout: `${lines.join("\n")}\n`, stderr: "", code: 0, signal: null }),
+	});
+
+	const events = [];
+	for await (const event of stream) events.push(event);
+
+	const done = events.find((event) => event.type === "done");
+	assert.ok(done && done.type === "done");
+	assert.ok(
+		!done.message.content.some((block) => block.type === "toolCall"),
+		"Cursor-owned internal tool events must not become local GSD tool calls",
+	);
+	assert.ok(!events.some((event) => event.type === "toolcall_start"));
+});
+
+test("streamViaCursorAgent emits complete stdout lines before cursor-agent exits", async () => {
+	let releaseRunner: (() => void) | undefined;
+	const stream = streamViaCursorAgent(model, context, {
+		_cursorAgentRunnerForTest: async (_plan, _options, onLine) => {
+			onLine('{"type":"assistant","message":{"content":[{"type":"text","text":"Live"}]}}');
+			await new Promise<void>((resolve) => { releaseRunner = resolve; });
+			return { stdout: "", stderr: "", code: 0, signal: null };
+		},
+	});
+
+	const iterator = stream[Symbol.asyncIterator]();
+	const firstDelta = (async () => {
+		for (;;) {
+			const next = await iterator.next();
+			if (next.done) return undefined;
+			if (next.value.type === "text_delta") return next.value;
+		}
+	})();
+
+	const event = await Promise.race([
+		firstDelta,
+		new Promise<undefined>((resolve) => setTimeout(resolve, 100)),
+	]);
+	assert.ok(event, "expected streamed text before runner completed");
+	assert.equal(event.type, "text_delta");
+	assert.equal(event.delta, "Live");
+
+	releaseRunner?.();
+	for (;;) {
+		const next = await iterator.next();
+		if (next.done) break;
+	}
+});
+
+test("streamViaCursorAgent turns NDJSON into assistant events with external tool results", async () => {
+	const lines = [
+		'{"type":"assistant","message":{"content":[{"type":"text","text":"Hi"}]}}',
+		'{"type":"tool_call","id":"tool_1","name":"edit","input":{"path":"a"}}',
+		'{"type":"tool_result","tool_call_id":"tool_1","content":"ok","is_error":false}',
+		'{"type":"result","usage":{"input_tokens":3,"output_tokens":4}}',
+	];
+	const stream = streamViaCursorAgent(model, context, {
+		_cursorAgentRunnerForTest: async () => ({ stdout: `${lines.join("\n")}\n`, stderr: "", code: 0, signal: null }),
+	});
+
+	const events = [];
+	for await (const event of stream) events.push(event);
+
+	const done = events.find((event) => event.type === "done");
+	assert.ok(done && done.type === "done");
+	assert.equal(done.message.content[0].type, "text");
+	assert.equal(done.message.content[0].text, "Hi");
+	const toolCall = done.message.content.find((block) => block.type === "toolCall");
+	assert.ok(toolCall && toolCall.type === "toolCall");
+	assert.deepEqual(toolCall.externalResult, { content: [{ type: "text", text: "ok" }], isError: false });
+	assert.equal(done.message.usage.input, 3);
+	assert.equal(done.message.usage.output, 4);
+});

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

@@ -20,7 +20,13 @@ const ZERO_USAGE = {
 	cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, total: 0 },
 };
 
-type GoogleCliProviderId = "google-gemini-cli" | "google-antigravity";
+export type GoogleCliProviderId = "google-gemini-cli" | "google-antigravity";
+
+export interface GoogleCliRunPlan {
+	command: string;
+	args: string[];
+	stdin?: string;
+}
 
 interface CliRunResult {
 	stdout: string;
@@ -29,6 +35,71 @@ interface CliRunResult {
 	signal: NodeJS.Signals | null;
 }
 
+const WINDOWS_CHILD_ENV_KEYS = new Set([
+	"ALLUSERSPROFILE",
+	"APPDATA",
+	"COMSPEC",
+	"COMMONPROGRAMFILES",
+	"COMMONPROGRAMFILES(X86)",
+	"FORCE_COLOR",
+	"HOME",
+	"HOMEDRIVE",
+	"HOMEPATH",
+	"LANG",
+	"LC_ALL",
+	"LOCALAPPDATA",
+	"NODE_EXTRA_CA_CERTS",
+	"NO_COLOR",
+	"NO_PROXY",
+	"PATHEXT",
+	"PATH",
+	"PROGRAMDATA",
+	"PROGRAMFILES",
+	"PROGRAMFILES(X86)",
+	"SSL_CERT_FILE",
+	"SYSTEMROOT",
+	"TEMP",
+	"TERM",
+	"TMP",
+	"TMPDIR",
+	"USER",
+	"USERNAME",
+	"USERPROFILE",
+	"WINDIR",
+	"XDG_CACHE_HOME",
+	"XDG_CONFIG_HOME",
+	"HTTP_PROXY",
+	"HTTPS_PROXY",
+]);
+
+const WINDOWS_CHILD_ENV_PREFIXES = [
+	"AGY_",
+	"ANTIGRAVITY_",
+	"CLOUDSDK_",
+	"GEMINI_",
+	"GOOGLE_",
+];
+
+export function buildGoogleCliChildEnv(
+	env: NodeJS.ProcessEnv = process.env,
+	platform: NodeJS.Platform = process.platform,
+): NodeJS.ProcessEnv {
+	if (platform !== "win32") return env;
+
+	const childEnv: NodeJS.ProcessEnv = {};
+	for (const [key, value] of Object.entries(env)) {
+		if (typeof value !== "string") continue;
+		const upperKey = key.toUpperCase();
+		if (
+			WINDOWS_CHILD_ENV_KEYS.has(upperKey) ||
+			WINDOWS_CHILD_ENV_PREFIXES.some((prefix) => upperKey.startsWith(prefix))
+		) {
+			childEnv[key] = value;
+		}
+	}
+	return childEnv;
+}
+
 function textBlocks(content: (TextContent | { type: string })[]): string {
 	return content
 		.map((block) => block.type === "text" ? (block as TextContent).text : `[${block.type} omitted]`)
@@ -120,15 +191,15 @@ function commandForProvider(provider: GoogleCliProviderId): string {
 	return provider === "google-gemini-cli" ? "gemini" : "agy";
 }
 
-function argsForProvider(provider: GoogleCliProviderId, model: Model<Api>, prompt: string): string[] {
+function argsForProvider(provider: GoogleCliProviderId, modelId: string, prompt?: string): string[] {
 	if (provider === "google-gemini-cli") {
-		const args = ["-p", prompt, "--output-format", "json"];
-		if (model.id !== "default") args.unshift("-m", model.id);
+		const args = prompt === undefined ? ["--output-format", "json"] : ["-p", prompt, "--output-format", "json"];
+		if (modelId !== "default") args.unshift("-m", modelId);
 		return args;
 	}
 
-	const args = ["-p", prompt];
-	if (model.id !== "default") args.unshift("-m", model.id);
+	const args = prompt === undefined ? [] : ["-p", prompt];
+	if (modelId !== "default") args.unshift("-m", modelId);
 	return args;
 }
 
@@ -136,20 +207,33 @@ export function buildGoogleCliSpawnInvocation(
 	command: string,
 	args: string[],
 	platform: NodeJS.Platform = process.platform,
-): { command: string; args: string[] } {
+): Omit<GoogleCliRunPlan, "stdin"> {
 	if (platform === "win32") {
 		return { command: "cmd", args: ["/c", command, ...args] };
 	}
 	return { command, args };
 }
 
-function runCli(command: string, args: string[], options?: SimpleStreamOptions): Promise<CliRunResult> {
+export function buildGoogleCliRunPlan(
+	provider: GoogleCliProviderId,
+	modelId: string,
+	prompt: string,
+	platform: NodeJS.Platform = process.platform,
+): GoogleCliRunPlan {
+	const pipePrompt = platform === "win32";
+	const args = argsForProvider(provider, modelId, pipePrompt ? undefined : prompt);
+	return {
+		...buildGoogleCliSpawnInvocation(commandForProvider(provider), args, platform),
+		...(pipePrompt ? { stdin: prompt } : {}),
+	};
+}
+
+function runCli(plan: GoogleCliRunPlan, options?: SimpleStreamOptions): Promise<CliRunResult> {
 	return new Promise((resolve, reject) => {
-		const invocation = buildGoogleCliSpawnInvocation(command, args);
-		const child = spawn(invocation.command, invocation.args, {
+		const child = spawn(plan.command, plan.args, {
 			cwd: options?.cwd || process.cwd(),
-			env: process.env,
-			stdio: ["ignore", "pipe", "pipe"],
+			env: buildGoogleCliChildEnv(),
+			stdio: [plan.stdin === undefined ? "ignore" : "pipe", "pipe", "pipe"],
 		});
 
 		let stdout = "";
@@ -174,12 +258,17 @@ function runCli(command: string, args: string[], options?: SimpleStreamOptions):
 		}
 		options?.signal?.addEventListener("abort", onAbort);
 
-		child.stdout.setEncoding("utf8");
-		child.stderr.setEncoding("utf8");
-		child.stdout.on("data", (chunk) => {
+		if (plan.stdin !== undefined) {
+			child.stdin?.on("error", () => {});
+			child.stdin?.end(plan.stdin);
+		}
+
+		child.stdout!.setEncoding("utf8");
+		child.stderr!.setEncoding("utf8");
+		child.stdout!.on("data", (chunk) => {
 			stdout += chunk;
 		});
-		child.stderr.on("data", (chunk) => {
+		child.stderr!.on("data", (chunk) => {
 			stderr += chunk;
 		});
 
@@ -243,9 +332,7 @@ export function streamViaGoogleCli(
 	queueMicrotask(async () => {
 		try {
 			const prompt = buildGoogleCliPrompt(context);
-			const command = commandForProvider(provider);
-			const args = argsForProvider(provider, model, prompt);
-			const result = await runCli(command, args, options);
+			const result = await runCli(buildGoogleCliRunPlan(provider, model.id, prompt), options);
 
 			if (result.code !== 0) {
 				const detail = (result.stderr || result.stdout || `CLI exited with code ${result.code}`).trim();

package/src/resources/extensions/gsd/activity-log.ts

@@ -16,6 +16,7 @@ import { GSDError, GSD_IO_ERROR } from "./errors.js";
 const SEQ_PREFIX_RE = /^(\d+)-/;
 import type { ExtensionContext } from "@gsd/pi-coding-agent";
 import { gsdRoot } from "./paths.js";
+import { redactSecrets } from "./redact-secrets.js";
 import { buildAuditEnvelope, emitUokAuditEvent } from "./uok/audit.js";
 import { isUnifiedAuditEnabled } from "./uok/audit-toggle.js";
 
@@ -127,7 +128,9 @@ export function saveActivityLog(
     const fd = openSync(filePath, "w");
     try {
       for (const entry of entries) {
-        writeSync(fd, JSON.stringify(entry) + "\n");
+        // Redact secret-shaped substrings before persisting; .gsd/ is skipped by
+        // the secret scanner, so raw LLM/tool content could otherwise leak keys.
+        writeSync(fd, redactSecrets(JSON.stringify(entry)) + "\n");
       }
     } finally {
       closeSync(fd);