super-dsh 0.1.0 → 0.1.2

package/agent-codex/dist/app-home.js

@@ -0,0 +1,65 @@
+/**
+ * Codex runtime app home bootstrap — idempotently creates the codex home and
+ * seeds it with the Codex CLI's own config set (config.toml / model catalog /
+ * auth) copied once from the native `~/.codex`.
+ *
+ * Why this is required, not cosmetic: a Codex home without `config.toml` makes
+ * the CLI fall back to its built-in OpenAI provider, so every turn dies on
+ * `wss://api.openai.com/v1/responses` with a region block (403 "Country,
+ * region, or territory not supported"). The native home is where the user's
+ * provider wiring lives (e.g. a local proxy: `model_provider = "custom"`,
+ * `base_url = "http://127.0.0.1:15721/v1"`, `model = "glm-5.3-flash"`), and the
+ * world deliberately runs with its own CODEX_HOME — so the config has to travel.
+ *
+ * Same manners as the OMP twin: never overwrites an existing file (a
+ * provisioned app home wins), skips missing sources, and is fail-soft — the app
+ * home is derived state, never a boot gate.
+ */
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { homedir } from "node:os";
+import { join } from "node:path";
+import { resolveCodexHome } from "./codex-store.js";
+/**
+ * Config files seeded into the codex home. `config.toml` names the provider and
+ * model, `cc-switch-model-catalog.json` is what its `model_catalog_json` key
+ * points at (a relative path, hence the same directory), and `auth.json` is the
+ * CLI's own credential record.
+ */
+export const CODEX_HOME_CONFIG_FILES = ["config.toml", "cc-switch-model-catalog.json", "auth.json"];
+/** Native codex home — the copy source (`AW_CODEX_SEED_HOME` overrides). */
+export function defaultCodexSeedHome() {
+    const configured = process.env.AW_CODEX_SEED_HOME;
+    return configured !== undefined && configured !== "" ? configured : join(homedir(), ".codex");
+}
+/**
+ * Ensure the codex home exists and carries the CLI config set.
+ *
+ * @param options - target/source/files overrides.
+ * @returns the resolved codex home path (always, even on a failed seed).
+ */
+export function ensureCodexAppHome(options = {}) {
+    const codexHome = options.codexHome ?? resolveCodexHome();
+    const source = options.seedHome ?? defaultCodexSeedHome();
+    const files = options.files ?? CODEX_HOME_CONFIG_FILES;
+    const seeded = [];
+    try {
+        mkdirSync(codexHome, { recursive: true });
+        for (const name of files) {
+            const dest = join(codexHome, name);
+            if (existsSync(dest))
+                continue;
+            const src = join(source, name);
+            if (!existsSync(src))
+                continue;
+            copyFileSync(src, dest);
+            seeded.push(name);
+        }
+        if (seeded.length > 0) {
+            options.warn?.(`codex-provider: app home ${codexHome} seeded from ${source} (${seeded.join(", ")})`);
+        }
+    }
+    catch (error) {
+        options.warn?.(`codex-provider: app-home bootstrap failed (fail-soft): ${String(error)}`);
+    }
+    return codexHome;
+}

package/agent-codex/dist/codex-client.js

@@ -0,0 +1,469 @@
+/**
+ * CodexSdkClient — the SDK-line client seam (AW-E Task 3).
+ *
+ * Public surface mirrors `OmpSdkClient` (agent-omp/src/sdk-client.ts) exactly —
+ * `spawn` / `on` / `onFailure` / `sendRaw` / `send` / `getState` / `getMessages`
+ * / `getSessionStats` / `getSubagents` / `prompt` / `followUp` / `steer` /
+ * `setModel` / `abort` / `newSession` / `close` / `ensureStarted` / `spawned` —
+ * so the Task 7 agent.ts/index.ts port compiles against this client the way it
+ * compiles against the omp one. Instead of one `omp --mode rpc` sidecar per
+ * session, ALL clients multiplex ONE module-level refcounted `Codex` instance
+ * (same acquire()/release() pattern as the omp sidecar; the SDK spawns its own
+ * per-turn codex process, so dropping the shared instance needs no stop call).
+ *
+ * Codex home: the shared instance is constructed with `{ env: { ...process.env } }`
+ * (SDK env is REPLACE semantics — Task 1 spike fact, so the spread is
+ * mandatory) and carries NO `CODEX_HOME`: the CLI resolves its own native
+ * `~/.codex` (user ruling 2026-09-17 — never redirect the native app home at
+ * spawn; tests redirect via `process.env.CODEX_HOME`). The SDK constructor
+ * itself is injectable via {@link setCodexFactory}.
+ *
+ * Wire events flow through `projectThreadEvent` (codex-events.ts) before
+ * reaching listeners, so Task 7's agent.ts switch is unchanged from omp.
+ */
+import { Codex } from "@openai/codex-sdk";
+import { projectThreadEvent } from "./codex-events.js";
+let codexFactory = (options) => new Codex(options);
+/** Replace the SDK constructor (tests inject a fake Codex). */
+export function setCodexFactory(factory) {
+    codexFactory = factory;
+}
+// ---------------------------------------------------------------------------
+// Shared Codex instance (module-level singleton, refcounted — omp sidecar pattern)
+// ---------------------------------------------------------------------------
+let sharedCodex = null;
+let refcount = 0;
+function acquire() {
+    if (sharedCodex === null) {
+        sharedCodex = codexFactory({ env: { ...process.env } });
+    }
+    refcount += 1;
+    return sharedCodex;
+}
+function release() {
+    refcount = Math.max(0, refcount - 1);
+    if (refcount === 0)
+        sharedCodex = null;
+}
+/** Test/observability hook: current shared-instance refcount (0 = none alive). */
+export function codexClientRefCount() {
+    return refcount;
+}
+function ok(command) {
+    return { type: "response", command, success: true };
+}
+function asRecord(value) {
+    if (value === null || typeof value !== "object" || Array.isArray(value))
+        return null;
+    return value;
+}
+/**
+ * Parse the omp-style spawn args. `--approval-mode <v>` is accepted and
+ * applied verbatim as the thread's launch `approvalPolicy` — the 3-preset
+ * mapping resolves the VALUE provider-side (Task 7's permission.ts) and the
+ * thread carries it on every construction (start, resume, setModel rebuild).
+ * `--resume-thread <id>` constructs the client on `codex.resumeThread(id, …)`
+ * — the thread-identity resume (plan Task 7), strictly distinct from the
+ * rejected omp-style `--resume <file>`, which keeps failing loudly exactly
+ * like unknown args.
+ */
+function parseSpawnArgs(args) {
+    const out = {};
+    for (let i = 0; i < args.length; i++) {
+        if (args[i] === "--approval-mode" && args[i + 1] !== undefined) {
+            out.approvalMode = args[++i];
+        }
+        else if (args[i] === "--resume-thread" && args[i + 1] !== undefined) {
+            out.resumeThreadId = args[++i];
+        }
+        else {
+            throw new Error(`CodexSdkClient: unsupported spawn arg "${String(args[i])}" (SDK line)`);
+        }
+    }
+    return out;
+}
+// ---------------------------------------------------------------------------
+export class CodexSdkClient {
+    #codex;
+    #listeners = new Set();
+    #failureListeners = new Set();
+    #threadOptions;
+    #messages = [];
+    #queue = [];
+    #approvalMode;
+    #thread;
+    #closed = false;
+    #failure = null;
+    #inFlight = false;
+    #currentAbort = null;
+    #currentRun = null;
+    #pendingModel = null;
+    #appliedModel = null;
+    #lastUsage = null;
+    /** Bumped by newSession()/close() to orphan runs started on an earlier thread. */
+    #sessionEpoch = 0;
+    constructor(codex, cwd, approvalMode, resumeThreadId) {
+        this.#codex = codex;
+        this.#approvalMode = approvalMode;
+        // skipGitRepoCheck: adapters spawn from arbitrary test/worktree cwds (Task 1 spike precedent).
+        // Launch-only approval mapping (Task 7): present only when the provider
+        // resolved a preset, so plain spawns keep the bare ThreadOptions shape.
+        this.#threadOptions = {
+            workingDirectory: cwd,
+            skipGitRepoCheck: true,
+            ...(approvalMode === undefined ? {} : { approvalPolicy: approvalMode }),
+        };
+        // `--resume-thread <id>` re-attaches to the existing Codex thread (the
+        // model context lives in Codex's rollout); plain spawn starts a fresh one.
+        this.#thread =
+            resumeThreadId === undefined ? codex.startThread(this.#threadOptions) : codex.resumeThread(resumeThreadId, this.#threadOptions);
+    }
+    /**
+     * Start a session on the shared Codex instance and resolve once ready.
+     * Mirrors `OmpSdkClient.spawn(args, cwd)`.
+     */
+    static async spawn(args = [], cwd) {
+        const { approvalMode, resumeThreadId } = parseSpawnArgs(args);
+        const codex = acquire();
+        try {
+            return new CodexSdkClient(codex, cwd, approvalMode, resumeThreadId);
+        }
+        catch (error) {
+            release();
+            throw error;
+        }
+    }
+    /** Register a wire event listener; returns the unsubscriber. */
+    on(listener) {
+        this.#listeners.add(listener);
+        return () => {
+            this.#listeners.delete(listener);
+        };
+    }
+    /** Register a failure listener; returns the unsubscriber. */
+    onFailure(listener) {
+        this.#failureListeners.add(listener);
+        return () => {
+            this.#failureListeners.delete(listener);
+        };
+    }
+    /**
+     * Raw-command escape hatch. The SDK line has no stdio command channel, so
+     * RPC-specific records (e.g. `extension_ui_response` approval answers) are
+     * accepted and logged under CODEX_TRACE=1 — approval flows route through
+     * SDK-side approval work (Task 7 parity item).
+     */
+    sendRaw(command) {
+        if (this.#failure !== null || this.#closed)
+            return;
+        if (process.env.CODEX_TRACE === "1") {
+            process.stderr.write(`[codex-sdk] sendRaw (no-op on SDK line): ${JSON.stringify(command).slice(0, 160)}\n`);
+        }
+    }
+    /** Generic command sender mapping the omp command table onto client methods. */
+    async send(command) {
+        switch (command.type) {
+            case "prompt":
+                await this.prompt(String(command.message));
+                return ok("prompt");
+            case "steer":
+                await this.steer(String(command.message));
+                return ok("steer");
+            case "follow_up":
+                await this.followUp(String(command.message));
+                return ok("follow_up");
+            case "abort":
+                await this.abort();
+                return ok("abort");
+            case "set_model":
+                await this.setModel(String(command.provider), String(command.modelId));
+                return ok("set_model");
+            case "new_session":
+                await this.newSession();
+                return ok("new_session");
+            case "get_state":
+                return { type: "response", command: "get_state", success: true, data: await this.getState() };
+            case "get_messages":
+                return { type: "response", command: "get_messages", success: true, data: { messages: await this.getMessages() } };
+            default:
+                throw new Error(`CodexSdkClient.send: unsupported command "${String(command.type)}" (SDK line)`);
+        }
+    }
+    /** Query session state; returns the `get_state`-shaped payload. */
+    async getState() {
+        this.#ensureUsable();
+        return { isStreaming: this.#inFlight };
+    }
+    /**
+     * Best-effort conversation mirror accumulated from the wire (user echoes at
+     * acceptance, assistant message_end, toolResult). The authoritative
+     * transcript comes from the rollout scan (codex-store.ts); reasoning-only
+     * messages are not mirrored. Fail-soft: [] when nothing accumulated.
+     */
+    async getMessages() {
+        try {
+            return [...this.#messages];
+        }
+        catch {
+            return [];
+        }
+    }
+    /** Live token accounting from the last turn_end usage (fail-soft {}). */
+    async getSessionStats() {
+        try {
+            const usage = this.#lastUsage;
+            if (usage === null)
+                return {};
+            const tokens = {};
+            const map = [
+                ["input", "input_tokens"],
+                ["output", "output_tokens"],
+                ["cacheRead", "cached_input_tokens"],
+                ["cacheWrite", "cache_write_input_tokens"],
+            ];
+            for (const [wireKey, codexKey] of map) {
+                const value = usage[codexKey];
+                if (typeof value === "number")
+                    tokens[wireKey] = value;
+            }
+            return { tokens };
+        }
+        catch {
+            return {};
+        }
+    }
+    /** Codex has no subagent registry (fail-soft constant, omp surface parity). */
+    async getSubagents() {
+        return [];
+    }
+    /** Start a turn with a user prompt (fire-and-forget acceptance). */
+    async prompt(message) {
+        this.#ensureUsable();
+        this.#enqueueOrRun(message);
+        return ok("prompt");
+    }
+    /** Queue a follow-up on a busy session (runs immediately when idle). */
+    async followUp(message) {
+        this.#ensureUsable();
+        this.#enqueueOrRun(message);
+        return ok("follow_up");
+    }
+    /**
+     * Steer an in-flight turn — 2026-09-10 gap table: the SDK line has no steer,
+     * so this is the queued-followUp approximation (plan Global Constraints:
+     * "无 steer（→ followUp 队列近似）"); while idle it degrades to a plain
+     * prompt, while in flight the message runs right after the current turn
+     * settles.
+     */
+    async steer(message) {
+        this.#ensureUsable();
+        if (this.#inFlight && process.env.CODEX_TRACE === "1") {
+            process.stderr.write("[codex-sdk] steer approximated as queued followUp (SDK gap)\n");
+        }
+        this.#enqueueOrRun(message);
+        return ok("steer");
+    }
+    /**
+     * Select the active model. SDK has no live setModel (2026-09-10 gap table):
+     * the id is stored and applied as the `model` ThreadOption on the NEXT run —
+     * via resumeThread when the thread already has an id, so conversation
+     * context survives the model switch. `provider` is accepted for surface
+     * parity; codex resolves models from its own catalog.
+     */
+    async setModel(provider, modelId) {
+        this.#ensureUsable();
+        void provider;
+        this.#pendingModel = modelId;
+        return ok("set_model");
+    }
+    /** Abort the current streaming run (AbortController per run, turn-level signal). */
+    async abort() {
+        this.#currentAbort?.abort();
+        const run = this.#currentRun;
+        if (run !== null)
+            await run; // settle first so state is deterministically idle
+        return ok("abort");
+    }
+    /** Discard the current thread and message mirror; start fresh. */
+    async newSession() {
+        this.#ensureUsable();
+        // Invalidate THIS run's queue-drain before aborting it: its finally must
+        // not start a queued message on the thread we are about to discard.
+        this.#sessionEpoch += 1;
+        this.#currentAbort?.abort();
+        const run = this.#currentRun;
+        if (run !== null)
+            await run;
+        this.#queue.length = 0;
+        this.#messages.length = 0;
+        this.#thread = this.#codex.startThread(this.#threadOptions);
+        this.#appliedModel = null; // a pending model still applies at the next run
+        return ok("new_session");
+    }
+    /** Lazy-surface parity: a real client is born live (see OmpAgentRpc.spawned). */
+    ensureStarted() {
+        return Promise.resolve();
+    }
+    /**
+     * The current Codex thread id, exactly as the SDK thread exposes it (null
+     * until the thread materializes one). The provider keeps the
+     * threadId ↔ Dash-session-id index from this (Task 7).
+     */
+    get threadId() {
+        return this.#thread.id;
+    }
+    /** Lazy-surface parity: a real client is born live (see OmpAgentRpc.spawned). */
+    get spawned() {
+        return true;
+    }
+    /** Release the shared-instance refcount and fail all future operations. */
+    close() {
+        if (this.#closed)
+            return;
+        this.#closed = true;
+        this.#sessionEpoch += 1; // a settled run must not drain the queue after close
+        this.#currentAbort?.abort();
+        release();
+        this.#fail(new Error("codex sdk client closed"));
+    }
+    // -------------------------------------------------------------------------
+    #ensureUsable() {
+        if (this.#failure !== null)
+            throw this.#failure;
+        if (this.#closed)
+            throw new Error("codex sdk client is closed");
+    }
+    /** Queue behind the in-flight turn, or start a run now. */
+    #enqueueOrRun(message) {
+        if (this.#inFlight) {
+            this.#queue.push(message);
+            return;
+        }
+        this.#startRun(message);
+    }
+    #startRun(message) {
+        this.#messages.push({ role: "user", content: [{ type: "text", text: message }] });
+        const run = this.#runTurn(message);
+        this.#currentRun = run;
+    }
+    /**
+     * One streamed turn: runStreamed on the thread, pump raw SDK events through
+     * projectThreadEvent, mirror the conversation, settle to agent_end. Mirrors
+     * the real SDK abort contract: an aborted turn just ENDS the stream (Task 1
+     * spike — no throw guarantee), so it settles like a normal end; thrown errors
+     * and the fatal top-level `error` event go to onFailure.
+     */
+    async #runTurn(message) {
+        // Session epoch: bumped by newSession()/close() so a run that started on
+        // the previous thread never drains the queue onto the new one.
+        const epoch = this.#sessionEpoch;
+        this.#inFlight = true;
+        const controller = new AbortController();
+        this.#currentAbort = controller;
+        try {
+            this.#applyPendingModel();
+            const streamed = await this.#thread.runStreamed(message, { signal: controller.signal });
+            for await (const raw of streamed.events) {
+                const record = asRecord(raw);
+                if (record !== null && record.type === "error") {
+                    // Fatal stream error: SDK contract surfaces it here, not as a throw.
+                    this.#fail(new Error(typeof record.message === "string" ? record.message : "codex stream error"));
+                    return;
+                }
+                const wire = projectThreadEvent(raw);
+                if (wire !== null) {
+                    const events = Array.isArray(wire) ? wire : [wire];
+                    for (const event of events) {
+                        this.#emit(event);
+                        this.#mirror(event);
+                    }
+                }
+            }
+            this.#emit({ type: "agent_end" });
+        }
+        catch (error) {
+            if (controller.signal.aborted) {
+                // Real SDK: the stream ends behind an abort — settle, stay idle.
+                this.#emit({ type: "agent_end" });
+            }
+            else {
+                this.#fail(error instanceof Error ? error : new Error(String(error)));
+            }
+        }
+        finally {
+            this.#inFlight = false;
+            this.#currentAbort = null;
+            this.#currentRun = null;
+            const next = this.#queue.shift();
+            if (next !== undefined && epoch === this.#sessionEpoch && this.#failure === null && !this.#closed) {
+                this.#startRun(next);
+            }
+        }
+    }
+    /** Rebuild the thread with the pending model when one is pending (next run). */
+    #applyPendingModel() {
+        if (this.#pendingModel === this.#appliedModel)
+            return;
+        const model = this.#pendingModel;
+        const options = model === null ? { ...this.#threadOptions } : { ...this.#threadOptions, model };
+        const currentId = this.#thread.id;
+        this.#thread =
+            currentId !== null ? this.#codex.resumeThread(currentId, options) : this.#codex.startThread(options);
+        this.#appliedModel = model;
+    }
+    /** Mirror wire events into the getMessages accumulator (best effort). */
+    #mirror(wire) {
+        if (wire.type === "message_end") {
+            const message = asRecord(wire.message);
+            if (message !== null && message.role === "assistant") {
+                // Reasoning-only messages are not mirrored (see getMessages doc).
+                const blocks = Array.isArray(message.content) ? message.content : [];
+                const reasoningOnly = blocks.length > 0 && blocks.every((block) => block.type === "thinking");
+                if (!reasoningOnly)
+                    this.#messages.push(message);
+            }
+            return;
+        }
+        if (wire.type === "tool_execution_end") {
+            const result = asRecord(wire.result);
+            this.#messages.push({
+                role: "toolResult",
+                toolCallId: wire.toolCallId,
+                content: Array.isArray(result?.content) ? result.content : [],
+                isError: wire.isError === true,
+            });
+            return;
+        }
+        if (wire.type === "turn_end") {
+            const data = asRecord(wire.data);
+            const usage = asRecord(data?.usage);
+            if (usage !== null)
+                this.#lastUsage = usage;
+        }
+    }
+    #emit(event) {
+        if (this.#closed)
+            return;
+        for (const listener of [...this.#listeners]) {
+            try {
+                listener(event);
+            }
+            catch (error) {
+                process.stderr.write(`codex sdk listener error: ${String(error)}\n`);
+            }
+        }
+    }
+    #fail(error) {
+        if (this.#failure !== null)
+            return;
+        this.#failure = error;
+        for (const listener of [...this.#failureListeners]) {
+            try {
+                listener(error);
+            }
+            catch (listenerError) {
+                process.stderr.write(`codex sdk failure listener error: ${String(listenerError)}\n`);
+            }
+        }
+    }
+}