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

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())
@@ -52,10 +57,14 @@ export function readCodexRecentHistory(cwd, threadId, limit, codexHome = join(ho
             const t = textOf(p.content).trim();
             if (!t || t.startsWith("<environment_context>"))
                 continue;
-            all.push({ role: p.role, text: t.slice(0, 4000) });
+            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/cwd-normalize.d.ts

@@ -0,0 +1,2 @@
+export declare function normalizeCwdPath(cwd: string): string;
+export declare function isExistingDirectory(cwd: string): boolean;

package/dist/cc-orchestrator/cwd-normalize.js

@@ -0,0 +1,19 @@
+import { realpathSync, statSync } from "node:fs";
+import { resolve } from "node:path";
+export function normalizeCwdPath(cwd) {
+    const resolved = resolve(cwd);
+    try {
+        return realpathSync(resolved);
+    }
+    catch {
+        return resolved;
+    }
+}
+export function isExistingDirectory(cwd) {
+    try {
+        return statSync(cwd).isDirectory();
+    }
+    catch {
+        return false;
+    }
+}

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

@@ -0,0 +1,27 @@
+export type ExternalAgentCli = "claude" | "codex";
+export interface ExternalAgentRunBinding {
+    cli: ExternalAgentCli;
+    externalSessionId: string;
+    codeShellSessionId: string;
+    cwd: string;
+    worktreePath?: string;
+    worktreeBranch?: string;
+    createdAt: number;
+    lastUsedAt: number;
+}
+export declare function externalAgentBindingsPath(home?: string): string;
+export declare class ExternalAgentBindingStore {
+    private readonly filePath?;
+    constructor(filePath?: string | undefined);
+    get(externalSessionId: string): ExternalAgentRunBinding | undefined;
+    upsert(next: Omit<ExternalAgentRunBinding, "createdAt" | "lastUsedAt">): ExternalAgentRunBinding;
+    private read;
+    private write;
+    private file;
+}
+export declare function detectExternalAgentWorktree(cwd: string): {
+    worktreePath?: string;
+    worktreeBranch?: string;
+};
+export declare function externalAgentResumeCwdError(binding: ExternalAgentRunBinding): string | undefined;
+export declare const externalAgentBindingStore: ExternalAgentBindingStore;

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

@@ -0,0 +1,150 @@
+import { existsSync, mkdirSync, readFileSync, renameSync, writeFileSync } from "node:fs";
+import { dirname, join, resolve } from "node:path";
+import { execFileSync } from "node:child_process";
+import { codeShellHome, SessionManager } from "../session/session-manager.js";
+export function externalAgentBindingsPath(home = codeShellHome()) {
+    return join(home, "external-agents", "bindings.json");
+}
+export class ExternalAgentBindingStore {
+    filePath;
+    constructor(filePath) {
+        this.filePath = filePath;
+    }
+    get(externalSessionId) {
+        return this.read({ failOnCorrupt: true }).bindings[externalSessionId];
+    }
+    upsert(next) {
+        const data = this.read({ failOnCorrupt: false });
+        const existing = data.bindings[next.externalSessionId];
+        const now = Date.now();
+        const binding = {
+            ...next,
+            codeShellSessionId: next.codeShellSessionId || existing?.codeShellSessionId || "",
+            createdAt: existing?.createdAt ?? now,
+            lastUsedAt: now,
+        };
+        data.bindings[next.externalSessionId] = binding;
+        this.write(data);
+        return binding;
+    }
+    read(opts) {
+        const file = this.file();
+        if (!existsSync(file))
+            return { bindings: {} };
+        try {
+            const parsed = JSON.parse(readFileSync(file, "utf-8"));
+            if (parsed && typeof parsed.bindings === "object" && parsed.bindings) {
+                return { bindings: parsed.bindings };
+            }
+            if (opts.failOnCorrupt) {
+                throw new Error(`external agent bindings file is corrupt: expected object with bindings`);
+            }
+            return { bindings: {} };
+        }
+        catch (err) {
+            if (opts.failOnCorrupt) {
+                throw new Error(`external agent bindings file is corrupt or unreadable: ${err instanceof Error ? err.message : String(err)}`, { cause: err });
+            }
+            return { bindings: {} };
+        }
+    }
+    write(data) {
+        const file = this.file();
+        mkdirSync(dirname(file), { recursive: true });
+        const tmp = `${file}.${process.pid}.${Date.now()}.tmp`;
+        writeFileSync(tmp, JSON.stringify(data, null, 2), "utf-8");
+        renameSync(tmp, file);
+    }
+    file() {
+        return this.filePath ?? externalAgentBindingsPath();
+    }
+}
+export function detectExternalAgentWorktree(cwd) {
+    if (!existsSync(cwd))
+        return {};
+    try {
+        const root = git(cwd, ["rev-parse", "--show-toplevel"]);
+        const branch = git(root, ["branch", "--show-current"]);
+        const entries = parseWorktreeList(git(root, ["worktree", "list", "--porcelain"]));
+        const current = entries.find((entry) => resolve(entry.path) === resolve(root));
+        const main = entries[0];
+        if (!current || !branch || !main || resolve(current.path) === resolve(main.path))
+            return {};
+        return { worktreePath: root, worktreeBranch: branch };
+    }
+    catch {
+        return {};
+    }
+}
+export function externalAgentResumeCwdError(binding) {
+    if (existsSync(binding.cwd))
+        return undefined;
+    const branch = binding.worktreeBranch;
+    if (branch && branchExistsForBinding(binding)) {
+        return (`Error: external ${binding.cli} session ${binding.externalSessionId} is bound to cwd ` +
+            `${binding.cwd}, but that directory no longer exists. Worktree branch ${branch} still ` +
+            `exists; recreate the worktree at ${binding.worktreePath ?? binding.cwd} before resuming.`);
+    }
+    return (`Error: external ${binding.cli} session ${binding.externalSessionId} is bound to cwd ` +
+        `${binding.cwd}, but the workspace deleted${branch ? ` and branch ${branch} is gone` : ""}. ` +
+        `Start a new external session.`);
+}
+function branchExistsForBinding(binding) {
+    if (!binding.worktreeBranch)
+        return false;
+    for (const cwd of candidateGitCwds(binding)) {
+        if (!cwd || !existsSync(cwd))
+            continue;
+        try {
+            const out = git(cwd, ["branch", "--list", binding.worktreeBranch]);
+            if (out.length > 0)
+                return true;
+        }
+        catch {
+            // Try the next candidate.
+        }
+    }
+    return false;
+}
+function candidateGitCwds(binding) {
+    const candidates = new Set();
+    if (existsSync(binding.cwd))
+        candidates.add(binding.cwd);
+    if (binding.codeShellSessionId) {
+        const sessionCwd = new SessionManager().readCwd(binding.codeShellSessionId);
+        if (sessionCwd)
+            candidates.add(sessionCwd);
+    }
+    candidates.add(process.cwd());
+    candidates.add(dirname(binding.cwd));
+    candidates.add(dirname(dirname(binding.cwd)));
+    return [...candidates];
+}
+function parseWorktreeList(raw) {
+    if (!raw.trim())
+        return [];
+    const entries = [];
+    let current = { path: "", branch: "" };
+    for (const line of raw.split("\n")) {
+        if (line.startsWith("worktree ")) {
+            if (current.path)
+                entries.push(current);
+            current = { path: line.slice(9), branch: "" };
+        }
+        else if (line.startsWith("branch ")) {
+            current.branch = line.slice(7).replace("refs/heads/", "");
+        }
+    }
+    if (current.path)
+        entries.push(current);
+    return entries;
+}
+function git(cwd, args) {
+    return execFileSync("git", args, {
+        cwd,
+        encoding: "utf-8",
+        timeout: 10000,
+        stdio: ["ignore", "pipe", "ignore"],
+    }).trim();
+}
+export const externalAgentBindingStore = new ExternalAgentBindingStore();

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,6 +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, 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 & {