@cjhyy/code-shell-core 0.5.0-rc.2 → 0.6.0-rc.10

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

@@ -0,0 +1,191 @@
+import { readdirSync, statSync, existsSync, openSync, readSync, closeSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+import { selectRecentStats } from "./session-discovery.js";
+/**
+ * Discover codex CLI sessions for a given `cwd`, mirroring the claude-side
+ * `discoverSessions` but for codex's storage layout, which is fundamentally
+ * different:
+ *
+ *   ~/.codex/sessions/YYYY/MM/DD/rollout-<ts>-<uuid>.jsonl
+ *
+ * Unlike claude (one dir per project), codex stores rollouts by DATE, not by
+ * cwd. The cwd lives INSIDE the file: the first line is a `session_meta` event
+ * whose `payload` carries `{ id, cwd, timestamp }` (`id` is the thread id we
+ * resume by). So discovery means: walk every rollout file, read just its first
+ * line to learn its cwd, and keep the ones matching the requested project.
+ *
+ * Codex rollout files can be large, so we deliberately AVOID `readFileSync` on
+ * the whole file (the claude version reads the whole file because claude
+ * sessions are small). We read the first line for the meta, and — only for a
+ * matching file — read a bounded prefix to find the first real user message for
+ * the title. Returns the same `DiscoveredSession` shape so the UI is CLI-blind.
+ */
+export function discoverCodexSessions(cwd, codexHome = join(homedir(), ".codex"), opts = {}) {
+    const root = join(codexHome, "sessions");
+    if (!existsSync(root))
+        return [];
+    // Cheap pass: stat every rollout (no read). Apply the recency window here so
+    // the meta read (first line) only runs on in-window files. The limit can't be
+    // applied yet — we don't know which files match `cwd` until we read the meta,
+    // so we'd otherwise drop matching-but-not-yet-seen sessions.
+    const stats = [];
+    for (const file of walkRollouts(root)) {
+        let st;
+        try {
+            st = statSync(file);
+        }
+        catch {
+            continue;
+        }
+        stats.push({ file, mtimeMs: st.mtimeMs });
+    }
+    const windowed = selectRecentStats(stats, { sinceMs: opts.sinceMs, now: opts.now });
+    const limit = opts.limit && opts.limit > 0 ? opts.limit : Infinity;
+    const out = [];
+    for (const s of windowed) {
+        if (out.length >= limit)
+            break;
+        let meta;
+        try {
+            meta = readSessionMeta(s.file);
+        }
+        catch {
+            continue;
+        }
+        if (!meta || !meta.id || meta.cwd !== cwd)
+            continue;
+        out.push({
+            sessionId: meta.id,
+            firstMessage: readFirstUserMessage(s.file),
+            lastModified: s.mtimeMs,
+            messageCount: 0, // not tracked for codex (would need a full scan); UI shows time + title.
+        });
+    }
+    return out;
+}
+/** Count codex sessions for `cwd` (reads first-line meta of every rollout; no
+ *  window). Used so the UI knows whether a bounded list left older ones hidden. */
+export function countCodexSessions(cwd, codexHome = join(homedir(), ".codex")) {
+    const root = join(codexHome, "sessions");
+    if (!existsSync(root))
+        return 0;
+    let n = 0;
+    for (const file of walkRollouts(root)) {
+        let meta;
+        try {
+            meta = readSessionMeta(file);
+        }
+        catch {
+            continue;
+        }
+        if (meta && meta.id && meta.cwd === cwd)
+            n++;
+    }
+    return n;
+}
+/** Recursively yield every `rollout-*.jsonl` file under `root`. */
+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;
+        }
+    }
+}
+/** Read just the first line of a file (bounded), without loading the whole file. */
+function readFirstLine(file, maxBytes = 1 << 16) {
+    const fd = openSync(file, "r");
+    try {
+        const buf = Buffer.alloc(maxBytes);
+        const n = readSync(fd, buf, 0, maxBytes, 0);
+        const text = buf.toString("utf-8", 0, n);
+        const nl = text.indexOf("\n");
+        return nl === -1 ? text : text.slice(0, nl);
+    }
+    finally {
+        closeSync(fd);
+    }
+}
+/** Parse the first-line `session_meta` event → `{ id, cwd }`. */
+function readSessionMeta(file) {
+    const first = readFirstLine(file).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 };
+}
+/**
+ * Find the first *real* user message text for the session title. Codex user
+ * messages look like:
+ *   {type:"response_item", payload:{type:"message", role:"user",
+ *      content:[{type:"input_text", text}]}}
+ * The very first user message is usually an `<environment_context>` injection
+ * (analogous to claude's `<local-command-caveat>`); skip those wrappers.
+ *
+ * Reads a bounded prefix of the file rather than the whole thing.
+ */
+function readFirstUserMessage(file, maxBytes = 1 << 20) {
+    let chunk;
+    try {
+        const fd = openSync(file, "r");
+        try {
+            const buf = Buffer.alloc(maxBytes);
+            const n = readSync(fd, buf, 0, maxBytes, 0);
+            chunk = buf.toString("utf-8", 0, n);
+        }
+        finally {
+            closeSync(fd);
+        }
+    }
+    catch {
+        return "";
+    }
+    for (const line of chunk.split("\n")) {
+        if (!line.trim())
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            // Truncated last line of the bounded read — stop scanning.
+            break;
+        }
+        const p = d?.payload;
+        if (d?.type !== "response_item" || p?.type !== "message" || p?.role !== "user")
+            continue;
+        const content = p.content;
+        const text = Array.isArray(content)
+            ? content.map((c) => (typeof c?.text === "string" ? c.text : "")).join("")
+            : typeof content === "string"
+                ? content
+                : "";
+        const t = text.trim();
+        if (!t)
+            continue;
+        if (t.startsWith("<environment_context>"))
+            continue;
+        return t.slice(0, 200);
+    }
+    return "";
+}

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

@@ -0,0 +1,25 @@
+import type { HistoryMessage } 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
+ * UI stays CLI-blind.
+ *
+ * Codex storage differs from claude fundamentally (see `codex-session-discovery`):
+ * rollouts live under `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl`, keyed by
+ * DATE not cwd, with the thread id inside the file's `session_meta` first line.
+ * So we first locate the rollout file whose `session_meta` matches both
+ * `threadId` and `cwd`, then parse its event stream:
+ *
+ *   - {type:"response_item", payload:{type:"message", role:"user"|"assistant",
+ *        content:[{type:"input_text"|"output_text", text}]}}  → message text
+ *   - {type:"response_item", payload:{type:"function_call", name, arguments}}   → tool
+ *   - {type:"response_item", payload:{type:"custom_tool_call", name, input}}    → tool
+ *
+ * `developer`-role messages (environment/system injections) and the leading
+ * `<environment_context>` user wrapper are skipped, mirroring discovery.
+ */
+export declare function readCodexRecentHistory(cwd: string, threadId: string, limit: number, codexHome?: string): {
+    messages: HistoryMessage[];
+    hasMore: boolean;
+    totalCount: number;
+};

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

@@ -0,0 +1,187 @@
+import { readdirSync, readFileSync, statSync, existsSync, openSync, readSync, closeSync } from "node:fs";
+import { join } from "node:path";
+import { homedir } from "node:os";
+/**
+ * Read the last `limit` user/assistant messages from a codex CLI session,
+ * returning the SAME shape as the claude-side `readRecentHistory` so the room
+ * UI stays CLI-blind.
+ *
+ * Codex storage differs from claude fundamentally (see `codex-session-discovery`):
+ * rollouts live under `~/.codex/sessions/YYYY/MM/DD/rollout-*.jsonl`, keyed by
+ * DATE not cwd, with the thread id inside the file's `session_meta` first line.
+ * So we first locate the rollout file whose `session_meta` matches both
+ * `threadId` and `cwd`, then parse its event stream:
+ *
+ *   - {type:"response_item", payload:{type:"message", role:"user"|"assistant",
+ *        content:[{type:"input_text"|"output_text", text}]}}  → message text
+ *   - {type:"response_item", payload:{type:"function_call", name, arguments}}   → tool
+ *   - {type:"response_item", payload:{type:"custom_tool_call", name, input}}    → tool
+ *
+ * `developer`-role messages (environment/system injections) and the leading
+ * `<environment_context>` user wrapper are skipped, mirroring discovery.
+ */
+export function readCodexRecentHistory(cwd, threadId, limit, codexHome = join(homedir(), ".codex")) {
+    const empty = { messages: [], hasMore: false, totalCount: 0 };
+    const file = findRolloutFile(codexHome, cwd, threadId);
+    if (!file)
+        return empty;
+    let raw;
+    try {
+        raw = readFileSync(file, "utf-8");
+    }
+    catch {
+        return empty;
+    }
+    const all = [];
+    for (const line of raw.split("\n")) {
+        if (!line.trim())
+            continue;
+        let d;
+        try {
+            d = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (d?.type !== "response_item")
+            continue;
+        const p = d.payload;
+        if (!p)
+            continue;
+        if (p.type === "message" && (p.role === "user" || p.role === "assistant")) {
+            const t = textOf(p.content).trim();
+            if (!t || t.startsWith("<environment_context>"))
+                continue;
+            all.push({ role: p.role, text: t.slice(0, 4000) });
+        }
+        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 last = all[all.length - 1];
+            // Attach the tool to the preceding assistant turn; otherwise start one.
+            if (last && last.role === "assistant") {
+                (last.tools ??= []).push(tool);
+            }
+            else {
+                all.push({ role: "assistant", text: "", tools: [tool] });
+            }
+        }
+    }
+    const lim = limit > 0 ? limit : 20;
+    const start = Math.max(0, all.length - lim);
+    return { messages: all.slice(start), hasMore: start > 0, totalCount: all.length };
+}
+/** Join the text of codex content parts (`input_text`/`output_text`). */
+function textOf(content) {
+    if (typeof content === "string")
+        return content;
+    if (Array.isArray(content))
+        return content.map((c) => (typeof c?.text === "string" ? c.text : "")).join("");
+    return "";
+}
+/** Build a short summary for a codex tool event from its arguments/input. */
+function summaryOf(payload) {
+    // function_call carries `arguments` as a JSON string; custom_tool_call carries `input` as a string.
+    if (typeof payload.arguments === "string") {
+        try {
+            const a = JSON.parse(payload.arguments);
+            const s = a?.cmd ?? a?.command ?? a?.file_path ?? a?.path ?? a?.workdir ?? "";
+            if (s)
+                return String(s).slice(0, 120);
+        }
+        catch {
+            /* fall through to raw */
+        }
+        return payload.arguments.slice(0, 120);
+    }
+    if (typeof payload.input === "string")
+        return payload.input.slice(0, 120);
+    return "";
+}
+/**
+ * Build the FULL structured tool args for a codex tool event so a replayed tool
+ * card can show the real parameters (not just the lossy one-field summary).
+ * `function_call.arguments` is a JSON string → parse it; `custom_tool_call.input`
+ * is a raw string → keep it under `{input}`. Returns undefined when neither is
+ * present or the JSON is malformed.
+ */
+function argsOf(payload) {
+    if (typeof payload.arguments === "string") {
+        try {
+            const a = JSON.parse(payload.arguments);
+            if (a && typeof a === "object")
+                return a;
+        }
+        catch {
+            /* malformed JSON → fall through */
+        }
+        return { arguments: payload.arguments };
+    }
+    if (typeof payload.input === "string")
+        return { input: payload.input };
+    return undefined;
+}
+/** Find the rollout file whose `session_meta` matches both `threadId` and `cwd`. */
+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;
+}
+/** Recursively yield every `rollout-*.jsonl` file under `root`. */
+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;
+        }
+    }
+}
+/** Parse the first-line `session_meta` event → `{ id, cwd }`, reading a bounded prefix. */
+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-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,214 @@
+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";
+/**
+ * #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 {
+        if (cli === "codex")
+            return readCodexChangedFiles(cwd, sessionId);
+        return readClaudeChangedFiles(cwd, sessionId);
+    }
+    catch {
+        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,18 @@
+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;
+}
+/** 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>;