@cjhyy/code-shell-core 0.6.0-rc.9 → 0.7.0

package/dist/cc-orchestrator/external-agent-driver.js

@@ -1,69 +1,284 @@
-import { spawn } from "node:child_process";
+import { execFile, spawn } from "node:child_process";
 import { createInterface } from "node:readline";
 import { pathWithCommonBins } from "./cc-capability.js";
+import { killProcessGroup } from "../runtime/spawn-common.js";
 /** Pure: reduce collected output lines + exit code to a result. Unit-testable. */
 export function runWithLines(adapter, lines, exitCode) {
     const parsed = adapter.parseResult(lines);
     return { ...parsed, exitCode, lines };
 }
-/** Spawn ONE headless agent run, collect stream-json to exit, return result.
- *  No time concept — a single turn. Honors AbortSignal (kills the child). */
-export function runAgentOnce(adapter, opts, signal) {
-    return new Promise((resolve, reject) => {
-        const args = adapter.buildArgs({
-            prompt: opts.prompt,
-            resumeSessionId: opts.resumeSessionId,
-            permissionMode: opts.permissionMode ?? "default",
-            cwd: opts.cwd,
-        });
-        // claude takes the prompt in argv (`-p <prompt>`) and wants stdin closed
-        // (verified: avoids a 3s wait). codex `exec` reads the prompt from stdin
-        // (argv ends with `-`), so adapters that set promptViaStdin get a piped
-        // stdin we write the prompt to.
-        const viaStdin = adapter.promptViaStdin === true;
-        const child = spawn(opts.command, args, {
-            cwd: opts.cwd,
-            env: { ...process.env, PATH: pathWithCommonBins() },
-            // NOT detached: this child is owned by the (long-lived) worker that reads
-            // its stdout. Detaching orphaned it across a worker/app restart — the
-            // reader promise then never resolved and the completion notification never
-            // fired (the "后台任务没返回" bug). Bound to the worker, it lives or dies
-            // with the process that's actually listening for its result.
-            detached: false,
-            stdio: [viaStdin ? "pipe" : "ignore", "pipe", "pipe"],
+const codexImageFlagCache = new Map();
+const CODEX_IMAGE_PROBE_TIMEOUT_MS = 5_000;
+const AGENT_TERMINATE_GRACE_MS = 500;
+function listPosixProcessTree(rootPid) {
+    return new Promise((resolve) => {
+        execFile("ps", ["-axo", "pid=,ppid="], { encoding: "utf8" }, (err, stdout) => {
+            if (err) {
+                resolve([rootPid]);
+                return;
+            }
+            const childrenByParent = new Map();
+            for (const line of stdout.split("\n")) {
+                const [pidText, parentText] = line.trim().split(/\s+/, 2);
+                const pid = Number(pidText);
+                const parentPid = Number(parentText);
+                if (!Number.isInteger(pid) || !Number.isInteger(parentPid))
+                    continue;
+                const children = childrenByParent.get(parentPid) ?? [];
+                children.push(pid);
+                childrenByParent.set(parentPid, children);
+            }
+            const pids = [];
+            const visit = (pid) => {
+                if (pids.includes(pid))
+                    return;
+                pids.push(pid);
+                for (const childPid of childrenByParent.get(pid) ?? [])
+                    visit(childPid);
+            };
+            visit(rootPid);
+            resolve(pids);
         });
-        if (viaStdin && child.stdin) {
-            child.stdin.end(opts.prompt);
+    });
+}
+function isPidAlive(pid) {
+    try {
+        process.kill(pid, 0);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function delay(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+async function waitForPidsToExit(pids, timeoutMs) {
+    const deadline = Date.now() + timeoutMs;
+    while ([...pids].some(isPidAlive)) {
+        if (Date.now() >= deadline)
+            return false;
+        await delay(25);
+    }
+    return true;
+}
+function signalPids(pids, killSignal) {
+    for (const pid of pids) {
+        try {
+            process.kill(pid, killSignal);
         }
-        const lines = [];
-        if (child.stdout) {
-            const rl = createInterface({ input: child.stdout });
-            rl.on("line", (line) => lines.push(line));
+        catch {
+            // already gone
         }
-        // Not detached → no own process group, so kill the child directly (a
-        // negative-pid group kill would target the worker's group). claude has no
-        // long-lived child tree of its own here, so a direct SIGTERM is sufficient.
-        const onAbort = () => {
+    }
+}
+async function terminateAttachedProcessTree(child) {
+    const pid = child.pid;
+    if (!pid) {
+        try {
+            child.kill("SIGKILL");
+        }
+        catch {
+            // already gone
+        }
+        return;
+    }
+    if (process.platform === "win32") {
+        // Windows has no POSIX SIGTERM semantics or negative-pid groups. Reap the
+        // tree via taskkill, then use positive-pid process.kill as the fallback the
+        // platform supports when taskkill is unavailable/races.
+        await killProcessGroup(pid, { graceMs: AGENT_TERMINATE_GRACE_MS });
+        if (isPidAlive(pid)) {
             try {
-                child.kill("SIGTERM");
+                process.kill(pid);
             }
-            catch { /* already gone */ }
-        };
-        signal?.addEventListener("abort", onAbort, { once: true });
-        child.on("error", (err) => {
+            catch {
+                // already gone
+            }
+        }
+        return;
+    }
+    const trackedPids = new Set(await listPosixProcessTree(pid));
+    signalPids(trackedPids, "SIGTERM");
+    if (await waitForPidsToExit(trackedPids, AGENT_TERMINATE_GRACE_MS))
+        return;
+    // Capture descendants created during the grace window while the leader is
+    // still addressable, but retain the first snapshot so reparented stubborn
+    // descendants cannot disappear from the escalation set.
+    for (const treePid of await listPosixProcessTree(pid))
+        trackedPids.add(treePid);
+    signalPids(trackedPids, "SIGKILL");
+    await waitForPidsToExit(trackedPids, 1_000);
+}
+function abortError() {
+    const err = new Error("Agent run aborted");
+    err.name = "AbortError";
+    return err;
+}
+function throwIfAborted(signal) {
+    if (signal?.aborted)
+        throw abortError();
+}
+function createCodexImageProbe(command, cwd, signal) {
+    return new Promise((resolve, reject) => {
+        if (signal?.aborted) {
+            reject(abortError());
+            return;
+        }
+        const child = spawn(command, ["exec", "--help"], {
+            cwd,
+            env: { ...process.env, PATH: pathWithCommonBins() },
+            windowsHide: true,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let out = "";
+        let settled = false;
+        let terminating = false;
+        const cleanup = () => {
+            clearTimeout(timer);
             signal?.removeEventListener("abort", onAbort);
-            // A missing binary is the most common failure (user hasn't installed the
-            // CLI, or GUI-launched Electron's PATH misses it). Turn the cryptic
-            // "spawn codex ENOENT" into something actionable that names the command.
-            if (err.code === "ENOENT") {
-                reject(new Error(`未找到命令 "${opts.command}"。请先安装该 CLI 并确保它在 PATH 中（${adapter.kind === "codex" ? "Codex CLI" : "Claude Code CLI"}）。`));
+        };
+        const done = (value) => {
+            if (settled)
                 return;
-            }
+            settled = true;
+            cleanup();
+            resolve(value);
+        };
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            cleanup();
             reject(err);
+        };
+        const onAbort = () => {
+            if (settled || terminating)
+                return;
+            terminating = true;
+            cleanup();
+            void terminateAttachedProcessTree(child).then(() => fail(abortError()));
+        };
+        const timer = setTimeout(() => {
+            if (settled || terminating)
+                return;
+            terminating = true;
+            cleanup();
+            void terminateAttachedProcessTree(child).then(() => done(false));
+        }, CODEX_IMAGE_PROBE_TIMEOUT_MS);
+        signal?.addEventListener("abort", onAbort, { once: true });
+        if (signal?.aborted)
+            onAbort();
+        child.stdout?.on("data", (chunk) => {
+            out += chunk.toString("utf8");
         });
-        child.on("exit", (code) => {
-            signal?.removeEventListener("abort", onAbort);
-            resolve(runWithLines(adapter, lines, code));
+        child.stderr?.on("data", (chunk) => {
+            out += chunk.toString("utf8");
+        });
+        child.on("error", () => {
+            if (!terminating)
+                done(false);
+        });
+        child.on("exit", () => {
+            if (!terminating)
+                done(/(?:^|\s)-i(?:,|\s)|--image\b/.test(out));
         });
     });
 }
+export function detectCodexImageInput(command, cwd, signal) {
+    if (signal)
+        return createCodexImageProbe(command, cwd, signal);
+    const cached = codexImageFlagCache.get(command);
+    if (cached)
+        return cached;
+    const probe = createCodexImageProbe(command, cwd);
+    codexImageFlagCache.set(command, probe);
+    return probe;
+}
+/** Spawn ONE headless agent run, collect stream-json to exit, return result.
+ *  No time concept — a single turn. Honors AbortSignal (kills the child). */
+export function runAgentOnce(adapter, opts, signal) {
+    return new Promise((resolve, reject) => {
+        void (async () => {
+            throwIfAborted(signal);
+            const codexImageInputSupported = adapter.kind === "codex" && (opts.imagePaths?.length ?? 0) > 0
+                ? await detectCodexImageInput(opts.command, opts.cwd, signal).catch((err) => {
+                    if (signal?.aborted || err?.name === "AbortError")
+                        throw err;
+                    return false;
+                })
+                : false;
+            throwIfAborted(signal);
+            const args = adapter.buildArgs({
+                prompt: opts.prompt,
+                resumeSessionId: opts.resumeSessionId,
+                model: opts.model,
+                permissionMode: opts.permissionMode ?? "default",
+                cwd: opts.cwd,
+                imagePaths: opts.imagePaths,
+                codexImageInputSupported,
+            });
+            throwIfAborted(signal);
+            // claude takes the prompt in argv (`-p <prompt>`) and wants stdin closed
+            // (verified: avoids a 3s wait). codex `exec` reads the prompt from stdin
+            // (argv ends with `-`), so adapters that set promptViaStdin get a piped
+            // stdin we write the prompt to.
+            const viaStdin = adapter.promptViaStdin === true;
+            const child = spawn(opts.command, args, {
+                cwd: opts.cwd,
+                env: { ...process.env, PATH: pathWithCommonBins() },
+                // Keep the agent in the owning worker/app process group. If that owner
+                // is force-terminated, the CLI and its descendants must not escape into
+                // a detached group that can keep editing the workspace unseen.
+                detached: false,
+                stdio: [viaStdin ? "pipe" : "ignore", "pipe", "pipe"],
+            });
+            let settled = false;
+            let abortRequested = false;
+            let termination;
+            const cleanup = () => {
+                signal?.removeEventListener("abort", onAbort);
+            };
+            const onAbort = () => {
+                if (abortRequested)
+                    return;
+                abortRequested = true;
+                termination = terminateAttachedProcessTree(child);
+            };
+            signal?.addEventListener("abort", onAbort, { once: true });
+            if (signal?.aborted)
+                onAbort();
+            if (viaStdin && child.stdin) {
+                child.stdin.end(opts.prompt);
+            }
+            const lines = [];
+            if (child.stdout) {
+                const rl = createInterface({ input: child.stdout });
+                rl.on("line", (line) => lines.push(line));
+            }
+            child.on("error", (err) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                // A missing binary is the most common failure (user hasn't installed the
+                // CLI, or GUI-launched Electron's PATH misses it). Turn the cryptic
+                // "spawn codex ENOENT" into something actionable that names the command.
+                if (err.code === "ENOENT") {
+                    reject(new Error(`未找到命令 "${opts.command}"。请先安装该 CLI 并确保它在 PATH 中（${adapter.kind === "codex" ? "Codex CLI" : "Claude Code CLI"}）。`));
+                    return;
+                }
+                reject(err);
+            });
+            child.on("exit", (code) => {
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                void (termination ?? Promise.resolve()).then(() => {
+                    resolve(runWithLines(adapter, lines, code));
+                });
+            });
+        })().catch(reject);
+    });
+}

package/dist/cc-orchestrator/external-agent-session-store.d.ts

@@ -0,0 +1,23 @@
+export type ExternalAgentCli = "claude" | "codex";
+export interface ExternalAgentSessionBinding {
+    cli: ExternalAgentCli;
+    sessionId: string;
+    cwd: string;
+    worktreePath?: string;
+    worktreeBranch?: string;
+    updatedAt: number;
+}
+export type ExternalAgentSessionRecord = Omit<ExternalAgentSessionBinding, "updatedAt"> & {
+    updatedAt?: number;
+};
+export declare function defaultExternalAgentSessionStorePath(): string;
+export declare class ExternalAgentSessionStore {
+    private readonly file;
+    constructor(file?: string);
+    get(cli: ExternalAgentCli, sessionId: string): ExternalAgentSessionBinding | undefined;
+    record(binding: ExternalAgentSessionRecord): void;
+    private load;
+    private save;
+    private withLock;
+}
+export declare const externalAgentSessionStore: ExternalAgentSessionStore;

package/dist/cc-orchestrator/external-agent-session-store.js

@@ -0,0 +1,146 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, rmSync, statSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { codeShellHome } from "../session/session-manager.js";
+import { logger } from "../logging/logger.js";
+import { normalizeCwdPath } from "./cwd-normalize.js";
+const LOCK_WAIT_MS = 5_000;
+const LOCK_STALE_MS = 30_000;
+const LOCK_POLL_MS = 10;
+export function defaultExternalAgentSessionStorePath() {
+    return join(codeShellHome(), "external-agent-sessions.json");
+}
+export class ExternalAgentSessionStore {
+    file;
+    constructor(file = defaultExternalAgentSessionStorePath()) {
+        this.file = file;
+    }
+    get(cli, sessionId) {
+        if (!sessionId)
+            return undefined;
+        return this.load().find((s) => s.cli === cli && s.sessionId === sessionId);
+    }
+    record(binding) {
+        if (!binding.sessionId || !binding.cwd)
+            return;
+        const next = {
+            cli: binding.cli,
+            sessionId: binding.sessionId,
+            cwd: normalizeCwdPath(binding.cwd),
+            ...(binding.worktreePath ? { worktreePath: binding.worktreePath } : {}),
+            ...(binding.worktreeBranch ? { worktreeBranch: binding.worktreeBranch } : {}),
+            updatedAt: binding.updatedAt ?? Date.now(),
+        };
+        this.withLock(() => {
+            const sessions = this.load().filter((s) => !(s.cli === binding.cli && s.sessionId === binding.sessionId));
+            sessions.push(next);
+            this.save(sessions);
+        });
+    }
+    load() {
+        if (!existsSync(this.file))
+            return [];
+        try {
+            const raw = readFileSync(this.file, "utf-8");
+            const parsed = JSON.parse(raw);
+            if (!parsed || !Array.isArray(parsed.sessions))
+                return [];
+            return parsed.sessions.filter(isBinding).map(normalizeBinding);
+        }
+        catch (err) {
+            logger.warn("external_agent_session_store.load_failed", {
+                cat: "cc",
+                file: this.file,
+                error: err instanceof Error ? err.message : String(err),
+            });
+            return [];
+        }
+    }
+    save(sessions) {
+        const dir = dirname(this.file);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        const snapshot = { version: 1, sessions };
+        const tmp = `${this.file}.${process.pid}.${Date.now()}.tmp`;
+        try {
+            writeFileSync(tmp, JSON.stringify(snapshot, null, 2) + "\n", "utf-8");
+            renameSync(tmp, this.file);
+        }
+        catch (err) {
+            rmSync(tmp, { force: true });
+            throw err;
+        }
+    }
+    withLock(fn) {
+        const dir = dirname(this.file);
+        if (!existsSync(dir))
+            mkdirSync(dir, { recursive: true });
+        // TODO: move this sync polling lock to an async write queue; callers can
+        // otherwise block the event loop for up to LOCK_WAIT_MS under contention.
+        const lockDir = `${this.file}.lock`;
+        const deadline = Date.now() + LOCK_WAIT_MS;
+        while (true) {
+            try {
+                mkdirSync(lockDir);
+                break;
+            }
+            catch (err) {
+                const code = err.code;
+                if (code !== "EEXIST")
+                    throw err;
+                if (removeStaleLock(lockDir))
+                    continue;
+                if (Date.now() >= deadline) {
+                    throw new Error(`timed out waiting for external agent session store lock: ${lockDir}`, {
+                        cause: err,
+                    });
+                }
+                sleepSync(LOCK_POLL_MS);
+            }
+        }
+        try {
+            return fn();
+        }
+        finally {
+            rmSync(lockDir, { recursive: true, force: true });
+        }
+    }
+}
+function normalizeBinding(binding) {
+    return { ...binding, cwd: normalizeCwdPath(binding.cwd) };
+}
+function removeStaleLock(lockDir) {
+    try {
+        if (Date.now() - statSync(lockDir).mtimeMs <= LOCK_STALE_MS)
+            return false;
+        rmSync(lockDir, { recursive: true, force: true });
+        return true;
+    }
+    catch (err) {
+        if (err.code === "ENOENT")
+            return true;
+        return false;
+    }
+}
+function sleepSync(ms) {
+    try {
+        const view = new Int32Array(new SharedArrayBuffer(4));
+        Atomics.wait(view, 0, 0, ms);
+    }
+    catch {
+        const until = Date.now() + ms;
+        while (Date.now() < until) {
+            // fallback for runtimes where Atomics.wait is unavailable
+        }
+    }
+}
+function isBinding(value) {
+    if (!value || typeof value !== "object")
+        return false;
+    const v = value;
+    return ((v.cli === "claude" || v.cli === "codex") &&
+        typeof v.sessionId === "string" &&
+        v.sessionId.length > 0 &&
+        typeof v.cwd === "string" &&
+        v.cwd.length > 0);
+}
+export const externalAgentSessionStore = new ExternalAgentSessionStore();

package/dist/cc-orchestrator/session-history.d.ts

@@ -11,6 +11,41 @@ export interface HistoryMessage {
     }[];
     ts?: number;
 }
+/** One render-relevant event parsed from an appended external-CLI transcript
+ * line. Kept CLI-neutral so the desktop room follower can feed Claude Code and
+ * Codex through the same RoomManager push path. */
+export type SessionTailEvent = {
+    type: "user";
+    text: string;
+} | {
+    type: "assistant";
+    text: string;
+} | {
+    type: "tool";
+    id?: string;
+    name: string;
+    summary: string;
+    args?: Record<string, unknown>;
+} | {
+    type: "tool_result";
+    id?: string;
+    result: string;
+    isError: boolean;
+} | {
+    type: "turn_end";
+    reason: string;
+};
+/** Parse a bounded/raw Claude Code transcript snapshot. Exported so a live
+ * follower can take its initial snapshot and EOF cursor from the same read,
+ * eliminating the snapshot→subscribe race. */
+export declare function parseRecentHistory(raw: string, limit: number): {
+    messages: HistoryMessage[];
+    hasMore: boolean;
+    totalCount: number;
+};
+/** Parse one newly-appended Claude Code transcript JSONL line into the compact
+ * event vocabulary consumed by the desktop room follower. */
+export declare function parseClaudeTranscriptLine(line: string): SessionTailEvent[];
 /** Read the last `limit` user/assistant messages from a claude session jsonl. */
 export declare function readRecentHistory(cwd: string, sessionId: string, limit: number, claudeHome?: string): {
     messages: HistoryMessage[];