super-dsh 0.1.10 → 0.1.11

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

@@ -8,6 +8,15 @@
  * methods exist at all), drives the bridge lazily per session, and fans every
  * message out through `projectClaudeEvent` (claude-events.ts).
  *
+ * ## The SDK is runtime-self-fetched, not imported
+ *
+ * The SDK is not a static dependency of this package: the default factory
+ * resolves it at the first real prompt via `loadClaudeQuery(worldHome)`
+ * (sdk-runtime.ts), which fetches the pinned tree into the agent world's
+ * home. `ClaudeFactory` stays SYNCHRONOUS — the await lives in factory
+ * RESOLUTION, never between query construction and the `this.query`
+ * assignment (see `ensureStarted`).
+ *
  * ## The two hard deviations from the codex precedent
  *
  * 1. **No shared singleton.** `agent-codex` multiplexes all clients through one
@@ -54,38 +63,31 @@
  *   every push is queued in order and there is no separate follow-up channel.
  *   `steer` differs by pushing with `priority: "now"`.
  */
-import { existsSync } from "node:fs";
-import { homedir } from "node:os";
-import { join } from "node:path";
-import { query as officialQuery } from "@anthropic-ai/claude-agent-sdk";
+import { loadClaudeQuery, resolveClaudeBinary } from "./sdk-runtime.js";
 import { InputQueue } from "./input-queue.js";
 import { projectClaudeEvent } from "./claude-events.js";
-/** Host Claude Code binary driven through the SDK bridge (spec ruling R5).
- * PATH-resolved like any host CLI: $CLAUDE_EXECUTABLE wins, else a bare
- * "claude" the SDK spawns through PATH. No machine-specific path ships. */
-export const DEFAULT_CLAUDE_EXECUTABLE = "claude";
-const defaultFactory = (o) => officialQuery({
-    prompt: o.prompt,
-    options: o.options,
-});
-const defaultExecutableResolver = () => process.env.CLAUDE_EXECUTABLE ?? resolveClaudeExecutable();
-/** PATH first, then the common native-installer locations (a service unit
- * PATH may not include ~/.local/bin — dev3 2026-09-22: "native binary not
- * found at claude" mid-session). */
-function resolveClaudeExecutable() {
-    for (const dir of (process.env.PATH ?? "").split(":").filter(Boolean)) {
-        if (existsSync(join(dir, "claude")))
-            return DEFAULT_CLAUDE_EXECUTABLE;
-    }
-    for (const candidate of [join(homedir(), ".local/bin/claude"), "/usr/local/bin/claude"]) {
-        if (existsSync(candidate))
-            return candidate;
-    }
-    return DEFAULT_CLAUDE_EXECUTABLE;
-}
-let factory = defaultFactory;
+import { NATIVE_LAUNCH } from "./claude-launch.js";
+/** The default executable resolution: Task 1's `resolveClaudeBinary` —
+ * `$CLAUDE_EXECUTABLE` (only while it exists) > `claude` on PATH >
+ * `~/.local/bin/claude` > `/usr/local/bin/claude`. `undefined` means "no
+ * local binary": `pathToClaudeCodeExecutable` is left unset and the SDK's
+ * bundled platform payload is the CLI (bundled-payload mode). */
+const defaultExecutableResolver = () => resolveClaudeBinary();
+let factory; // test injection only
 let executableResolver = defaultExecutableResolver;
 let refcount = 0;
+/** The factory to construct queries with: a test-injected one wins (the sync
+ * seam); otherwise the SDK is self-fetched into `worldHome`'s durable runtime
+ * on first use (sdk-runtime.ts). */
+async function resolveFactory(worldHome) {
+    if (factory)
+        return factory;
+    if (worldHome === undefined) {
+        throw new Error("agent-claude: client needs worldHome to fetch its SDK runtime (the provider passes dshHomePath)");
+    }
+    const sdkQuery = await loadClaudeQuery(worldHome);
+    return (o) => sdkQuery({ prompt: o.prompt, options: o.options });
+}
 /** Replace the SDK entry point (tests inject a fake query). */
 export function setClaudeFactory(next) {
     factory = next;
@@ -101,7 +103,7 @@ export function claudeClientRefCount() {
 /** Restore module-level seams and refcount (test isolation only). */
 export function resetClaudeClientState() {
     refcount = 0;
-    factory = defaultFactory;
+    factory = undefined;
     executableResolver = defaultExecutableResolver;
 }
 /**
@@ -114,13 +116,15 @@ export function resetClaudeClientState() {
  * is the caller's to trace; the boot catalog stays as-is.
  */
 export async function probeClaudeModels(config = {}) {
+    const queryFactory = await resolveFactory(config.worldHome);
+    const executable = executableResolver();
     const queue = new InputQueue();
-    const query = factory({
+    const query = queryFactory({
         prompt: queue,
         options: {
             cwd: config.cwd ?? process.cwd(),
             env: { ...process.env },
-            pathToClaudeCodeExecutable: executableResolver(),
+            ...(executable !== undefined ? { pathToClaudeCodeExecutable: executable } : {}),
             persistSession: false,
         },
     });
@@ -145,10 +149,13 @@ export async function probeClaudeModels(config = {}) {
 }
 export class ClaudeSdkClient {
     cwdPath;
+    worldHome;
     claudeSessionId;
     resumeSessionId;
     canUseTool;
     allowDangerouslySkipPermissions;
+    /** The provider-pinning launch this client will spawn under (NATIVE_LAUNCH until `setLaunch`). */
+    launch;
     /** True while a user turn is in flight (set on push, cleared on `turn_end`/`agent_end`). */
     turnActive = false;
     queue;
@@ -164,10 +171,12 @@ export class ClaudeSdkClient {
             throw new Error("agent-claude: claudeSessionId and resumeSessionId are mutually exclusive");
         }
         this.cwdPath = config.cwd ?? process.cwd();
+        this.worldHome = config.worldHome;
         this.claudeSessionId = config.claudeSessionId;
         this.resumeSessionId = config.resumeSessionId;
         this.canUseTool = config.canUseTool;
         this.allowDangerouslySkipPermissions = config.allowDangerouslySkipPermissions;
+        this.launch = config.launch ?? NATIVE_LAUNCH;
         refcount += 1;
     }
     /**
@@ -186,6 +195,21 @@ export class ClaudeSdkClient {
     get threadId() {
         return this.threadIdValue;
     }
+    /** The provider id this client was last told to spawn under (constructor fact; `null` = native). */
+    get appliedProvider() {
+        return this.launch.providerId;
+    }
+    /**
+     * Pin the launch this client will spawn under. Only legal before the query
+     * exists: once the CLI subprocess is up, a provider move is a different child
+     * (the agent swaps the whole client at a turn boundary — see `#reattach`).
+     */
+    setLaunch(launch) {
+        if (this.query !== undefined) {
+            throw new Error("agent-claude: setLaunch after spawn is not allowed (a provider move swaps the client)");
+        }
+        this.launch = launch;
+    }
     /** The client's own running/streaming attestation (idle-TTL revalidation gate). */
     async getState() {
         return { isStreaming: this.turnActive };
@@ -221,22 +245,27 @@ export class ClaudeSdkClient {
         };
     }
     /**
-     * Lazily construct the query (zero-IO until this runs). Everything up to the
-     * `this.query = query` assignment is synchronous, so concurrent first prompts
-     * can never build two queries: the first caller assigns `this.query` before
-     * any `await` yields control. This single-query invariant therefore depends
-     * on the `ClaudeFactory` contract staying synchronous (it must return the
-     * `Query` without awaiting). The reader loop is started fire-and-forget before
-     * any pending control call is replayed, so a throwing control can never leave
-     * the CLI undrained.
+     * Lazily construct the query (zero-IO until this runs). The factory is
+     * resolved first — an await (a test-injected seam, or the world-home SDK
+     * self-fetch) — and a caller that loses the race during that await reuses
+     * the winner's query at the re-check. From the construct line through the
+     * `this.query = query` assignment everything is synchronous (zero awaits),
+     * so concurrent first prompts can never build two queries. The single-query
+     * invariant therefore still depends on the `ClaudeFactory` contract staying
+     * synchronous (it must return the `Query` without awaiting). The reader loop
+     * is started fire-and-forget before any pending control call is replayed, so
+     * a throwing control can never leave the CLI undrained.
      */
     async ensureStarted() {
         if (this.query !== undefined)
             return;
+        const f = await resolveFactory(this.worldHome); // await BEFORE the sync section
+        if (this.query !== undefined)
+            return; // lost the race to a concurrent first prompt — reuse its query
         const queue = new InputQueue();
-        const query = factory({ prompt: queue, options: this.buildOptions() });
+        const query = f({ prompt: queue, options: this.buildOptions() });
         this.queue = queue;
-        this.query = query;
+        this.query = query; // sync section: zero awaits before this assignment (invariant)
         void this.runReader(query);
         const controls = this.pendingControls;
         this.pendingControls = [];
@@ -303,11 +332,23 @@ export class ClaudeSdkClient {
     }
     // --- internals ------------------------------------------------------------
     buildOptions() {
+        const launchExecutable = this.launch.pathToClaudeCodeExecutable;
+        const executable = launchExecutable !== undefined && launchExecutable !== "" ? launchExecutable : executableResolver();
         return {
             cwd: this.cwdPath,
-            env: { ...process.env },
-            pathToClaudeCodeExecutable: executableResolver(),
+            // The launch env holds ADDITIONS only; spreading process.env first keeps
+            // PATH/HOME and the user's own key alive (NATIVE_LAUNCH carries an empty
+            // env, so the native shape is exactly `{ ...process.env }`).
+            env: { ...process.env, ...this.launch.env },
+            // The `--settings` command-line tier (a JSON string) outranks the user's
+            // native settings.json env, so a provider-pinned launch rides it here
+            // (2026-10-04 F-B: without it the native env pins the endpoint).
+            ...(this.launch.settings !== undefined ? { settings: this.launch.settings } : {}),
+            // undefined (no local binary) leaves the key unset — bundled-payload
+            // mode lets the SDK spawn its own platform payload as the CLI.
+            ...(executable !== undefined ? { pathToClaudeCodeExecutable: executable } : {}),
             persistSession: true,
+            ...(this.launch.model !== undefined ? { model: this.launch.model } : {}),
             ...(this.claudeSessionId !== undefined ? { sessionId: this.claudeSessionId } : {}),
             ...(this.resumeSessionId !== undefined ? { resume: this.resumeSessionId } : {}),
             ...(this.canUseTool !== undefined ? { canUseTool: this.canUseTool } : {}),

package/agent-claude/dist/claude-launch.js

@@ -0,0 +1,101 @@
+/**
+ * claude-launch.ts — how a provider reaches the Claude Code CLI
+ * (2026-10-04 multi-provider rework).
+ *
+ * Claude Code is a single-provider harness: its own `settings.json` env block
+ * names exactly one `ANTHROPIC_BASE_URL` with one key, so the LIST of
+ * configured providers lives in `claude-providers.ts` instead. This module is
+ * the other end of that store: given the route the next turn will run (DSH's
+ * own per-session model selection, read by `claude-route.ts`), the resolved
+ * provider entry, and the resolved host binary, it produces the slice Task 9
+ * merges into the SDK's `Options`.
+ *
+ * The child's environment is the ONE channel a provider's variables enter the
+ * process through (spec §2.2) — AND, for a provider-pinned launch, the same env
+ * is re-carried as a `--settings`-tier JSON string so the command-line tier
+ * outranks the user's native `~/.claude/settings.json` env (2026-10-04 F-B).
+ * Concretely, the env keys are:
+ *
+ *   - `ANTHROPIC_BASE_URL` — always, from the entry (validation guarantees a
+ *     non-empty endpoint; an entry without one is not an entry).
+ *   - `ANTHROPIC_AUTH_TOKEN` for `authToken` (Bearer), `ANTHROPIC_API_KEY` for
+ *     `apiKey` (x-api-key) — exactly one, chosen by the entry's auth KIND, with
+ *     the stored value verbatim. The kind names the channel, so the variable is
+ *     present even when the value is empty ("keyed outside Super D"): the CLI
+ *     reads both names with `.trim() || undefined` (measured in
+ *     `@anthropic-ai/claude-agent-sdk` 2.1.263), so an empty value is unset
+ *     rather than a fabricated secret.
+ *   - `ANTHROPIC_MODEL` — the RAW route model id (`glm-5.2`), never the
+ *     selector's composite key (`glm/glm-5.2`); the composite is a DSH catalog
+ *     id and has no meaning on the wire.
+ *   - `ANTHROPIC_DEFAULT_{SONNET,OPUS,HAIKU}_MODEL` — ONLY for aliases the
+ *     entry actually declares, and never an empty-string one: an alias the user
+ *     did not write must not be invented, or the child silently answers on a
+ *     model they never chose.
+ *
+ * The returned env holds ADDITIONS only. The caller composes the child
+ * environment as `{ ...process.env, ...launch.env }` — the spread AFTER
+ * `process.env` is the contract, and it is why this function never reads or
+ * mutates `process.env` itself: it is a pure declaration, and the caller's
+ * precedence is what makes it effective. `NATIVE_LAUNCH` is the same
+ * declaration with nothing in it: `providerId: null` and an empty env, for a
+ * route no provider entry answers (a legacy bare-id selection, the native
+ * settings-only shape).
+ *
+ * The same reasoning makes `pathToClaudeCodeExecutable` optional and
+ * conditional: it is set only when a host binary was actually resolved, so an
+ * unresolved binary omits the key entirely and lets the SDK fall back to its
+ * bundled payload (spec §2.1) instead of spawning an empty path.
+ *
+ * @module agent-claude/claude-launch
+ */
+/** The launch for "no provider injection at all" (the native settings apply). */
+export const NATIVE_LAUNCH = { providerId: null, env: {} };
+/** The variable each auth kind authenticates through. */
+const AUTH_ENV = {
+    authToken: "ANTHROPIC_AUTH_TOKEN",
+    apiKey: "ANTHROPIC_API_KEY",
+};
+/** The alias slots an entry may declare, in catalog order. */
+const ALIAS_ENV = [
+    ["sonnet", "ANTHROPIC_DEFAULT_SONNET_MODEL"],
+    ["opus", "ANTHROPIC_DEFAULT_OPUS_MODEL"],
+    ["haiku", "ANTHROPIC_DEFAULT_HAIKU_MODEL"],
+];
+/**
+ * Turn one resolved provider into the SDK `Options` slice for one route.
+ *
+ * Pure: reads no file, no env, no clock, and spawns nothing. The provider id
+ * comes from the ENTRY (the caller resolves the entry BY `route.provider`, so
+ * the label and the injected data stay one fact); the model comes from the
+ * ROUTE, because that is what the session selected.
+ *
+ * @param route - the route the next turn runs (raw model half).
+ * @param entry - the provider entry that route resolved to.
+ * @param hostBinary - the resolved Claude Code binary, or `undefined` to let
+ *   the SDK use its bundled payload.
+ * @returns the env additions, the wire model, and the optional binary path.
+ */
+export function claudeLaunchFor(route, entry, hostBinary) {
+    const env = {
+        ANTHROPIC_BASE_URL: entry.baseUrl,
+        [AUTH_ENV[entry.auth.kind]]: entry.auth.value,
+        ANTHROPIC_MODEL: route.model,
+    };
+    // Declared aliases only: `undefined` means the entry never named that slot,
+    // and "" is not a model id — emitting either would invent a choice.
+    for (const [slot, name] of ALIAS_ENV) {
+        const value = entry.aliases?.[slot];
+        if (value !== undefined && value !== "")
+            env[name] = value;
+    }
+    return {
+        providerId: entry.id,
+        env,
+        settings: JSON.stringify({ env }),
+        model: route.model,
+        // Spread, not `pathToClaudeCodeExecutable: hostBinary`: an absent key must
+        // not exist at all, or it would ride a spread into Options as `undefined`.
+        ...(hostBinary !== undefined && hostBinary !== "" ? { pathToClaudeCodeExecutable: hostBinary } : {}),
+    };
+}

package/agent-claude/dist/claude-native-config.js

@@ -0,0 +1,169 @@
+/**
+ * claude-native-config.ts — reading the foreign runtime's own settings, the
+ * read-only half of the multi-provider split (2026-10-04).
+ *
+ * Claude Code is a single-provider harness: its `settings.json` `env` block
+ * names exactly ONE `ANTHROPIC_BASE_URL` with at most one key variable, so the
+ * LIST of providers a user has configured has nowhere to live natively and
+ * lives in the adapter's store instead (`claude-providers.ts`). This module is
+ * the other half of that split — the sole authority on what the user's own
+ * file actually says.
+ *
+ * The direction is one-way: `settings.json` is a SOURCE. Nothing here writes
+ * it — this module has no write path at all — and cc-switch can still own the
+ * file; the sync in `claude-provider-gateway.ts` picks up whatever it leaves
+ * there. The `.bak-*` manual-switch layers are never folded (they are not the
+ * live file). Compare `agent-codex/src/codex-native-config.ts`, the structural
+ * port source; claude needs none of codex's per-provider catalog machinery
+ * because a settings env block IS its whole catalog.
+ *
+ * Two reads live here:
+ *
+ *  - `readNativeProviders` — the `env` block as a provider table, 0 or 1
+ *    entries. An env block without `ANTHROPIC_BASE_URL` declares no provider:
+ *    the store's identity IS the endpoint URL, and with nothing to dedupe by
+ *    there is no entry to make.
+ *  - `readNativeModel` — `env.ANTHROPIC_MODEL`, the model the user's own CLI
+ *    runs. Independent of the provider read: a native setup on the default
+ *    Anthropic endpoint carries no base URL but a perfectly meaningful model.
+ *
+ * Auth is classified by the VARIABLE NAME, and an explicitly-empty variable
+ * reads as unset — the same env semantics the codex port applies to an empty
+ * `env_key` — so `ANTHROPIC_AUTH_TOKEN` (Bearer) wins only when it carries a
+ * value, and a base URL whose env names no usable key variable folds as the
+ * real "keyed outside Super D" state `{kind:"apiKey", value:""}` rather than
+ * being rejected.
+ *
+ * Non-string env values (a hand-edited file may carry numbers or booleans)
+ * are read in their string forms — everything downstream of an env block is a
+ * string, process-env semantics — and shapes with no string form worth
+ * honoring (objects, arrays, null) are skipped.
+ *
+ * Every read is fail-soft: an absent file, an unreadable file, unparsable
+ * JSON, or a wrong shape all degrade to "nothing declared" and never throw.
+ *
+ * @module agent-claude/claude-native-config
+ */
+import { existsSync, readFileSync } from "node:fs";
+import { join } from "node:path";
+// The home resolver stays canonical in claude-home.ts (it has its own tests
+// and its own callers); this re-export is the non-duplicating way to give the
+// native-config consumers the one-face import the plan's Interfaces pin.
+export { resolveClaudeHome } from "./claude-home.js";
+const SETTINGS_FILE = "settings.json";
+/** Read a file, or `undefined` when it is absent or unreadable. */
+function readIfExists(path) {
+    if (!existsSync(path))
+        return undefined;
+    try {
+        return readFileSync(path, "utf8");
+    }
+    catch {
+        return undefined;
+    }
+}
+/**
+ * One env value as the process would see it. Strings pass verbatim; numbers
+ * and booleans coerce to their string forms; objects, arrays, null, and
+ * empty/whitespace strings are unusable (an empty credential is not a
+ * credential — see the module header).
+ */
+function envString(value) {
+    if (typeof value === "string")
+        return value.trim() === "" ? undefined : value;
+    if (typeof value === "number" && Number.isFinite(value))
+        return String(value);
+    if (typeof value === "boolean")
+        return value ? "true" : "false";
+    return undefined;
+}
+/** The settings.json `env` block, or `undefined` when anything above it fails. */
+function readEnvBlock(claudeHome) {
+    const text = readIfExists(join(claudeHome, SETTINGS_FILE));
+    if (text === undefined)
+        return undefined;
+    let parsed;
+    try {
+        parsed = JSON.parse(text);
+    }
+    catch {
+        return undefined;
+    }
+    if (parsed === null || Array.isArray(parsed) || typeof parsed !== "object")
+        return undefined;
+    const env = parsed["env"];
+    if (env === null || Array.isArray(env) || typeof env !== "object")
+        return undefined;
+    return env;
+}
+/**
+ * Parse the native settings env into the sync's source tables.
+ *
+ * The output is 0 or 1 entries, in the only order there is. `models` is the
+ * DEDUPLICATED sequence of the alias values (sonnet, opus, haiku) — the only
+ * model ids a settings env reveals; `ANTHROPIC_MODEL` deliberately does not
+ * become one (it is `readNativeModel`'s own view, and folding it would invent
+ * a catalog entry the aliases never named).
+ *
+ * @param claudeHome - the NATIVE claude home (`~/.claude`).
+ * @returns the declared provider table, or `[]` when the env declares none.
+ */
+export function readNativeProviders(claudeHome) {
+    const env = readEnvBlock(claudeHome);
+    if (env === undefined)
+        return [];
+    const baseUrl = envString(env["ANTHROPIC_BASE_URL"]);
+    // No endpoint is not a provider: there is nothing to dedupe the entry by in
+    // a list whose identity IS the endpoint URL.
+    if (baseUrl === undefined)
+        return [];
+    // Key-variable precedence: AUTH_TOKEN (Bearer) over API_KEY (x-api-key),
+    // an empty variable counting as unset, and no usable variable at all
+    // folding as the keyed-outside-Super-D state rather than an error.
+    const token = envString(env["ANTHROPIC_AUTH_TOKEN"]);
+    const key = envString(env["ANTHROPIC_API_KEY"]);
+    const auth = token !== undefined
+        ? { kind: "authToken", value: token }
+        : key !== undefined
+            ? { kind: "apiKey", value: key }
+            : { kind: "apiKey", value: "" };
+    const sonnet = envString(env["ANTHROPIC_DEFAULT_SONNET_MODEL"]);
+    const opus = envString(env["ANTHROPIC_DEFAULT_OPUS_MODEL"]);
+    const haiku = envString(env["ANTHROPIC_DEFAULT_HAIKU_MODEL"]);
+    const models = [];
+    const seen = new Set();
+    for (const id of [sonnet, opus, haiku]) {
+        if (id === undefined || seen.has(id))
+            continue;
+        seen.add(id);
+        models.push({ id });
+    }
+    const table = {
+        baseUrl,
+        auth,
+        models,
+        ...(sonnet === undefined && opus === undefined && haiku === undefined ? {} : {
+            aliases: {
+                ...(sonnet === undefined ? {} : { sonnet }),
+                ...(opus === undefined ? {} : { opus }),
+                ...(haiku === undefined ? {} : { haiku }),
+            },
+        }),
+    };
+    return [table];
+}
+/**
+ * The model the user's own settings env puts in force (`env.ANTHROPIC_MODEL`).
+ *
+ * Read independently of the provider tables: it is the panel's passive "your
+ * own Claude runs this" line, meaningful even when no endpoint is declared.
+ *
+ * @param claudeHome - the NATIVE claude home (`~/.claude`).
+ * @returns the model id, or `undefined` when the env names none.
+ */
+export function readNativeModel(claudeHome) {
+    const env = readEnvBlock(claudeHome);
+    if (env === undefined)
+        return undefined;
+    return envString(env["ANTHROPIC_MODEL"]);
+}