@cjhyy/code-shell-core 0.7.1 → 0.8.0

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

@@ -1,54 +0,0 @@
-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[];
-    codexImageInputSupported?: boolean;
-}
-export interface ParsedResult {
-    sessionId: string;
-    finalText: string;
-    isError: boolean;
-}
-export interface AgentAdapter {
-    /** Display name, e.g. "claude" / "codex". */
-    kind: string;
-    /** Build the CLI argv (command itself excluded). */
-    buildArgs(opts: BuildArgsOpts): string[];
-    /** Reduce collected stream-json output lines to {sessionId, finalText, isError}. */
-    parseResult(lines: string[]): ParsedResult;
-    /**
-     * When true, the prompt is fed over stdin instead of being passed in argv.
-     * claude takes the prompt as `-p <prompt>` (argv) so leaves this unset; codex
-     * `exec` reads the prompt from stdin (its argv ends with a bare `-`).
-     */
-    promptViaStdin?: boolean;
-}
-/**
- * Soft cost-guard appended to a driven CC's system prompt. Workflow fans out a
- * fleet of agents and is the main token sink; we ask CC to surface intent and
- * get a go-ahead before running one, so a human can intervene (rooms) and the
- * model stays cost-aware even where Workflow isn't hard-disabled. Shared so the
- * room's resident process can reuse the exact same wording.
- */
-export declare const CC_COST_GUARD_PROMPT: string;
-export declare const claudeAdapter: AgentAdapter;
-/**
- * Drives the OpenAI Codex CLI via `codex exec`. Mirrors claudeAdapter but for
- * codex's different surface:
- *  - prompt is fed over STDIN (argv ends with a bare `-`), not argv → promptViaStdin
- *  - permission is a spawn-time SANDBOX choice, not a per-tool approval loop:
- *      default        → --sandbox read-only      (codex can read, not write)
- *      acceptEdits    → --sandbox workspace-write (codex can write the workspace)
- *      bypassPermissions → --dangerously-bypass-approvals-and-sandbox (full auto)
- *    (Matches the only model codex supports — same choice the `wand` tool makes;
- *    codex has no `--permission-prompt-tool stdio` equivalent.)
- *  - JSONL event shape differs: session id is `thread.started`.thread_id, the
- *    final answer is the last `item.completed` of item.type "agent_message", and
- *    failure is `turn.failed` / `error` events (no `is_error` flag).
- */
-export declare const codexAdapter: AgentAdapter;

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

@@ -1,143 +0,0 @@
-/**
- * Soft cost-guard appended to a driven CC's system prompt. Workflow fans out a
- * fleet of agents and is the main token sink; we ask CC to surface intent and
- * get a go-ahead before running one, so a human can intervene (rooms) and the
- * model stays cost-aware even where Workflow isn't hard-disabled. Shared so the
- * room's resident process can reuse the exact same wording.
- */
-export const CC_COST_GUARD_PROMPT = "Cost guard: before invoking the Workflow tool (which fans out many agents and " +
-    "burns a lot of tokens), first state in one short message what workflow you intend " +
-    "to run and why, and ask for a go-ahead — do NOT launch a Workflow unprompted. A " +
-    "single Task sub-agent is fine without asking.";
-export const claudeAdapter = {
-    kind: "claude",
-    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),
-        // CC's Workflow tool fans out a FLEET of agents — the real token-burn culprit
-        // (user: "自动了 2 个 workflow token 就烧没了"). A single Task (one sub-agent)
-        // is cheap, so it stays ALLOWED. (We earlier disallowed Task by mistake;
-        // Workflow is the one that fans out.) Disabling outright is cleaner than an
-        // approval round-trip this path doesn't have.
-        args.push("--disallowedTools", "Workflow");
-        // Soft constraint (belt-and-suspenders + carries to rooms where Workflow is
-        // allowed): ask CC to check in before expensive multi-agent work.
-        args.push("--append-system-prompt", CC_COST_GUARD_PROMPT);
-        args.push("--permission-mode", opts.permissionMode);
-        return args;
-    },
-    parseResult(lines) {
-        let sessionId = "";
-        let finalText = "";
-        let isError = false;
-        for (const line of lines) {
-            const t = line.trim();
-            if (!t)
-                continue;
-            let d;
-            try {
-                d = JSON.parse(t);
-            }
-            catch {
-                continue;
-            }
-            if (typeof d.session_id === "string" && !sessionId)
-                sessionId = d.session_id;
-            if (d.type === "result") {
-                if (typeof d.session_id === "string")
-                    sessionId = d.session_id;
-                if (typeof d.result === "string")
-                    finalText = d.result;
-                isError = Boolean(d.is_error);
-            }
-        }
-        return { sessionId, finalText, isError };
-    },
-};
-/**
- * Drives the OpenAI Codex CLI via `codex exec`. Mirrors claudeAdapter but for
- * codex's different surface:
- *  - prompt is fed over STDIN (argv ends with a bare `-`), not argv → promptViaStdin
- *  - permission is a spawn-time SANDBOX choice, not a per-tool approval loop:
- *      default        → --sandbox read-only      (codex can read, not write)
- *      acceptEdits    → --sandbox workspace-write (codex can write the workspace)
- *      bypassPermissions → --dangerously-bypass-approvals-and-sandbox (full auto)
- *    (Matches the only model codex supports — same choice the `wand` tool makes;
- *    codex has no `--permission-prompt-tool stdio` equivalent.)
- *  - JSONL event shape differs: session id is `thread.started`.thread_id, the
- *    final answer is the last `item.completed` of item.type "agent_message", and
- *    failure is `turn.failed` / `error` events (no `is_error` flag).
- */
-export const codexAdapter = {
-    kind: "codex",
-    promptViaStdin: true,
-    buildArgs(opts) {
-        const args = ["exec", "--json", "--color", "never", "--skip-git-repo-check"];
-        if (opts.permissionMode === "bypassPermissions") {
-            args.push("--dangerously-bypass-approvals-and-sandbox");
-        }
-        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);
-        }
-        // `resume <thread_id>` continues a prior codex session; the trailing `-`
-        // tells codex exec to read the prompt from stdin (we feed it there).
-        if (opts.resumeSessionId)
-            args.push("resume", opts.resumeSessionId, "-");
-        else
-            args.push("-");
-        return args;
-    },
-    parseResult(lines) {
-        let sessionId = "";
-        let finalText = "";
-        let isError = false;
-        const errorBits = [];
-        for (const line of lines) {
-            const t = line.trim();
-            if (!t)
-                continue;
-            let d;
-            try {
-                d = JSON.parse(t);
-            }
-            catch {
-                continue;
-            }
-            if (d.type === "thread.started" && typeof d.thread_id === "string")
-                sessionId = d.thread_id;
-            else if (d.type === "item.completed" &&
-                d.item?.type === "agent_message" &&
-                typeof d.item.text === "string") {
-                finalText = d.item.text; // keep the LAST agent_message
-            }
-            else if (d.type === "turn.failed") {
-                isError = true;
-                const msg = d.error?.message ?? d.error ?? "turn failed";
-                if (typeof msg === "string")
-                    errorBits.push(msg);
-            }
-            else if (d.type === "error") {
-                isError = true;
-                const msg = d.message ?? d.error?.message ?? d.error ?? "error";
-                if (typeof msg === "string")
-                    errorBits.push(msg);
-            }
-        }
-        // On failure, surface the error text as finalText (so the caller/notification
-        // shows *why*), preferring it over any partial agent_message.
-        if (isError && errorBits.length)
-            finalText = errorBits.join("\n");
-        return { sessionId, finalText, isError };
-    },
-};

package/dist/cc-orchestrator/cc-capability.d.ts

@@ -1,19 +0,0 @@
-export interface CCAvailability {
-    available: boolean;
-    command: string;
-    version?: string;
-    reason?: "not-found" | "not-executable";
-}
-/** macOS GUI-launched Electron has a minimal PATH (no Homebrew). Prepend common
- *  CLI dirs so `claude` resolves. Mirrors resident-agent.ts's fix. */
-export declare function pathWithCommonBins(env?: NodeJS.ProcessEnv): string;
-export type ProbeRunner = (command: string) => Promise<{
-    ok: boolean;
-    stdout: string;
-}>;
-/** Probe a CLI's availability. Injectable runner for tests. */
-export declare function probeCli(command: string, runner?: ProbeRunner): Promise<CCAvailability>;
-/** Cached probe; pass force=true to re-detect (user installed CLI mid-session). */
-export declare function probeClaudeCli(force?: boolean): Promise<CCAvailability>;
-/** Cached probe for the OpenAI Codex CLI; force=true re-detects. */
-export declare function probeCodexCli(force?: boolean): Promise<CCAvailability>;

package/dist/cc-orchestrator/cc-capability.js

@@ -1,53 +0,0 @@
-import { spawn } from "node:child_process";
-import { delimiter } from "node:path";
-/** macOS GUI-launched Electron has a minimal PATH (no Homebrew). Prepend common
- *  CLI dirs so `claude` resolves. Mirrors resident-agent.ts's fix. */
-export function pathWithCommonBins(env = process.env) {
-    const extra = ["/opt/homebrew/bin", "/usr/local/bin", "/usr/bin", "/bin"];
-    const current = (env.PATH ?? "").split(delimiter).filter(Boolean);
-    const merged = [];
-    for (const dir of [...extra, ...current])
-        if (!merged.includes(dir))
-            merged.push(dir);
-    return merged.join(delimiter);
-}
-/** Default runner: `<command> --version` with PATH fix. */
-const defaultRunner = (command) => new Promise((resolve, reject) => {
-    const child = spawn(command, ["--version"], {
-        env: { ...process.env, PATH: pathWithCommonBins() },
-        stdio: ["ignore", "pipe", "pipe"],
-    });
-    let stdout = "";
-    child.stdout?.on("data", (c) => (stdout += String(c)));
-    child.on("error", reject);
-    child.on("exit", (code) => resolve({ ok: code === 0, stdout }));
-});
-/** Probe a CLI's availability. Injectable runner for tests. */
-export async function probeCli(command, runner = defaultRunner) {
-    try {
-        const { ok, stdout } = await runner(command);
-        if (!ok)
-            return { available: false, command, reason: "not-executable" };
-        return { available: true, command, version: stdout.trim() || undefined };
-    }
-    catch (err) {
-        const code = err.code;
-        return { available: false, command, reason: code === "ENOENT" ? "not-found" : "not-executable" };
-    }
-}
-let cached;
-/** Cached probe; pass force=true to re-detect (user installed CLI mid-session). */
-export async function probeClaudeCli(force = false) {
-    if (cached && !force)
-        return cached;
-    cached = await probeCli("claude");
-    return cached;
-}
-let cachedCodex;
-/** Cached probe for the OpenAI Codex CLI; force=true re-detects. */
-export async function probeCodexCli(force = false) {
-    if (cachedCodex && !force)
-        return cachedCodex;
-    cachedCodex = await probeCli("codex");
-    return cachedCodex;
-}

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

@@ -1,24 +0,0 @@
-import type { DiscoveredSession, DiscoverOptions } 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 declare function discoverCodexSessions(cwd: string, codexHome?: string, opts?: DiscoverOptions): DiscoveredSession[];
-/** 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 declare function countCodexSessions(cwd: string, codexHome?: string): number;

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

@@ -1,191 +0,0 @@
-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

@@ -1,38 +0,0 @@
-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
- * 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;
-};
-/** 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;