@cjhyy/code-shell-core 0.7.0-beta.1 → 0.7.0

package/dist/cc-orchestrator/agent-adapter.d.ts

@@ -2,6 +2,8 @@ export type PermissionMode = "default" | "acceptEdits" | "bypassPermissions";
 export interface BuildArgsOpts {
     prompt: string;
     resumeSessionId?: string;
+    /** Optional caller-specified model override. Passed through without validation; the CLI reports unknown models. */
+    model?: string;
     permissionMode: PermissionMode;
     cwd: string;
     imagePaths?: string[];

package/dist/cc-orchestrator/agent-adapter.js

@@ -14,6 +14,8 @@ export const claudeAdapter = {
     buildArgs(opts) {
         // -p (print/headless) + stream-json REQUIRES --verbose (verified).
         const args = ["-p", opts.prompt, "--output-format", "stream-json", "--verbose"];
+        if (opts.model)
+            args.push("--model", opts.model);
         if (opts.resumeSessionId)
             args.push("--resume", opts.resumeSessionId);
         // Hard-disallow Workflow: driving CC unattended (esp. bypassPermissions),
@@ -82,6 +84,8 @@ export const codexAdapter = {
         else {
             args.push("--sandbox", opts.permissionMode === "acceptEdits" ? "workspace-write" : "read-only");
         }
+        if (opts.model)
+            args.push("--model", opts.model);
         if (opts.codexImageInputSupported) {
             for (const imagePath of opts.imagePaths ?? [])
                 args.push("-i", imagePath);

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

@@ -1,4 +1,4 @@
-import type { HistoryMessage } from "./session-history.js";
+import type { HistoryMessage, SessionTailEvent } from "./session-history.js";
 /**
  * Read the last `limit` user/assistant messages from a codex CLI session,
  * returning the SAME shape as the claude-side `readRecentHistory` so the room
@@ -23,3 +23,16 @@ export declare function readCodexRecentHistory(cwd: string, threadId: string, li
     hasMore: boolean;
     totalCount: number;
 };
+/** Parse a bounded/raw Codex rollout snapshot. Shared with the desktop tail
+ * follower so its initial history and EOF cursor are atomic. */
+export declare function parseCodexRecentHistory(raw: string, limit: number): {
+    messages: HistoryMessage[];
+    hasMore: boolean;
+    totalCount: number;
+};
+/** Parse one newly-appended Codex rollout JSONL line. `response_item` is the
+ * authoritative rendered stream; parallel `event_msg.agent_message` records
+ * are deliberately ignored to avoid duplicate assistant bubbles. */
+export declare function parseCodexTranscriptLine(line: string): SessionTailEvent[];
+/** Find the rollout file whose `session_meta` matches both `threadId` and `cwd`. */
+export declare function findCodexRolloutFile(codexHome: string, cwd: string, threadId: string): string | undefined;

package/dist/cc-orchestrator/codex-session-history.js

@@ -1,4 +1,4 @@
-import { readdirSync, readFileSync, statSync, existsSync, openSync, readSync, closeSync } from "node:fs";
+import { readdirSync, readFileSync, statSync, existsSync, openSync, readSync, closeSync, } from "node:fs";
 import { join } from "node:path";
 import { homedir } from "node:os";
 /**
@@ -22,7 +22,7 @@ import { homedir } from "node:os";
  */
 export function readCodexRecentHistory(cwd, threadId, limit, codexHome = join(homedir(), ".codex")) {
     const empty = { messages: [], hasMore: false, totalCount: 0 };
-    const file = findRolloutFile(codexHome, cwd, threadId);
+    const file = findCodexRolloutFile(codexHome, cwd, threadId);
     if (!file)
         return empty;
     let raw;
@@ -32,6 +32,11 @@ export function readCodexRecentHistory(cwd, threadId, limit, codexHome = join(ho
     catch {
         return empty;
     }
+    return parseCodexRecentHistory(raw, limit);
+}
+/** Parse a bounded/raw Codex rollout snapshot. Shared with the desktop tail
+ * follower so its initial history and EOF cursor are atomic. */
+export function parseCodexRecentHistory(raw, limit) {
     const all = [];
     for (const line of raw.split("\n")) {
         if (!line.trim())
@@ -55,7 +60,11 @@ export function readCodexRecentHistory(cwd, threadId, limit, codexHome = join(ho
             all.push({ role: p.role, text: t });
         }
         else if (p.type === "function_call" || p.type === "custom_tool_call") {
-            const tool = { name: typeof p.name === "string" ? p.name : "tool", summary: summaryOf(p), args: argsOf(p) };
+            const tool = {
+                name: typeof p.name === "string" ? p.name : "tool",
+                summary: summaryOf(p),
+                args: argsOf(p),
+            };
             const last = all[all.length - 1];
             // Attach the tool to the preceding assistant turn; otherwise start one.
             if (last && last.role === "assistant") {
@@ -70,6 +79,57 @@ export function readCodexRecentHistory(cwd, threadId, limit, codexHome = join(ho
     const start = Math.max(0, all.length - lim);
     return { messages: all.slice(start), hasMore: start > 0, totalCount: all.length };
 }
+/** Parse one newly-appended Codex rollout JSONL line. `response_item` is the
+ * authoritative rendered stream; parallel `event_msg.agent_message` records
+ * are deliberately ignored to avoid duplicate assistant bubbles. */
+export function parseCodexTranscriptLine(line) {
+    let d;
+    try {
+        d = JSON.parse(line);
+    }
+    catch {
+        return [];
+    }
+    if (d?.type === "event_msg" && d.payload?.type === "task_complete") {
+        return [{ type: "turn_end", reason: "completed" }];
+    }
+    if (d?.type !== "response_item" || !d.payload)
+        return [];
+    const p = d.payload;
+    if (p.type === "message" && (p.role === "user" || p.role === "assistant")) {
+        const text = textOf(p.content).trim();
+        if (!text || text.startsWith("<environment_context>"))
+            return [];
+        return [{ type: p.role === "user" ? "user" : "assistant", text }];
+    }
+    if (p.type === "function_call" || p.type === "custom_tool_call") {
+        return [
+            {
+                type: "tool",
+                id: typeof p.call_id === "string" ? p.call_id : undefined,
+                name: typeof p.name === "string" ? p.name : "tool",
+                summary: summaryOf(p),
+                args: argsOf(p),
+            },
+        ];
+    }
+    if (p.type === "function_call_output" || p.type === "custom_tool_call_output") {
+        const result = typeof p.output === "string"
+            ? p.output
+            : typeof p.content === "string"
+                ? p.content
+                : JSON.stringify(p.output ?? p.content ?? "");
+        return [
+            {
+                type: "tool_result",
+                id: typeof p.call_id === "string" ? p.call_id : undefined,
+                result: result.slice(0, 4000),
+                isError: Boolean(p.is_error),
+            },
+        ];
+    }
+    return [];
+}
 /** Join the text of codex content parts (`input_text`/`output_text`). */
 function textOf(content) {
     if (typeof content === "string")
@@ -121,7 +181,7 @@ function argsOf(payload) {
     return undefined;
 }
 /** Find the rollout file whose `session_meta` matches both `threadId` and `cwd`. */
-function findRolloutFile(codexHome, cwd, threadId) {
+export function findCodexRolloutFile(codexHome, cwd, threadId) {
     const root = join(codexHome, "sessions");
     if (!existsSync(root))
         return undefined;

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

@@ -2,6 +2,7 @@ import { readFileSync, existsSync, readdirSync, statSync, openSync, readSync, cl
 import { join } from "node:path";
 import { homedir } from "node:os";
 import { encodeCwd } from "./session-discovery.js";
+import { logger } from "../logging/logger.js";
 /**
  * #6 — attribute file changes made by a background external agent (DriveAgent
  * running `claude` / `codex`). Those Edit/Write calls land in the external CLI's
@@ -143,11 +144,27 @@ export function readCodexChangedFiles(cwd, threadId, codexHome = join(homedir(),
 /** Dispatch by CLI. Unknown cli → []. Never throws. */
 export function readExternalChangedFiles(cli, cwd, sessionId) {
     try {
-        if (cli === "codex")
-            return readCodexChangedFiles(cwd, sessionId);
-        return readClaudeChangedFiles(cwd, sessionId);
-    }
-    catch {
+        const files = cli === "codex"
+            ? readCodexChangedFiles(cwd, sessionId)
+            : readClaudeChangedFiles(cwd, sessionId);
+        logger.debug("changed_files.external.extracted", {
+            cat: "changed_files",
+            cli,
+            cwd,
+            externalSessionId: sessionId,
+            size: files.length,
+            files,
+        });
+        return files;
+    }
+    catch (err) {
+        logger.debug("changed_files.external.extract_failed", {
+            cat: "changed_files",
+            cli,
+            cwd,
+            externalSessionId: sessionId,
+            error: err instanceof Error ? err.message : String(err),
+        });
         return [];
     }
 }

package/dist/cc-orchestrator/external-agent-driver.d.ts

@@ -11,7 +11,7 @@ export declare function runWithLines(adapter: AgentAdapter, lines: string[], exi
 export interface DriverRunOpts extends Omit<BuildArgsOpts, "permissionMode"> {
     permissionMode?: PermissionMode;
 }
-export declare function detectCodexImageInput(command: string, cwd: string): Promise<boolean>;
+export declare function detectCodexImageInput(command: string, cwd: string, signal?: AbortSignal): Promise<boolean>;
 /** Spawn ONE headless agent run, collect stream-json to exit, return result.
  *  No time concept — a single turn. Honors AbortSignal (kills the child). */
 export declare function runAgentOnce(adapter: AgentAdapter, opts: DriverRunOpts & {

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

@@ -1,17 +1,130 @@
-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 };
 }
 const codexImageFlagCache = new Map();
-export function detectCodexImageInput(command, cwd) {
-    const cached = codexImageFlagCache.get(command);
-    if (cached)
-        return cached;
-    const probe = new Promise((resolve) => {
+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);
+        });
+    });
+}
+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);
+        }
+        catch {
+            // already gone
+        }
+    }
+}
+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 {
+                process.kill(pid);
+            }
+            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() },
@@ -20,31 +133,65 @@ export function detectCodexImageInput(command, cwd) {
         });
         let out = "";
         let settled = false;
+        let terminating = false;
+        const cleanup = () => {
+            clearTimeout(timer);
+            signal?.removeEventListener("abort", onAbort);
+        };
         const done = (value) => {
             if (settled)
                 return;
             settled = true;
-            clearTimeout(timer);
+            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(() => {
-            try {
-                child.kill("SIGTERM");
-            }
-            catch {
-                // already gone
-            }
-            done(false);
-        }, 2_000);
+            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.stderr?.on("data", (chunk) => {
             out += chunk.toString("utf8");
         });
-        child.on("error", () => done(false));
-        child.on("exit", () => done(/(?:^|\s)-i(?:,|\s)|--image\b/.test(out)));
+        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;
 }
@@ -53,17 +200,25 @@ export function detectCodexImageInput(command, cwd) {
 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).catch(() => false)
+                ? 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
@@ -72,14 +227,27 @@ export function runAgentOnce(adapter, opts, signal) {
             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.
+                // 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);
             }
@@ -88,20 +256,11 @@ export function runAgentOnce(adapter, opts, signal) {
                 const rl = createInterface({ input: child.stdout });
                 rl.on("line", (line) => lines.push(line));
             }
-            // 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 = () => {
-                try {
-                    child.kill("SIGTERM");
-                }
-                catch {
-                    /* already gone */
-                }
-            };
-            signal?.addEventListener("abort", onAbort, { once: true });
             child.on("error", (err) => {
-                signal?.removeEventListener("abort", onAbort);
+                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.
@@ -112,8 +271,13 @@ export function runAgentOnce(adapter, opts, signal) {
                 reject(err);
             });
             child.on("exit", (code) => {
-                signal?.removeEventListener("abort", onAbort);
-                resolve(runWithLines(adapter, lines, code));
+                if (settled)
+                    return;
+                settled = true;
+                cleanup();
+                void (termination ?? Promise.resolve()).then(() => {
+                    resolve(runWithLines(adapter, lines, code));
+                });
             });
         })().catch(reject);
     });

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[];