lsd-pi 1.2.4 → 1.3.6

package/dist/resources/extensions/subagent/launch-helpers.js

@@ -11,15 +11,29 @@ export function getBundledExtensionPathsFromEnv(env = process.env) {
     }
     return Array.from(unique);
 }
-export function buildSubagentProcessArgs(agent, task, tmpPromptPath, model) {
-    const args = ["--mode", "json", "-p", "--no-session"];
+export function buildSubagentProcessArgs(agent, task, tmpPromptPath, model, options) {
+    const mode = options?.mode ?? "json";
+    const args = ["--mode", mode];
+    if (mode === "json")
+        args.push("-p");
+    if (options?.noSession ?? true)
+        args.push("--no-session");
+    if (options?.parentSessionFile)
+        args.push("--parent-session", options.parentSessionFile);
+    args.push("--subagent-name", agent.name);
+    args.push("--subagent-task", task);
+    const uniqueTools = agent.tools?.filter((tool, index, all) => all.indexOf(tool) === index);
+    if (uniqueTools && uniqueTools.length > 0)
+        args.push("--subagent-tools", uniqueTools.join(","));
     if (model)
         args.push("--model", model);
-    const uniqueTools = agent.tools?.filter((tool, index, all) => all.indexOf(tool) === index);
     if (uniqueTools && uniqueTools.length > 0)
         args.push("--tools", uniqueTools.join(","));
-    if (tmpPromptPath)
+    if (tmpPromptPath) {
         args.push("--append-system-prompt", tmpPromptPath);
-    args.push(`Task: ${task}`);
+        args.push("--subagent-system-prompt-file", tmpPromptPath);
+    }
+    if (mode === "json")
+        args.push(`Task: ${task}`);
     return args;
 }

package/dist/resources/extensions/subagent/legacy-runner.js

@@ -0,0 +1,503 @@
+import { spawn, execFileSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as os from "node:os";
+import * as path from "node:path";
+import { getAgentDir } from "@gsd/pi-coding-agent";
+import { buildSubagentProcessArgs, getBundledExtensionPathsFromEnv } from "./launch-helpers.js";
+import { handleSubagentPermissionRequest, isSubagentPermissionRequest } from "./approval-proxy.js";
+import { resolveConfiguredSubagentModel } from "./configured-model.js";
+import { normalizeSubagentModel, resolveSubagentModel } from "./model-resolution.js";
+import { loadEffectivePreferences } from "../shared/preferences.js";
+const liveSubagentProcesses = new Set();
+export function readBudgetSubagentModelFromSettings() {
+    try {
+        const settingsPath = path.join(getAgentDir(), "settings.json");
+        if (!fs.existsSync(settingsPath))
+            return undefined;
+        const raw = fs.readFileSync(settingsPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        return typeof parsed.budgetSubagentModel === "string"
+            ? normalizeSubagentModel(parsed.budgetSubagentModel)
+            : undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+export async function stopLegacySubagents() {
+    const active = Array.from(liveSubagentProcesses);
+    if (active.length === 0)
+        return;
+    for (const proc of active) {
+        try {
+            proc.kill("SIGTERM");
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    await Promise.all(active.map((proc) => new Promise((resolve) => {
+        const done = () => resolve();
+        const timer = setTimeout(done, 500);
+        proc.once("exit", () => {
+            clearTimeout(timer);
+            resolve();
+        });
+    })));
+    for (const proc of active) {
+        if (proc.exitCode === null) {
+            try {
+                proc.kill("SIGKILL");
+            }
+            catch {
+                /* ignore */
+            }
+        }
+    }
+}
+function listSessionFiles(sessionDir) {
+    if (!fs.existsSync(sessionDir))
+        return [];
+    try {
+        return fs
+            .readdirSync(sessionDir)
+            .filter((name) => name.endsWith(".jsonl"))
+            .map((name) => path.join(sessionDir, name));
+    }
+    catch {
+        return [];
+    }
+}
+function detectNewSubagentSessionFile(sessionDir, before, startedAt) {
+    const after = listSessionFiles(sessionDir);
+    const created = after.filter((file) => !before.has(file));
+    const candidates = created.length > 0 ? created : after;
+    const ranked = candidates
+        .map((file) => {
+        let mtime = 0;
+        try {
+            mtime = fs.statSync(file).mtimeMs;
+        }
+        catch {
+            mtime = 0;
+        }
+        return { file, mtime };
+    })
+        .filter((entry) => entry.mtime >= startedAt - 5000)
+        .sort((a, b) => b.mtime - a.mtime);
+    return ranked[0]?.file;
+}
+function resolveSubagentCliPath(defaultCwd) {
+    const candidates = [process.env.GSD_BIN_PATH, process.env.LSD_BIN_PATH, process.argv[1]]
+        .map((value) => value?.trim())
+        .filter((value) => Boolean(value && value !== "undefined"));
+    for (const candidate of candidates) {
+        if (path.isAbsolute(candidate) && fs.existsSync(candidate))
+            return candidate;
+    }
+    const cwdCandidates = [path.join(defaultCwd, "dist", "loader.js"), path.join(defaultCwd, "scripts", "dev-cli.js")];
+    for (const candidate of cwdCandidates) {
+        if (fs.existsSync(candidate))
+            return candidate;
+    }
+    for (const binName of ["lsd", "gsd"]) {
+        try {
+            const resolved = execFileSync("which", [binName], { encoding: "utf-8" }).trim();
+            if (resolved)
+                return resolved;
+        }
+        catch {
+            /* ignore */
+        }
+    }
+    return null;
+}
+function processSubagentEventLine(line, currentResult, emitUpdate, proc, onSessionInfo, onEventType, onParsedEvent) {
+    if (!line.trim())
+        return false;
+    let event;
+    try {
+        event = JSON.parse(line);
+    }
+    catch {
+        return false;
+    }
+    const eventType = typeof event.type === "string" ? event.type : "unknown";
+    onEventType?.(eventType);
+    onParsedEvent?.(event);
+    if (event.type === "subagent_session_info") {
+        let changed = false;
+        if (typeof event.sessionFile === "string" && event.sessionFile) {
+            if (currentResult.sessionFile !== event.sessionFile)
+                changed = true;
+            currentResult.sessionFile = event.sessionFile;
+        }
+        if (typeof event.parentSessionFile === "string" && event.parentSessionFile) {
+            if (currentResult.parentSessionFile !== event.parentSessionFile)
+                changed = true;
+            currentResult.parentSessionFile = event.parentSessionFile;
+        }
+        if (changed) {
+            onSessionInfo?.({
+                sessionFile: currentResult.sessionFile,
+                parentSessionFile: currentResult.parentSessionFile,
+            });
+        }
+        return false;
+    }
+    if (proc && isSubagentPermissionRequest(event)) {
+        void handleSubagentPermissionRequest(event, proc);
+        return false;
+    }
+    if ((event.type === "message_end" || event.type === "turn_end") && event.message) {
+        const msg = event.message;
+        currentResult.messages.push(msg);
+        if (msg.role === "assistant") {
+            currentResult.usage.turns++;
+            const usage = msg.usage;
+            if (usage) {
+                currentResult.usage.input += usage.input || 0;
+                currentResult.usage.output += usage.output || 0;
+                currentResult.usage.cacheRead += usage.cacheRead || 0;
+                currentResult.usage.cacheWrite += usage.cacheWrite || 0;
+                currentResult.usage.cost += usage.cost?.total || 0;
+                currentResult.usage.contextTokens = usage.totalTokens || 0;
+            }
+            if (msg.model && (!currentResult.model || msg.model.includes("/")))
+                currentResult.model = msg.model;
+            if (msg.stopReason)
+                currentResult.stopReason = msg.stopReason;
+            if (msg.errorMessage)
+                currentResult.errorMessage = msg.errorMessage;
+        }
+        emitUpdate();
+    }
+    if (event.type === "tool_result_end" && event.message) {
+        currentResult.messages.push(event.message);
+        emitUpdate();
+    }
+    return event.type === "agent_end";
+}
+function writePromptToTempFile(agentName, prompt) {
+    const tmpDir = fs.mkdtempSync(path.join(os.tmpdir(), "pi-subagent-"));
+    const safeName = agentName.replace(/[^\w.-]+/g, "_");
+    const filePath = path.join(tmpDir, `prompt-${safeName}.md`);
+    fs.writeFileSync(filePath, prompt, { encoding: "utf-8", mode: 0o600 });
+    return { dir: tmpDir, filePath };
+}
+function getFinalOutput(messages) {
+    for (let i = messages.length - 1; i >= 0; i--) {
+        const msg = messages[i];
+        if (msg.role === "assistant") {
+            for (const part of msg.content) {
+                if (part.type === "text")
+                    return part.text;
+            }
+        }
+    }
+    return "";
+}
+export async function runLegacySingleAgent(defaultCwd, agents, agentName, task, cwd, step, modelOverride, parentModel, signal, onUpdate, makeDetails, parentSessionFile, attachableSession, onSessionInfo, onSubagentEvent, foregroundHooks) {
+    const agent = agents.find((a) => a.name === agentName);
+    if (!agent) {
+        const available = agents.map((a) => `"${a.name}"`).join(", ") || "none";
+        return {
+            agent: agentName,
+            agentSource: "unknown",
+            task,
+            exitCode: 1,
+            messages: [],
+            stderr: `Unknown agent: "${agentName}". Available agents: ${available}.`,
+            usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+            step,
+        };
+    }
+    let tmpPromptDir = null;
+    let tmpPromptPath = null;
+    const preferences = loadEffectivePreferences()?.preferences;
+    const settingsBudgetModel = readBudgetSubagentModelFromSettings();
+    const resolvedModel = resolveConfiguredSubagentModel(agent, preferences, settingsBudgetModel);
+    const inferredModel = resolveSubagentModel({ name: agent.name, model: resolvedModel }, { overrideModel: modelOverride, parentModel });
+    const currentResult = {
+        agent: agentName,
+        agentSource: agent.source,
+        task,
+        exitCode: 0,
+        messages: [],
+        stderr: "",
+        usage: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0, cost: 0, contextTokens: 0, turns: 0 },
+        model: inferredModel,
+        step,
+        parentSessionFile,
+    };
+    const emitUpdate = () => {
+        if (onUpdate) {
+            onUpdate({
+                content: [{ type: "text", text: getFinalOutput(currentResult.messages) || "(running...)" }],
+                details: makeDetails([currentResult]),
+            });
+        }
+    };
+    let wasAborted = false;
+    let deferTempPromptCleanup = false;
+    let tempPromptCleanupDone = false;
+    const cleanupTempPromptFiles = () => {
+        if (tempPromptCleanupDone)
+            return;
+        tempPromptCleanupDone = true;
+        if (tmpPromptPath)
+            try {
+                fs.unlinkSync(tmpPromptPath);
+            }
+            catch {
+                /* ignore */
+            }
+        if (tmpPromptDir)
+            try {
+                fs.rmdirSync(tmpPromptDir);
+            }
+            catch {
+                /* ignore */
+            }
+    };
+    try {
+        if (agent.systemPrompt.trim()) {
+            const tmp = writePromptToTempFile(agent.name, agent.systemPrompt);
+            tmpPromptDir = tmp.dir;
+            tmpPromptPath = tmp.filePath;
+        }
+        const effectiveCwd = cwd ?? defaultCwd;
+        const subagentSessionDir = parentSessionFile ? path.dirname(parentSessionFile) : undefined;
+        const sessionFilesBefore = attachableSession && subagentSessionDir
+            ? new Set(listSessionFiles(subagentSessionDir))
+            : undefined;
+        const launchStartedAt = Date.now();
+        const args = buildSubagentProcessArgs(agent, task, tmpPromptPath, inferredModel, {
+            noSession: !attachableSession,
+            parentSessionFile: parentSessionFile,
+            mode: attachableSession ? "rpc" : "json",
+        });
+        const exitCode = await new Promise((resolve) => {
+            const bundledPaths = getBundledExtensionPathsFromEnv();
+            const extensionArgs = bundledPaths.flatMap((p) => ["--extension", p]);
+            const cliPath = resolveSubagentCliPath(effectiveCwd);
+            if (!cliPath) {
+                currentResult.stderr += "Unable to resolve LSD/GSD CLI path for subagent launch.";
+                resolve(1);
+                return;
+            }
+            const proc = spawn(process.execPath, [cliPath, ...extensionArgs, ...args], { cwd: effectiveCwd, shell: false, stdio: ["pipe", "pipe", "pipe"] });
+            liveSubagentProcesses.add(proc);
+            let buffer = "";
+            let completionSeen = false;
+            let resolved = false;
+            let foregroundReleased = false;
+            let isBusy = false;
+            let commandSeq = 0;
+            const pendingCommandResponses = new Map();
+            const procAbortController = new AbortController();
+            let resolveBackgroundResult;
+            let rejectBackgroundResult;
+            const backgroundResultPromise = new Promise((resolveBg, rejectBg) => {
+                resolveBackgroundResult = resolveBg;
+                rejectBackgroundResult = rejectBg;
+            });
+            const sendRpcCommand = async (command) => {
+                const id = `sa_cmd_${++commandSeq}`;
+                if (!proc.stdin)
+                    throw new Error("Subagent RPC stdin is not available.");
+                return new Promise((resolveCmd, rejectCmd) => {
+                    pendingCommandResponses.set(id, { resolve: resolveCmd, reject: rejectCmd });
+                    proc.stdin.write(JSON.stringify({ id, ...command }) + "\n");
+                });
+            };
+            const finishForeground = (code) => {
+                if (resolved)
+                    return;
+                resolved = true;
+                resolve(code);
+            };
+            const adoptToBackground = (jobId) => {
+                if (resolved || foregroundReleased)
+                    return false;
+                foregroundReleased = true;
+                deferTempPromptCleanup = true;
+                currentResult.backgroundJobId = jobId;
+                finishForeground(0);
+                return true;
+            };
+            backgroundResultPromise.finally(() => {
+                if (deferTempPromptCleanup)
+                    cleanupTempPromptFiles();
+            });
+            foregroundHooks?.onStart?.({
+                agentName,
+                task,
+                cwd: cwd ?? defaultCwd,
+                parentSessionFile,
+                abortController: procAbortController,
+                resultPromise: backgroundResultPromise,
+                adoptToBackground,
+                sendPrompt: attachableSession
+                    ? async (text, images) => {
+                        await sendRpcCommand({ type: "prompt", message: text, images });
+                    }
+                    : undefined,
+                sendSteer: attachableSession
+                    ? async (text, images) => {
+                        await sendRpcCommand({ type: "steer", message: text, images });
+                    }
+                    : undefined,
+                sendFollowUp: attachableSession
+                    ? async (text, images) => {
+                        await sendRpcCommand({ type: "follow_up", message: text, images });
+                    }
+                    : undefined,
+                isBusy: attachableSession ? () => isBusy : undefined,
+            });
+            proc.stdout.on("data", (data) => {
+                buffer += data.toString();
+                const lines = buffer.split("\n");
+                buffer = lines.pop() || "";
+                for (const line of lines) {
+                    const trimmed = line.trim();
+                    if (!trimmed)
+                        continue;
+                    if (attachableSession) {
+                        try {
+                            const parsed = JSON.parse(trimmed);
+                            if (parsed?.type === "response" && typeof parsed.id === "string" && pendingCommandResponses.has(parsed.id)) {
+                                const pending = pendingCommandResponses.get(parsed.id);
+                                pendingCommandResponses.delete(parsed.id);
+                                if (parsed.success === false) {
+                                    pending.reject(new Error(typeof parsed.error === "string" ? parsed.error : "Subagent RPC command failed."));
+                                }
+                                else {
+                                    pending.resolve(parsed.data);
+                                }
+                                continue;
+                            }
+                        }
+                        catch {
+                            // Fall through to generic event processing.
+                        }
+                    }
+                    if (processSubagentEventLine(trimmed, currentResult, emitUpdate, proc, onSessionInfo, (eventType) => {
+                        if (eventType === "agent_start")
+                            isBusy = true;
+                        if (eventType === "agent_end")
+                            isBusy = false;
+                    }, (event) => onSubagentEvent?.(event, currentResult))) {
+                        completionSeen = true;
+                        try {
+                            proc.kill("SIGTERM");
+                        }
+                        catch {
+                            /* ignore */
+                        }
+                    }
+                }
+            });
+            proc.stderr.on("data", (data) => {
+                currentResult.stderr += data.toString();
+            });
+            proc.on("close", (code) => {
+                liveSubagentProcesses.delete(proc);
+                if (buffer.trim()) {
+                    const completedOnFlush = processSubagentEventLine(buffer, currentResult, emitUpdate, proc, onSessionInfo, (eventType) => {
+                        if (eventType === "agent_start")
+                            isBusy = true;
+                        if (eventType === "agent_end")
+                            isBusy = false;
+                    }, (event) => onSubagentEvent?.(event, currentResult));
+                    completionSeen = completionSeen || completedOnFlush;
+                }
+                isBusy = false;
+                for (const pending of pendingCommandResponses.values()) {
+                    pending.reject(new Error("Subagent process closed before command response."));
+                }
+                pendingCommandResponses.clear();
+                const finalExitCode = completionSeen && (code === null || code === 143 || code === 15) ? 0 : (code ?? 0);
+                currentResult.exitCode = finalExitCode;
+                if (attachableSession && sessionFilesBefore && subagentSessionDir && !currentResult.sessionFile) {
+                    const detected = detectNewSubagentSessionFile(subagentSessionDir, sessionFilesBefore, launchStartedAt);
+                    if (detected)
+                        currentResult.sessionFile = detected;
+                }
+                resolveBackgroundResult?.({
+                    summary: getFinalOutput(currentResult.messages),
+                    stderr: currentResult.stderr,
+                    exitCode: finalExitCode,
+                    model: currentResult.model,
+                    sessionFile: currentResult.sessionFile,
+                    parentSessionFile: currentResult.parentSessionFile,
+                });
+                foregroundHooks?.onFinish?.();
+                finishForeground(finalExitCode);
+            });
+            proc.on("error", (error) => {
+                liveSubagentProcesses.delete(proc);
+                isBusy = false;
+                for (const pending of pendingCommandResponses.values()) {
+                    pending.reject(error instanceof Error ? error : new Error(String(error)));
+                }
+                pendingCommandResponses.clear();
+                rejectBackgroundResult?.(error);
+                foregroundHooks?.onFinish?.();
+                finishForeground(1);
+            });
+            if (attachableSession) {
+                void sendRpcCommand({ type: "prompt", message: task }).catch((error) => {
+                    currentResult.stderr += error instanceof Error ? error.message : String(error);
+                    try {
+                        proc.kill("SIGTERM");
+                    }
+                    catch {
+                        /* ignore */
+                    }
+                });
+            }
+            const killProc = () => {
+                wasAborted = true;
+                procAbortController.abort();
+                proc.kill("SIGTERM");
+                setTimeout(() => {
+                    if (!proc.killed)
+                        proc.kill("SIGKILL");
+                }, 5000);
+            };
+            if (signal) {
+                if (signal.aborted)
+                    killProc();
+                else
+                    signal.addEventListener("abort", killProc, { once: true });
+            }
+            if (procAbortController.signal.aborted) {
+                killProc();
+            }
+            else {
+                procAbortController.signal.addEventListener("abort", () => {
+                    proc.kill("SIGTERM");
+                    setTimeout(() => {
+                        if (!proc.killed)
+                            proc.kill("SIGKILL");
+                    }, 5000);
+                }, { once: true });
+            }
+        });
+        currentResult.exitCode = exitCode;
+        if (attachableSession && sessionFilesBefore && subagentSessionDir) {
+            const detected = detectNewSubagentSessionFile(subagentSessionDir, sessionFilesBefore, launchStartedAt);
+            if (detected) {
+                currentResult.sessionFile = detected;
+            }
+        }
+        if (wasAborted)
+            throw new Error("Subagent was aborted");
+        return currentResult;
+    }
+    finally {
+        if (!deferTempPromptCleanup)
+            cleanupTempPromptFiles();
+    }
+}