@cjhyy/code-shell-capability-coding 0.9.44 → 0.9.47

package/dist/external-runtimes/claude-code/text-inference.js

@@ -0,0 +1,240 @@
+import { spawn } from "node:child_process";
+import { chmod, mkdtemp, rm, writeFile } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import { join } from "node:path";
+import { killProcessGroup } from "@cjhyy/code-shell-core/extension";
+const MAX_OUTPUT_BYTES = 2 * 1024 * 1024;
+const MAX_STDERR_BYTES = 64 * 1024;
+const MAX_INPUT_BYTES = 2 * 1024 * 1024;
+function usageFromResult(value) {
+    if (!value || typeof value !== "object")
+        return undefined;
+    const raw = value;
+    const input = raw.input_tokens;
+    const output = raw.output_tokens;
+    const read = raw.cache_read_input_tokens ?? 0;
+    const write = raw.cache_creation_input_tokens ?? 0;
+    if (![input, output, read, write].every((count) => Number.isSafeInteger(count) && Number(count) >= 0))
+        return undefined;
+    const promptTokens = Number(input) + Number(read) + Number(write);
+    const totalTokens = promptTokens + Number(output);
+    if (!Number.isSafeInteger(totalTokens))
+        return undefined;
+    return {
+        promptTokens,
+        completionTokens: Number(output),
+        totalTokens,
+        ...(raw.cache_read_input_tokens !== undefined ? { cacheReadTokens: Number(read) } : {}),
+        ...(raw.cache_creation_input_tokens !== undefined
+            ? { cacheCreationTokens: Number(write) }
+            : {}),
+    };
+}
+/** Fresh CLI inference, with no conversation, Host tools or user customizations. */
+export async function runClaudeTextInference(options, dependencies = {}) {
+    options.signal?.throwIfAborted();
+    if (!options.systemPrompt?.trim() || !options.userMessage?.trim())
+        throw new Error("Claude text inference requires a system prompt and user message");
+    if (Buffer.byteLength(options.systemPrompt) + Buffer.byteLength(options.userMessage) >
+        MAX_INPUT_BYTES)
+        throw new Error("Claude text inference input exceeds its byte limit");
+    const maxTokens = options.maxTokens ?? 3072;
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    if (!Number.isSafeInteger(maxTokens) || maxTokens < 1 || maxTokens > 128_000)
+        throw new Error("Invalid Claude text inference output budget");
+    if (!Number.isSafeInteger(timeoutMs) || timeoutMs < 1 || timeoutMs > 3_600_000)
+        throw new Error("Invalid Claude text inference timeout");
+    const privateDir = await mkdtemp(join(tmpdir(), "codeshell-claude-text-"));
+    try {
+        await chmod(privateDir, 0o700);
+        const systemPromptFile = join(privateDir, "system-prompt.txt");
+        await writeFile(systemPromptFile, options.systemPrompt, { mode: 0o600 });
+        await chmod(systemPromptFile, 0o600);
+        options.signal?.throwIfAborted();
+        const args = [
+            "-p",
+            "--output-format",
+            "stream-json",
+            "--verbose",
+            "--include-partial-messages",
+            "--safe-mode",
+            "--tools",
+            "",
+            "--disallowedTools",
+            "*",
+            "--strict-mcp-config",
+            "--disable-slash-commands",
+            "--no-session-persistence",
+            "--permission-mode",
+            "dontAsk",
+            "--permission-prompts",
+            "none",
+            "--max-turns",
+            "1",
+            "--system-prompt-file",
+            systemPromptFile,
+            ...(options.model ? ["--model", options.model] : []),
+        ];
+        // Safe mode keeps the CLI's auth/provider selection, unlike --bare. Managed
+        // policy (including managed hooks) remains authoritative inside the CLI.
+        const env = {
+            ...(options.env ?? process.env),
+            CLAUDE_CODE_SAFE_MODE: "1",
+            CLAUDE_CODE_MAX_OUTPUT_TOKENS: String(maxTokens),
+            CLAUDE_CODE_DISABLE_NONESSENTIAL_TRAFFIC: "1",
+            CLAUDE_CODE_DISABLE_TERMINAL_TITLE: "1",
+            CLAUDE_CODE_DISABLE_FILE_MENTIONS: "1",
+        };
+        for (const name of [
+            "CLAUDECODE",
+            "CLAUDE_CODE_ENTRYPOINT",
+            "CLAUDE_CODE_SIMPLE",
+            "CODESHELL_CODEX_MCP_TOKEN",
+            "CODE_SHELL_HOST_MCP_SERVERS",
+            "CODESHELL_MODEL_TRACE_FD",
+        ])
+            delete env[name];
+        return await new Promise((resolve, reject) => {
+            const launch = dependencies.spawn ?? spawn;
+            const child = launch(options.command ?? "claude", args, {
+                cwd: options.cwd ?? privateDir,
+                env,
+                shell: false,
+                detached: process.platform !== "win32",
+                stdio: ["pipe", "pipe", "pipe"],
+            });
+            let outputBytes = 0;
+            let stderrBytes = 0;
+            let pending = "";
+            let terminal;
+            let stopReason;
+            let failure;
+            let settling = false;
+            let stopping;
+            const stop = () => {
+                stopping ??= child.pid ? killProcessGroup(child.pid, { graceMs: 250 }) : Promise.resolve();
+                return stopping;
+            };
+            const finish = (code, signal) => {
+                if (settling)
+                    return;
+                settling = true;
+                clearTimeout(timer);
+                options.signal?.removeEventListener("abort", onAbort);
+                void stop().then(() => {
+                    child.stdin.destroy();
+                    child.stdout.destroy();
+                    child.stderr.destroy();
+                    if (failure)
+                        return reject(failure);
+                    if (code !== 0 || signal)
+                        return reject(new Error(`Claude text inference exited without success (${signal ?? code})`));
+                    try {
+                        if (pending.trim())
+                            accept(pending);
+                        if (!terminal)
+                            throw new Error("Claude text inference produced no terminal result");
+                        resolve({
+                            text: terminal.result,
+                            usage: usageFromResult(terminal.usage),
+                            stopReason,
+                        });
+                    }
+                    catch (error) {
+                        reject(error);
+                    }
+                }, reject);
+            };
+            const fail = (error) => {
+                if (settling || failure)
+                    return;
+                failure = error;
+                void stop().then(() => finish(), reject);
+            };
+            const acceptStopReason = (value) => {
+                if (typeof value !== "string")
+                    return;
+                if (!["end_turn", "stop", "stop_sequence"].includes(value))
+                    throw new Error(`Claude text inference stopped without complete text (${value})`);
+                stopReason = value;
+            };
+            const accept = (line) => {
+                if (!line.trim())
+                    return;
+                let item;
+                try {
+                    item = JSON.parse(line);
+                }
+                catch {
+                    throw new Error("Claude text inference emitted malformed JSON");
+                }
+                if (!item || typeof item !== "object" || Array.isArray(item))
+                    throw new Error("Claude text inference emitted a malformed event");
+                const content = item.message?.content;
+                const block = item.event?.content_block;
+                if (["tool_progress", "tool_use_summary"].includes(item.type) ||
+                    (item.type === "control_request" && item.request?.subtype === "can_use_tool") ||
+                    ["tool_use", "server_tool_use"].includes(block?.type) ||
+                    (Array.isArray(content) &&
+                        content.some((part) => ["tool_use", "server_tool_use", "tool_result"].includes(part?.type))) ||
+                    (item.type === "system" && item.subtype === "init" && item.tools?.length > 0))
+                    throw new Error("Claude text inference attempted to use tools");
+                if (item.type === "assistant")
+                    acceptStopReason(item.message?.stop_reason);
+                if (item.type === "stream_event" && item.event?.type === "message_delta")
+                    acceptStopReason(item.event.delta?.stop_reason);
+                if (item.type !== "result")
+                    return;
+                if (terminal)
+                    throw new Error("Claude text inference emitted multiple terminal results");
+                if (item.is_error !== false ||
+                    item.subtype !== "success" ||
+                    typeof item.result !== "string" ||
+                    !item.result.trim() ||
+                    (Array.isArray(item.errors) && item.errors.length > 0))
+                    throw new Error("Claude text inference returned an incomplete or failed result");
+                acceptStopReason(item.stop_reason);
+                terminal = item;
+            };
+            const onAbort = () => fail(Object.assign(new Error("Claude text inference aborted"), { name: "AbortError" }));
+            const timer = setTimeout(() => fail(new Error(`Claude text inference timed out after ${timeoutMs}ms`)), timeoutMs);
+            child.stdout.setEncoding("utf8");
+            child.stdout.on("data", (chunk) => {
+                if (settling || failure)
+                    return;
+                outputBytes += Buffer.byteLength(chunk);
+                if (outputBytes > MAX_OUTPUT_BYTES)
+                    return fail(new Error("Claude text inference output exceeds its byte limit"));
+                pending += chunk;
+                try {
+                    for (let newline; (newline = pending.indexOf("\n")) >= 0;) {
+                        const line = pending.slice(0, newline);
+                        pending = pending.slice(newline + 1);
+                        accept(line);
+                    }
+                }
+                catch (error) {
+                    fail(error);
+                }
+            });
+            child.stderr.on("data", (chunk) => {
+                stderrBytes += chunk.byteLength;
+                if (stderrBytes > MAX_STDERR_BYTES)
+                    fail(new Error("Claude text inference diagnostics exceed their byte limit"));
+            });
+            child.stdin.on("error", (error) => fail(error));
+            child.stdout.on("error", (error) => fail(error));
+            child.stderr.on("error", (error) => fail(error));
+            child.once("error", (error) => fail(error));
+            child.once("close", finish);
+            options.signal?.addEventListener("abort", onAbort, { once: true });
+            if (options.signal?.aborted)
+                onAbort();
+            else
+                child.stdin.end(options.userMessage);
+        });
+    }
+    finally {
+        await rm(privateDir, { recursive: true, force: true });
+    }
+}

package/dist/external-runtimes/codex/app-server-client.d.ts

@@ -21,6 +21,14 @@ export type NotificationHandler = (method: string, params: unknown) => void;
  * waiting either way.
  */
 export type ServerRequestHandler = (method: string, params: unknown) => Promise<unknown> | unknown;
+/**
+ * Told once when the transport is gone for good — the process exited or failed
+ * to spawn, the stream broke, or {@link CodexAppServerClient.close} ran. Pending
+ * requests are rejected by then; this is for state that is NOT a request, such
+ * as a turn whose RPC was already answered and now waits on notifications that
+ * can never arrive.
+ */
+export type CloseHandler = (reason: string) => void;
 export declare class CodexAppServerClient {
     private readonly options;
     private child?;
@@ -29,7 +37,9 @@ export declare class CodexAppServerClient {
     private readonly pending;
     private notificationHandler?;
     private requestHandler?;
+    private closeHandler?;
     private closed;
+    private closing?;
     private closeReason?;
     /** Buffer lines that arrive before a handler exists, then drain in order. */
     private readonly preHandlerLines;
@@ -42,6 +52,7 @@ export declare class CodexAppServerClient {
      */
     onNotification(handler: NotificationHandler): void;
     onServerRequest(handler: ServerRequestHandler): void;
+    onClose(handler: CloseHandler): void;
     /** Spawn the app-server. Handlers must already be registered. */
     start(): void;
     private acceptLine;
@@ -59,8 +70,12 @@ export declare class CodexAppServerClient {
     request(method: string, params?: unknown, timeoutMs?: number): Promise<unknown>;
     notify(method: string, params?: unknown): void;
     private write;
+    private failInput;
     private failAll;
+    /** Why the transport closed, once it has. */
+    get closedReason(): string | undefined;
     get isClosed(): boolean;
     /** Stop via stdin EOF, then SIGTERM and SIGKILL if the server does not exit. */
     close(): Promise<void>;
+    private stop;
 }

package/dist/external-runtimes/codex/app-server-client.js

@@ -36,7 +36,9 @@ export class CodexAppServerClient {
     pending = new Map();
     notificationHandler;
     requestHandler;
+    closeHandler;
     closed = false;
+    closing;
     closeReason;
     /** Buffer lines that arrive before a handler exists, then drain in order. */
     preHandlerLines = [];
@@ -56,8 +58,13 @@ export class CodexAppServerClient {
     onServerRequest(handler) {
         this.requestHandler = handler;
     }
+    onClose(handler) {
+        this.closeHandler = handler;
+    }
     /** Spawn the app-server. Handlers must already be registered. */
     start() {
+        if (this.closed)
+            throw new Error(this.closeReason ?? "app-server client is closed");
         if (this.child)
             return;
         const command = this.options.command ?? "codex";
@@ -70,6 +77,12 @@ export class CodexAppServerClient {
             stdio: ["pipe", "pipe", "pipe"],
             shell: false,
         });
+        this.child.stdin.on("error", (error) => {
+            // Failed spawns have no pid; ChildProcess.error owns their OS diagnostic.
+            if (this.child?.pid === undefined)
+                return;
+            this.failInput(error);
+        });
         this.child.stdout.setEncoding("utf8");
         this.lines = createInterface({ input: this.child.stdout, crlfDelay: Infinity });
         this.lines.on("line", (line) => this.acceptLine(line));
@@ -114,6 +127,8 @@ export class CodexAppServerClient {
         this.handleLine(line);
     }
     handleLine(line) {
+        if (this.closed)
+            return;
         if (line.length > MAX_LINE_BYTES) {
             // Oversized is a transport failure: parsing it would stall the event loop.
             this.failAll("app-server sent an oversized line");
@@ -208,7 +223,17 @@ export class CodexAppServerClient {
                 }, timeoutMs);
             }
             this.pending.set(id, entry);
-            this.write({ id, method, params: params ?? {} });
+            try {
+                this.write({ id, method, params: params ?? {} });
+            }
+            catch (error) {
+                // Invalid caller data was never written. Release only this request;
+                // serialization failures say nothing about the transport's health.
+                this.pending.delete(id);
+                if (entry.timer)
+                    clearTimeout(entry.timer);
+                reject(error);
+            }
         });
     }
     notify(method, params) {
@@ -218,9 +243,27 @@ export class CodexAppServerClient {
     }
     write(payload) {
         const child = this.child;
-        if (!child || child.stdin.destroyed)
+        if (this.closed)
             return;
-        child.stdin.write(`${JSON.stringify(payload)}\n`);
+        if (child && child.pid === undefined)
+            return;
+        if (!child || child.stdin.destroyed || !child.stdin.writable) {
+            this.failInput();
+            return;
+        }
+        const line = `${JSON.stringify(payload)}\n`;
+        try {
+            child.stdin.write(line);
+        }
+        catch (error) {
+            this.failInput(error);
+        }
+    }
+    failInput(error) {
+        this.failAll(`app-server input pipe closed${error?.code ? ` (${diagnosticText(error.code)})` : ""}`);
+        // Reject outstanding RPCs now and terminate even when the process keeps
+        // running after closing fd 0. close() owns one bounded cleanup sequence.
+        void this.close();
     }
     failAll(reason, details = {}) {
         if (this.closed)
@@ -234,15 +277,35 @@ export class CodexAppServerClient {
             entry.reject(new Error(reason));
         }
         this.pending.clear();
+        try {
+            this.closeHandler?.(reason);
+        }
+        catch (error) {
+            this.log("appserver.close_handler_failed", {
+                error: error instanceof Error ? error.name : "unknown",
+            });
+        }
+    }
+    /** Why the transport closed, once it has. */
+    get closedReason() {
+        return this.closeReason;
     }
     get isClosed() {
         return this.closed;
     }
     /** Stop via stdin EOF, then SIGTERM and SIGKILL if the server does not exit. */
-    async close() {
+    close() {
+        if (!this.closing) {
+            // Publish cleanup ownership before notifying callers, whose onClose may
+            // itself call close(). One process must have only one escalation timer.
+            this.closing = Promise.resolve().then(() => this.stop());
+            this.failAll("app-server client closed");
+            this.lines?.close();
+        }
+        return this.closing;
+    }
+    async stop() {
         const child = this.child;
-        this.failAll("app-server client closed");
-        this.lines?.close();
         // Failed spawns have no pid and never emit `exit`. A process already killed
         // by a signal likewise has no numeric exitCode and will not emit it again.
         if (!child || !child.pid || child.exitCode !== null || child.signalCode !== null)

package/dist/external-runtimes/codex/event-translator.js

@@ -48,6 +48,21 @@ function toolArgsOf(item) {
     }
     return args;
 }
+function toolErrorOf(item, type) {
+    const detail = str(asRecord(item.error)?.message) ?? str(item.error);
+    if (detail)
+        return detail;
+    // A completed app-server item means the operation settled, not that its
+    // command succeeded. In particular, nonzero exits often have no error object.
+    if (type === "commandExecution" && Number.isInteger(item.exitCode) && item.exitCode !== 0) {
+        return `Command exited with code ${item.exitCode}.`;
+    }
+    if (item.status === "failed")
+        return `${type} failed.`;
+    if (item.status === "declined")
+        return `${type} was declined.`;
+    return undefined;
+}
 /**
  * Map a Codex turn status onto a CodeShell `TerminalReason`.
  *
@@ -350,8 +365,7 @@ export class CodexEventTranslator {
                 output = String(rawOutput);
             }
         }
-        const error = asRecord(item.error);
-        const errorMessage = str(error?.message) ?? str(item.error);
+        const errorMessage = toolErrorOf(item, type);
         const events = [];
         // Correct the arguments first when they only materialized now, so the
         // recorded call shows what actually ran before its result.

package/dist/external-runtimes/codex/runtime.d.ts

@@ -77,6 +77,7 @@ export declare class CodexRuntime {
     private readonly log;
     private translator?;
     private threadId?;
+    private reportedModel?;
     private started;
     private resumed;
     private firstTurn;
@@ -85,6 +86,8 @@ export declare class CodexRuntime {
     /** Codex thread id, once the thread exists. Protocol routing only — never the
      *  authorization subject (§8.1). */
     get runtimeSessionId(): string | undefined;
+    /** CLI-reported model, falling back to the requested model until reported. */
+    get resolvedModel(): string | undefined;
     /**
      * Spawn the app-server, handshake, and open a thread.
      *
@@ -111,7 +114,18 @@ export declare class CodexRuntime {
      * that no further step starts (§13.3).
      */
     interrupt(): Promise<void>;
+    private requestInterrupt;
     close(): Promise<void>;
+    /** Learn the active turn's id; deliver a Stop that was waiting for it, once. */
+    private bindTurnId;
+    /**
+     * The app-server is gone (exited, failed, broken stream). A turn Codex already
+     * accepted would otherwise wait forever for a `turn/completed` that can never
+     * arrive, so report it terminal now as a model error. A turn whose
+     * `turn/start` is still unanswered is NOT reported here: that RPC rejects, and
+     * the rejected `send()` is its caller's terminal signal.
+     */
+    private onTransportClosed;
     private onNotification;
     private emitEvent;
     /**