@cjhyy/code-shell-capability-coding 0.8.0

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 "@cjhyy/code-shell-core/extension";
+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().readSessionMainRoot(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.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Parse claude transcript JSONL text → deduped list of changed file paths.
+ * Each line is `{ message: { content: [{ type:"tool_use", name, input }] } }`.
+ * Exported for direct unit testing without a transcript file on disk.
+ */
+export declare function extractChangedFilesFromClaudeLines(text: string): string[];
+/** Locate `<claudeHome>/projects/<encodeCwd(cwd)>/<sid>.jsonl` and extract changes. */
+export declare function readClaudeChangedFiles(cwd: string, sessionId: string, claudeHome?: string): string[];
+/**
+ * Parse codex rollout JSONL text → changed file paths. Codex tool calls are
+ * `{type:"response_item", payload:{type:"function_call", name, arguments}}` or
+ * `{...custom_tool_call, input}`. apply_patch carries the patch text; write/edit
+ * carry a file path in arguments. Exported for unit testing.
+ */
+export declare function extractChangedFilesFromCodexLines(text: string): string[];
+/** Locate a codex rollout by threadId+cwd under `<codexHome>/sessions` and extract changes. */
+export declare function readCodexChangedFiles(cwd: string, threadId: string, codexHome?: string): string[];
+/** Dispatch by CLI. Unknown cli → []. Never throws. */
+export declare function readExternalChangedFiles(cli: string, cwd: string, sessionId: string): string[];

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

@@ -0,0 +1,231 @@
+import { readFileSync, existsSync, readdirSync, statSync, openSync, readSync, closeSync, } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { encodeCwd } from "./session-discovery.js";
+import { logger } from "@cjhyy/code-shell-core/extension";
+/**
+ * #6 — attribute file changes made by a background external agent (DriveAgent
+ * running `claude` / `codex`). Those Edit/Write calls land in the external CLI's
+ * own transcript, invisible to the host's in-session file-change aggregator.
+ * Given the external session id + cwd, locate that transcript and extract the
+ * set of changed files, so the UI can show "N files edited" for the run.
+ *
+ * Read-only; tolerant — a malformed line is skipped, a missing transcript
+ * returns []. Never throws for the caller.
+ */
+const CLAUDE_WRITE_TOOLS = new Set(["Write", "Edit", "MultiEdit", "NotebookEdit"]);
+const CODEX_WRITE_TOOLS = new Set(["apply_patch", "ApplyPatch", "write_file", "edit_file"]);
+/** Pull the changed-file path out of a claude tool_use input block. */
+function claudeInputPath(input) {
+    if (!input || typeof input !== "object")
+        return undefined;
+    const o = input;
+    const p = o.file_path ?? o.notebook_path;
+    return typeof p === "string" && p.length > 0 ? p : undefined;
+}
+/**
+ * Parse claude transcript JSONL text → deduped list of changed file paths.
+ * Each line is `{ message: { content: [{ type:"tool_use", name, input }] } }`.
+ * Exported for direct unit testing without a transcript file on disk.
+ */
+export function extractChangedFilesFromClaudeLines(text) {
+    const seen = new Set();
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        const content = d?.message?.content;
+        if (!Array.isArray(content))
+            continue;
+        for (const block of content) {
+            if (block &&
+                typeof block === "object" &&
+                block.type === "tool_use" &&
+                CLAUDE_WRITE_TOOLS.has(block.name ?? "")) {
+                const p = claudeInputPath(block.input);
+                if (p)
+                    seen.add(p);
+            }
+        }
+    }
+    return [...seen];
+}
+/** Locate `<claudeHome>/projects/<encodeCwd(cwd)>/<sid>.jsonl` and extract changes. */
+export function readClaudeChangedFiles(cwd, sessionId, claudeHome = join(homedir(), ".claude")) {
+    const file = join(claudeHome, "projects", encodeCwd(cwd), `${sessionId}.jsonl`);
+    if (!existsSync(file))
+        return [];
+    let text;
+    try {
+        text = readFileSync(file, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    return extractChangedFilesFromClaudeLines(text);
+}
+/**
+ * Parse codex rollout JSONL text → changed file paths. Codex tool calls are
+ * `{type:"response_item", payload:{type:"function_call", name, arguments}}` or
+ * `{...custom_tool_call, input}`. apply_patch carries the patch text; write/edit
+ * carry a file path in arguments. Exported for unit testing.
+ */
+export function extractChangedFilesFromCodexLines(text) {
+    const seen = new Set();
+    for (const line of text.split("\n")) {
+        if (!line.trim())
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (d?.type !== "response_item" || !d.payload)
+            continue;
+        const p = d.payload;
+        const name = typeof p.name === "string" ? p.name : "";
+        if (!CODEX_WRITE_TOOLS.has(name))
+            continue;
+        // function_call.arguments is a JSON string; custom_tool_call.input a string.
+        const rawArgs = typeof p.arguments === "string" ? p.arguments : typeof p.input === "string" ? p.input : "";
+        for (const f of filesFromCodexArgs(name, rawArgs))
+            seen.add(f);
+    }
+    return [...seen];
+}
+/** Pull file paths out of a codex tool's arguments string. */
+function filesFromCodexArgs(name, raw) {
+    if (!raw)
+        return [];
+    if (name === "apply_patch" || name === "ApplyPatch") {
+        // apply_patch payload wraps a patch; headers look like `*** Update File: <p>`
+        // or `*** Add File: <p>`. Match those directly off the raw text.
+        const out = [];
+        const re = /\*\*\*\s+(?:Update|Add|Delete) File:\s+(.+)/g;
+        let m;
+        while ((m = re.exec(raw)) !== null) {
+            const f = m[1]?.trim();
+            if (f)
+                out.push(f);
+        }
+        return out;
+    }
+    try {
+        const a = JSON.parse(raw);
+        const p = a.file_path ?? a.path;
+        return typeof p === "string" && p ? [p] : [];
+    }
+    catch {
+        return [];
+    }
+}
+/** Locate a codex rollout by threadId+cwd under `<codexHome>/sessions` and extract changes. */
+export function readCodexChangedFiles(cwd, threadId, codexHome = join(homedir(), ".codex")) {
+    const file = findRolloutFile(codexHome, cwd, threadId);
+    if (!file)
+        return [];
+    let text;
+    try {
+        text = readFileSync(file, "utf-8");
+    }
+    catch {
+        return [];
+    }
+    return extractChangedFilesFromCodexLines(text);
+}
+/** Dispatch by CLI. Unknown cli → []. Never throws. */
+export function readExternalChangedFiles(cli, cwd, sessionId) {
+    try {
+        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 [];
+    }
+}
+// ── codex rollout location (mirrors codex-session-history.ts) ──────────────
+function findRolloutFile(codexHome, cwd, threadId) {
+    const root = join(codexHome, "sessions");
+    if (!existsSync(root))
+        return undefined;
+    for (const file of walkRollouts(root)) {
+        let meta;
+        try {
+            meta = readSessionMeta(file);
+        }
+        catch {
+            continue;
+        }
+        if (meta && meta.id === threadId && meta.cwd === cwd)
+            return file;
+    }
+    return undefined;
+}
+function* walkRollouts(root) {
+    let entries;
+    try {
+        entries = readdirSync(root);
+    }
+    catch {
+        return;
+    }
+    for (const name of entries) {
+        const full = join(root, name);
+        let st;
+        try {
+            st = statSync(full);
+        }
+        catch {
+            continue;
+        }
+        if (st.isDirectory())
+            yield* walkRollouts(full);
+        else if (name.startsWith("rollout-") && name.endsWith(".jsonl"))
+            yield full;
+    }
+}
+function readSessionMeta(file, maxBytes = 1 << 16) {
+    const fd = openSync(file, "r");
+    let text;
+    try {
+        const buf = Buffer.alloc(maxBytes);
+        const n = readSync(fd, buf, 0, maxBytes, 0);
+        text = buf.toString("utf-8", 0, n);
+    }
+    finally {
+        closeSync(fd);
+    }
+    const nl = text.indexOf("\n");
+    const first = (nl === -1 ? text : text.slice(0, nl)).trim();
+    if (!first)
+        return undefined;
+    const d = JSON.parse(first);
+    if (d.type !== "session_meta" || !d.payload)
+        return undefined;
+    return { id: d.payload.id, cwd: d.payload.cwd };
+}

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

@@ -0,0 +1,19 @@
+import type { AgentAdapter, BuildArgsOpts, PermissionMode } from "./agent-adapter.js";
+export interface AgentRunResult {
+    sessionId: string;
+    finalText: string;
+    isError: boolean;
+    exitCode: number | null;
+    lines: string[];
+}
+/** Pure: reduce collected output lines + exit code to a result. Unit-testable. */
+export declare function runWithLines(adapter: AgentAdapter, lines: string[], exitCode: number | null): AgentRunResult;
+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 & {
+    command: string;
+}, signal?: AbortSignal): Promise<AgentRunResult>;