super-dsh 0.1.5 → 0.1.6

package/agent-agy/dist/agent-preset-projection.d.ts

@@ -0,0 +1,31 @@
+/**
+ * The `agentPreset` session projection, owned by the adapter.
+ *
+ * Upstream registers this fold from the `dsh-agent-presets` package, which our
+ * patch disables (the Antigravity provider replaces preset composition
+ * wholesale). But the Web UI depends on the projection regardless: the preset
+ * hero chip renders only when `session.projectionValues.agentPreset` resolves
+ * (presetOf in ui-agent-preset/seat-store.ts), and the session-header label
+ * reads it too. Without a registrant the projection is absent for every
+ * adapter session and both surfaces stay blank — roster or no roster.
+ *
+ * Same fold as upstream (packages/preset/agent-presets/src/session.ts):
+ * initialized from the creation header, advanced by `agent-preset/selected`
+ * events, which this adapter synthesizes (`"agy"`) on every session it
+ * prepares. Registered under the provider's own fiber via
+ * `ctx.inject(['sessionProjections'])`, so the key lives exactly as long as
+ * the provider is mounted.
+ */
+import { z } from "zod";
+/** Current Session preset, initialized from its header and advanced by selection events. */
+export declare const agyAgentPresetProjection: {
+    key: "agentPreset";
+    stateSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+    init: (header: import("@deepseek-ai/dsh-session").SessionHeader) => string;
+    apply: (state: string | null, event: import("@deepseek-ai/dsh-session").SessionEvent) => string | null;
+    wire: {
+        viewSchema: z.ZodUnion<readonly [z.ZodString, z.ZodNull]>;
+        view: (state: string | null) => string | null;
+    };
+    stateVersion: number;
+};

package/agent-agy/dist/agent-preset-projection.js

@@ -0,0 +1,33 @@
+/**
+ * The `agentPreset` session projection, owned by the adapter.
+ *
+ * Upstream registers this fold from the `dsh-agent-presets` package, which our
+ * patch disables (the Antigravity provider replaces preset composition
+ * wholesale). But the Web UI depends on the projection regardless: the preset
+ * hero chip renders only when `session.projectionValues.agentPreset` resolves
+ * (presetOf in ui-agent-preset/seat-store.ts), and the session-header label
+ * reads it too. Without a registrant the projection is absent for every
+ * adapter session and both surfaces stay blank — roster or no roster.
+ *
+ * Same fold as upstream (packages/preset/agent-presets/src/session.ts):
+ * initialized from the creation header, advanced by `agent-preset/selected`
+ * events, which this adapter synthesizes (`"agy"`) on every session it
+ * prepares. Registered under the provider's own fiber via
+ * `ctx.inject(['sessionProjections'])`, so the key lives exactly as long as
+ * the provider is mounted.
+ */
+import { z } from "zod";
+const agentPresetSchema = z.union([z.string(), z.null()]);
+/** Current Session preset, initialized from its header and advanced by selection events. */
+export const agyAgentPresetProjection = {
+    key: "agentPreset",
+    stateSchema: agentPresetSchema,
+    // adapter-agy is single-preset: default every session to "agy" so the
+    // header chip resolves for scan-native (never-resumed) sessions too.
+    init: (header) => header.agentPreset ?? "agy",
+    apply: (state, event) => event.type === "agent-preset/selected"
+        ? event.data.agentPreset
+        : state,
+    wire: { viewSchema: agentPresetSchema, view: (state) => state },
+    stateVersion: 1,
+};

package/agent-claude/dist/agent-preset-projection.js

@@ -0,0 +1,30 @@
+/**
+ * The `agentPreset` session projection, owned by the adapter.
+ *
+ * Upstream registers this fold from the `dsh-agent-presets` package, which
+ * the bundle patch disables (the claude provider replaces preset composition
+ * wholesale). But the Web UI depends on the projection regardless: the
+ * preset hero chip renders only when `session.projectionValues.agentPreset`
+ * resolves, and the session-header label reads it too. Without a registrant
+ * the projection is absent for every adapter session and both surfaces stay
+ * blank — roster or no roster (the omp line's "no mode" bug, re-observed as
+ * the claude "degraded preset" finding).
+ *
+ * Same fold as upstream; adapter-claude is single-preset: default every
+ * session to "claude" so the header chip resolves for sessions whose log
+ * carries no `agent-preset/selected` event yet. Registered under the
+ * provider's own fiber via `ctx.inject(['sessionProjections'])`.
+ */
+import { z } from "zod";
+const agentPresetSchema = z.union([z.string(), z.null()]);
+/** Current Session preset, initialized from its header and advanced by selection events. */
+export const claudeAgentPresetProjection = {
+    key: "agentPreset",
+    stateSchema: agentPresetSchema,
+    init: (header) => header.agentPreset ?? "claude",
+    apply: (state, event) => event.type === "agent-preset/selected"
+        ? event.data.agentPreset
+        : state,
+    wire: { viewSchema: agentPresetSchema, view: (state) => state },
+    stateVersion: 1,
+};

package/agent-codex/dist/agent-preset-projection.js

@@ -0,0 +1,37 @@
+/**
+ * The `agentPreset` session projection, owned by the adapter.
+ *
+ * Upstream registers this fold from the `dsh-agent-presets` package, which our
+ * patch disables (the Codex provider replaces preset composition wholesale).
+ * But the Web UI depends on the projection regardless: the preset hero chip
+ * renders only when `session.projectionValues.agentPreset` resolves
+ * (`presetOf` in ui-agent-preset/seat-store.ts), and the session-header label
+ * reads it too. Without a registrant the projection is absent for every
+ * adapter session and both surfaces stay blank — roster or no roster (that
+ * was the "no mode" bug on the omp line: the roster service answered
+ * agentPresets/list 200, yet nothing drove the per-session projection the
+ * chip gates on).
+ *
+ * Same fold as upstream (packages/preset/agent-presets/src/session.ts):
+ * initialized from the creation header, advanced by `agent-preset/selected`
+ * events, which this adapter synthesizes (`"codex"`) on every session it
+ * prepares. Registered under the provider's own fiber via
+ * `ctx.inject(['sessionProjections'])`, so the key lives exactly as long as
+ * the provider is mounted.
+ */
+import { z } from "zod";
+const agentPresetSchema = z.union([z.string(), z.null()]);
+/** Current Session preset, initialized from its header and advanced by selection events. */
+export const codexAgentPresetProjection = {
+    key: "agentPreset",
+    stateSchema: agentPresetSchema,
+    // adapter-codex is single-preset: default every session to "codex" so the
+    // header chip resolves for scan-native (never-resumed) sessions too,
+    // instead of only those whose log carries an `agent-preset/selected` event.
+    init: (header) => header.agentPreset ?? "codex",
+    apply: (state, event) => event.type === "agent-preset/selected"
+        ? event.data.agentPreset
+        : state,
+    wire: { viewSchema: agentPresetSchema, view: (state) => state },
+    stateVersion: 1,
+};

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/spike.js

@@ -0,0 +1,46 @@
+/**
+ * AW-E Task 1 spike (P0 gate): prove `@openai/codex-sdk@0.154.0` drives a real
+ * turn against the local cc-switch provider (glm-5.2) under an ISOLATED
+ * CODEX_HOME, and capture the raw ThreadEvent chain for the Task 2 projection
+ * fixtures. The SDK spawns its own exact-pinned codex binary — the 0.153.4
+ * CLI on PATH is never consulted (version-mix safety, 2026-09-10 fact).
+ */
+import { Codex } from "@openai/codex-sdk";
+function lastOfType(events, type) {
+    for (let i = events.length - 1; i >= 0; i -= 1) {
+        const evt = events[i];
+        if (evt.type === type)
+            return evt;
+    }
+    return undefined;
+}
+/** Run one real streamed turn and collect the full event chain. */
+export async function runSpike(opts) {
+    const codex = new Codex({
+        // env REPLACES process.env (SDK contract) — carry it forward + redirect home.
+        env: { ...process.env, CODEX_HOME: opts.codexHome },
+    });
+    const thread = codex.startThread({
+        workingDirectory: opts.cwd,
+        skipGitRepoCheck: true,
+        approvalPolicy: "never",
+        sandboxMode: "read-only",
+    });
+    const events = [];
+    const streamed = await thread.runStreamed(opts.prompt ?? "Reply with exactly: ok");
+    for await (const evt of streamed.events) {
+        events.push(evt);
+        if (evt.type === "turn.failed") {
+            const error = evt.error;
+            throw new Error(`spike turn failed: ${error?.message ?? "unknown"}`);
+        }
+    }
+    const completed = lastOfType(events, "turn.completed");
+    const message = lastOfType(events, "item.completed");
+    return {
+        threadId: thread.id ?? "",
+        finalResponse: message?.item?.text ?? "",
+        usage: completed?.usage ?? null,
+        events,
+    };
+}

package/agent-hermes/dist/agent-preset-projection.js

@@ -0,0 +1,34 @@
+/**
+ * The `agentPreset` session projection, owned by the adapter.
+ *
+ * Upstream registers this fold from the `dsh-agent-presets` package, which our
+ * patch disables (the Hermes provider replaces preset composition wholesale).
+ * But the Web UI depends on the projection regardless: the preset hero chip
+ * renders only when `session.projectionValues.agentPreset` resolves
+ * (`presetOf` in ui-agent-preset/seat-store.ts), and the session-header label
+ * reads it too. Without a registrant the projection is absent for every
+ * adapter session and both surfaces stay blank — roster or no roster.
+ *
+ * Same fold as upstream (packages/preset/agent-presets/src/session.ts):
+ * initialized from the creation header, advanced by `agent-preset/selected`
+ * events, which this adapter synthesizes (`"hermes"`) on every session it
+ * prepares. Registered under the provider's own fiber via
+ * `ctx.inject(['sessionProjections'])`, so the key lives exactly as long as
+ * the provider is mounted.
+ */
+import { z } from "zod";
+const agentPresetSchema = z.union([z.string(), z.null()]);
+/** Current Session preset, initialized from its header and advanced by selection events. */
+export const hermesAgentPresetProjection = {
+    key: "agentPreset",
+    stateSchema: agentPresetSchema,
+    // adapter-hermes is single-preset: default every session to "hermes" so the
+    // header chip resolves for scan-native (never-resumed) sessions too,
+    // instead of only those whose log carries an `agent-preset/selected` event.
+    init: (header) => header.agentPreset ?? "hermes",
+    apply: (state, event) => event.type === "agent-preset/selected"
+        ? event.data.agentPreset
+        : state,
+    wire: { viewSchema: agentPresetSchema, view: (state) => state },
+    stateVersion: 1,
+};

package/agent-omp/dist/agent-preset-projection.js

@@ -0,0 +1,36 @@
+/**
+ * The `agentPreset` session projection, owned by the bridge.
+ *
+ * Upstream registers this fold from the `dsh-agent-presets` package, which our
+ * patch disables (OMP replaces preset composition wholesale). But the Web UI
+ * depends on the projection regardless: the preset hero chip renders only when
+ * `session.projectionValues.agentPreset` resolves (`presetOf` in
+ * ui-agent-preset/seat-store.ts), and the session-header label reads it too.
+ * Without a registrant the projection is absent for every bridge session and
+ * both surfaces stay blank — roster or no roster (that was the "no omp mode"
+ * bug: the roster service answered `agentPresets/list` 200, yet nothing drove
+ * the per-session projection the chip gates on).
+ *
+ * Same fold as upstream (packages/preset/agent-presets/src/session.ts):
+ * initialized from the creation header, advanced by `agent-preset/selected`
+ * events, which this bridge already synthesizes (`"omp"`) on every session it
+ * prepares. Registered under the provider's own fiber via
+ * `ctx.inject(['sessionProjections'])`, so the key lives exactly as long as
+ * the provider is mounted.
+ */
+import { z } from "zod";
+const agentPresetSchema = z.union([z.string(), z.null()]);
+/** Current Session preset, initialized from its header and advanced by selection events. */
+export const ompAgentPresetProjection = {
+    key: "agentPreset",
+    stateSchema: agentPresetSchema,
+    // omp-web is single-preset: default every session to "omp" so the header
+    // chip resolves for scan-native (never-resumed) sessions too, instead of
+    // only those whose log carries an `agent-preset/selected` event.
+    init: (header) => header.agentPreset ?? "omp",
+    apply: (state, event) => event.type === "agent-preset/selected"
+        ? event.data.agentPreset
+        : state,
+    wire: { viewSchema: agentPresetSchema, view: (state) => state },
+    stateVersion: 1,
+};

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

@@ -0,0 +1,86 @@
+/**
+ * OMP runtime app home bootstrap — idempotently creates the runtime's OMP home
+ * (`<DSH_HOME>/agents/omp/.omp`) and seeds it with the OMP config (config.yml /
+ * mcp.json / models.yml / .env) copied once from `~/.omp/agent`. Fail-soft: any
+ * error is reported and the host boot continues — the app home is derived state,
+ * never a boot gate.
+ */
+import { copyFileSync, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { join } from "node:path";
+import { OMP_HOME, OMP_NATIVE_HOME } from "./knobs.js";
+/** Config files seeded into the app home from the native OMP agent dir. */
+export const APP_HOME_CONFIG_FILES = ["config.yml", "mcp.json", "models.yml", ".env"];
+/**
+ * Comma/space separated `mcpServers` names the launcher refuses to inherit
+ * (`AW_OMP_MCP_EXCLUDE=zai-vision`). Deployment policy lives in the launcher, so
+ * this module never names a vendor.
+ */
+export const OMP_MCP_EXCLUDE_ENV = "AW_OMP_MCP_EXCLUDE";
+/** Native OMP agent dir (`<OMP_NATIVE_HOME>/agent`) — the copy source. */
+function defaultSourceAgentDir() {
+    return join(OMP_NATIVE_HOME, "agent");
+}
+/** Parse {@link OMP_MCP_EXCLUDE_ENV} into server names. */
+function excludedMcpServers() {
+    return (process.env[OMP_MCP_EXCLUDE_ENV] ?? "")
+        .split(/[\s,]+/)
+        .map((name) => name.trim())
+        .filter((name) => name !== "");
+}
+/**
+ * Drop excluded stdio MCP servers from the app home's `mcp.json`.
+ *
+ * Why this exists: the native `~/.omp/agent/mcp.json` carries a `npx -y
+ * @z_ai/mcp-server@latest` stdio server, and every spawned MCP child is a real
+ * process (a live npx install ~200 MB) that this runtime does not need. Seeding
+ * copies the file verbatim, so the filter runs after seeding and is idempotent:
+ * it only rewrites the document when a listed server was actually present.
+ */
+function pruneMcpServers(appHome, names, warn) {
+    if (names.length === 0)
+        return;
+    const file = join(appHome, "mcp.json");
+    if (!existsSync(file))
+        return;
+    const parsed = JSON.parse(readFileSync(file, "utf8"));
+    const servers = parsed.mcpServers;
+    if (servers === undefined || typeof servers !== "object" || servers === null)
+        return;
+    const removed = names.filter((name) => Object.hasOwn(servers, name));
+    if (removed.length === 0)
+        return;
+    for (const name of removed)
+        delete servers[name];
+    writeFileSync(file, `${JSON.stringify(parsed, null, 2)}\n`);
+    warn?.(`omp-provider: pruned MCP servers from ${file}: ${removed.join(", ")}`);
+}
+/**
+ * Ensure the app home exists and is seeded. Never overwrites an existing file
+ * (an already-provisioned app home wins); a missing source file is skipped.
+ * Returns the resolved app home path.
+ */
+export function ensureOmpAppHome(options = {}) {
+    const appHome = options.appHome ?? OMP_HOME;
+    const source = options.sourceAgentDir ?? defaultSourceAgentDir();
+    const files = options.files ?? APP_HOME_CONFIG_FILES;
+    try {
+        mkdirSync(appHome, { recursive: true });
+        for (const name of files) {
+            const dest = join(appHome, name);
+            if (existsSync(dest))
+                continue;
+            const src = join(source, name);
+            if (!existsSync(src))
+                continue;
+            copyFileSync(src, dest);
+        }
+        // Deployment policy, data-side: a seeded/kept `mcp.json` may still carry
+        // heavy stdio servers this runtime must not inherit (a vendor name does not
+        // belong in adapter code, so the launcher names them here).
+        pruneMcpServers(appHome, options.excludeMcpServers ?? excludedMcpServers(), options.warn);
+    }
+    catch (error) {
+        options.warn?.(`omp-provider: app-home bootstrap failed (fail-soft): ${String(error)}`);
+    }
+    return appHome;
+}

package/agent-pi/dist/agent-preset-projection.js

@@ -0,0 +1,29 @@
+/**
+ * The `agentPreset` session projection, owned by the adapter.
+ *
+ * Upstream registers this fold from the `dsh-agent-presets` package, which our
+ * patch disables (the pi provider replaces preset composition wholesale).
+ * But the Web UI depends on the projection regardless: the preset hero chip
+ * renders only when `session.projectionValues.agentPreset` resolves, and the
+ * session-header label reads it too. Without a registrant the projection is
+ * absent for every adapter session and both surfaces stay blank (the omp
+ * line's "no mode" bug).
+ *
+ * Same fold as upstream; adapter-pi is single-preset: default every session
+ * to "pi" so the header chip resolves for scan-native (never-resumed)
+ * sessions too. Registered under the provider's own fiber via
+ * `ctx.inject(['sessionProjections'])`.
+ */
+import { z } from "zod";
+const agentPresetSchema = z.union([z.string(), z.null()]);
+/** Current Session preset, initialized from its header and advanced by selection events. */
+export const piAgentPresetProjection = {
+    key: "agentPreset",
+    stateSchema: agentPresetSchema,
+    init: (header) => header.agentPreset ?? "pi",
+    apply: (state, event) => event.type === "agent-preset/selected"
+        ? event.data.agentPreset
+        : state,
+    wire: { viewSchema: agentPresetSchema, view: (state) => state },
+    stateVersion: 1,
+};