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

package/dist/resources/extensions/cursor-cli/readiness.js

@@ -0,0 +1,128 @@
+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 = null;
+let cachedAuthed = null;
+let lastCheckMs = 0;
+export function getCursorAgentCommand(platform = process.platform) {
+    return platform === "win32" ? "cursor-agent.cmd" : "cursor-agent";
+}
+export function getCursorAgentCommandCandidates(platform = process.platform) {
+    const command = getCursorAgentCommand(platform);
+    return platform === "win32" ? [command, "cursor-agent.exe", "cursor-agent"] : [command];
+}
+export function buildCursorAgentSpawnInvocation(command, args, platform = process.platform) {
+    if (platform === "win32") {
+        return { command: "cmd", args: ["/c", command, ...args] };
+    }
+    return { command, args };
+}
+function debugLog(...parts) {
+    if (process.env.GSD_CURSOR_DEBUG) {
+        process.stderr.write(`[cursor-readiness] ${parts.map((part) => String(part)).join(" ")}\n`);
+    }
+}
+function spawnCursorAgent(command, args, timeout) {
+    const invocation = buildCursorAgentSpawnInvocation(command, args);
+    return execFileSync(invocation.command, invocation.args, { timeout, stdio: "pipe" });
+}
+function findWorkingCommand() {
+    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.message?.slice(0, 200));
+        }
+    }
+    return null;
+}
+export function parseCursorAgentStatus(output) {
+    const trimmed = output.trim();
+    if (!trimmed)
+        return null;
+    if (trimmed.startsWith("{")) {
+        try {
+            const parsed = JSON.parse(trimmed);
+            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) {
+    const trimmed = value?.trim();
+    return Boolean(trimmed && trimmed !== "cli");
+}
+function hasCursorApiKey() {
+    return isCursorAgentApiKeyValue(process.env.CURSOR_API_KEY);
+}
+function probeAuth(command) {
+    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.message?.slice(0, 200));
+        }
+    }
+    return null;
+}
+export function isCursorAgentReadyUncached() {
+    const command = findWorkingCommand();
+    if (!command)
+        return false;
+    return probeAuth(command) === true;
+}
+function refreshCache() {
+    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() {
+    refreshCache();
+    return cachedBinaryPresent ?? false;
+}
+export function isCursorAgentReady() {
+    refreshCache();
+    return (cachedBinaryPresent ?? false) && (cachedAuthed ?? false);
+}
+export function clearCursorAgentReadinessCache() {
+    cachedBinaryPresent = null;
+    cachedAuthed = null;
+    lastCheckMs = 0;
+}

package/dist/resources/extensions/cursor-cli/stream-adapter.js

@@ -0,0 +1,353 @@
+import { spawn } from "node:child_process";
+import { createAssistantMessageEventStream } from "@gsd/pi-ai";
+import { buildCursorAgentSpawnInvocation } from "./readiness.js";
+const ZERO_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) {
+    return content
+        .map((block) => block.type === "text" ? block.text : `[${block.type} omitted]`)
+        .join("\n");
+}
+function messageToText(message) {
+    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.type} omitted]`;
+        })
+            .join("\n");
+        return `Assistant:\n${text}`;
+    }
+    return `Tool result (${message.toolName}):\n${textBlocks(message.content)}`;
+}
+export function buildCursorPrompt(context) {
+    const parts = [];
+    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, args, platform = process.platform) {
+    return buildCursorAgentSpawnInvocation(command, args, platform);
+}
+export function buildCursorAgentRunPlan(modelId, prompt, cwd, platform = process.platform) {
+    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, pending, onLine) {
+    pending.value += chunk;
+    const lines = pending.value.split(/\r?\n/);
+    pending.value = lines.pop() ?? "";
+    for (const line of lines)
+        onLine(line);
+}
+function flushPendingLine(pending, onLine) {
+    if (!pending.value)
+        return;
+    onLine(pending.value);
+    pending.value = "";
+}
+function runCursorAgent(plan, options, onLine) {
+    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) => {
+            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) {
+    for (const value of values) {
+        if (typeof value === "string" && value.length > 0)
+            return value;
+    }
+    return undefined;
+}
+function objectValue(value) {
+    return value && typeof value === "object" && !Array.isArray(value) ? value : undefined;
+}
+function extractText(value) {
+    if (typeof value === "string")
+        return value;
+    if (Array.isArray(value)) {
+        return value
+            .map((item) => stringValue(objectValue(item)?.text, objectValue(item)?.content, item))
+            .filter((item) => Boolean(item))
+            .join("\n");
+    }
+    const obj = objectValue(value);
+    if (!obj)
+        return "";
+    return stringValue(obj.text, obj.content, obj.message, obj.result) ?? "";
+}
+function mapUsage(raw) {
+    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) {
+    return objectValue(input) ?? { input };
+}
+function normalizeToolResult(raw) {
+    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) {
+    const trimmed = line.trim();
+    if (!trimmed)
+        return { type: "ignore" };
+    let event;
+    try {
+        event = JSON.parse(trimmed);
+    }
+    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) {
+    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, content, usage, stopReason = "stop", errorMessage) {
+    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, message, text) {
+    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, model, error) {
+    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, context, options) {
+    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;
+            let streamStarted = false;
+            let textStarted = false;
+            const toolCalls = new Map();
+            const content = [];
+            const partialMessage = () => {
+                const partialContent = 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) => {
+                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 = 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;
+}

package/dist/resources/extensions/gsd/activity-log.js

@@ -13,6 +13,7 @@ import { join } from "node:path";
 import { GSDError, GSD_IO_ERROR } from "./errors.js";
 const SEQ_PREFIX_RE = /^(\d+)-/;
 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";
 const activityLogState = new Map();
@@ -104,7 +105,9 @@ export function saveActivityLog(ctx, basePath, unitType, unitId) {
         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 {