super-dsh 0.1.9 → 0.1.10-e

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"]);
+}

package/agent-claude/dist/claude-provider-gateway.js

@@ -0,0 +1,340 @@
+/**
+ * claude-provider-gateway.ts — the adapter-owned Remote behind the Hub's Claude
+ * settings panel (2026-10-04 multi-provider ruling).
+ *
+ * Why a Remote and not a hub route: the provider list is ADAPTER config
+ * (dev-rules §12), so the adapter owns it and the hub only forwards.
+ * `TypertRemoteService` + `@Remote` is the whole mechanism — standard (TC39)
+ * method decorators recorded on the class prototype, read back at dispatch time
+ * by the gateway's source-claim scan. No codegen, no compiler-injected metadata,
+ * which is why a plain `tsc` adapter build can ship one.
+ *
+ * Wire contract (`superd-hub/src/client/runtime-settings-api.ts` builds each
+ * envelope; the hub carrier forwards `envelope.method` verbatim):
+ *
+ *   request   POST /hub/api?agent=claude
+ *             { type:'client-request', rpcId, method:'claudeProviders/<op>',
+ *               payload: { args: { request?: … } } }
+ *   response  { type:'server-response', rpcId, result:{ ok:true, value:<view> } }
+ *
+ * There is no `select`: which provider a SESSION runs on is DSH's own
+ * per-session `model/selection`, chosen from the harness's model selector. This
+ * panel is a list editor — add, edit, remove — plus the reconcile with the
+ * user's `settings.json` that {@link syncFromNative} performs.
+ *
+ * The class is a delegation shell on purpose: every operation is a plain
+ * function over (worldHome, claudeHome), so the entire contract — the key
+ * privacy rule, the validation, the sync, the view projection — is pinnable
+ * under `node --test` with no Cordis Context and no real home.
+ *
+ * @module agent-claude/claude-provider-gateway
+ */
+var __runInitializers = (this && this.__runInitializers) || function (thisArg, initializers, value) {
+    var useValue = arguments.length > 2;
+    for (var i = 0; i < initializers.length; i++) {
+        value = useValue ? initializers[i].call(thisArg, value) : initializers[i].call(thisArg);
+    }
+    return useValue ? value : void 0;
+};
+var __esDecorate = (this && this.__esDecorate) || function (ctor, descriptorIn, decorators, contextIn, initializers, extraInitializers) {
+    function accept(f) { if (f !== void 0 && typeof f !== "function") throw new TypeError("Function expected"); return f; }
+    var kind = contextIn.kind, key = kind === "getter" ? "get" : kind === "setter" ? "set" : "value";
+    var target = !descriptorIn && ctor ? contextIn["static"] ? ctor : ctor.prototype : null;
+    var descriptor = descriptorIn || (target ? Object.getOwnPropertyDescriptor(target, contextIn.name) : {});
+    var _, done = false;
+    for (var i = decorators.length - 1; i >= 0; i--) {
+        var context = {};
+        for (var p in contextIn) context[p] = p === "access" ? {} : contextIn[p];
+        for (var p in contextIn.access) context.access[p] = contextIn.access[p];
+        context.addInitializer = function (f) { if (done) throw new TypeError("Cannot add initializers after decoration has completed"); extraInitializers.push(accept(f || null)); };
+        var result = (0, decorators[i])(kind === "accessor" ? { get: descriptor.get, set: descriptor.set } : descriptor[key], context);
+        if (kind === "accessor") {
+            if (result === void 0) continue;
+            if (result === null || typeof result !== "object") throw new TypeError("Object expected");
+            if (_ = accept(result.get)) descriptor.get = _;
+            if (_ = accept(result.set)) descriptor.set = _;
+            if (_ = accept(result.init)) initializers.unshift(_);
+        }
+        else if (_ = accept(result)) {
+            if (kind === "field") initializers.unshift(_);
+            else descriptor[key] = _;
+        }
+    }
+    if (target) Object.defineProperty(target, contextIn.name, descriptor);
+    done = true;
+};
+import { Remote, TypertRemoteService } from "@deepseek-ai/dsh-typert-protocol";
+import { isProviderId, providerStorePath, readProviderStore, removeProvider, syncNativeProviders, upsertProvider, writeProviderStore, } from "./claude-providers.js";
+import { readNativeModel, readNativeProviders, } from "./claude-native-config.js";
+import { join } from "node:path";
+function isRecord(value) {
+    return value !== null && typeof value === "object" && !Array.isArray(value);
+}
+function nonEmpty(value) {
+    return typeof value === "string" && value.trim() !== "" ? value : undefined;
+}
+/**
+ * Whether an entry's key is actually available right now.
+ *
+ * Claude has no auth-manager shadowing to work around (the codex face's
+ * ChatGPT-login wrinkle has no analogue here): both kinds carry the literal
+ * secret and reach the child through its own environment
+ * (`claude-launch.ts`), so the store IS the whole truth — an empty value is the
+ * real "keyed outside Super D" state and nothing else can supply the key.
+ */
+function keyAvailable(entry) {
+    return entry.auth.value !== "";
+}
+function project(entry) {
+    return {
+        id: entry.id,
+        label: entry.label,
+        baseUrl: entry.baseUrl,
+        models: entry.models,
+        authKind: entry.auth.kind,
+        hasKey: keyAvailable(entry),
+    };
+}
+/** Turn one parsed native table into the store's import shape. */
+function toImport(table) {
+    // The native read emits a table only when a usable endpoint exists, and it
+    // always classifies an auth shape by then; the optionals are the TYPE being
+    // honest about a hand-edited file, so the fold keeps only tables that
+    // actually carry the pair.
+    if (table.baseUrl === undefined || table.auth === undefined)
+        return undefined;
+    return {
+        baseUrl: table.baseUrl,
+        auth: table.auth,
+        models: table.models,
+        ...(table.aliases === undefined ? {} : { aliases: table.aliases }),
+    };
+}
+/**
+ * Reconcile the canonical store against the user's `settings.json` env.
+ *
+ * This is the sync the 2026-10-04 ruling asks for: the store is canonical, the
+ * native settings env is a SOURCE, and the two are joined by endpoint URL (the
+ * only identity a hand-written settings env reliably carries — it names no
+ * provider). It runs at adapter startup and every ten minutes thereafter, and
+ * it is idempotent and silent — the store is only rewritten when something
+ * actually moved.
+ *
+ * @param worldHome - the world's DSH home.
+ * @param claudeHome - the native claude home (read only).
+ * @returns the effective store plus what the sync changed.
+ */
+export function syncFromNative(worldHome, claudeHome) {
+    const store = readProviderStore(worldHome);
+    const imported = readNativeProviders(claudeHome)
+        .map(toImport)
+        .filter((value) => value !== undefined);
+    const result = syncNativeProviders(store, imported);
+    if (result.added.length > 0 || result.updated.length > 0) {
+        writeProviderStore(worldHome, result.store);
+    }
+    return result;
+}
+/** The view for one (already loaded) store. */
+function viewOf(worldHome, claudeHome, store, syncedAt, note) {
+    // A settings env declares at most one endpoint, so the FIRST table is the
+    // one in force. `readNativeModel` is read on its own because a native setup
+    // on the default Anthropic endpoint carries a model but no base URL.
+    const baseUrl = readNativeProviders(claudeHome)[0]?.baseUrl;
+    const model = readNativeModel(claudeHome);
+    const native = baseUrl === undefined && model === undefined
+        ? null
+        : {
+            ...(baseUrl === undefined ? {} : { baseUrl }),
+            ...(model === undefined ? {} : { model }),
+        };
+    return {
+        providers: store.providers.map(project),
+        native,
+        paths: {
+            store: providerStorePath(worldHome),
+            settings: join(claudeHome, "settings.json"),
+        },
+        ...(syncedAt === undefined ? {} : { syncedAt }),
+        ...(note === undefined ? {} : { note }),
+    };
+}
+/**
+ * Read the panel state, reconciling with the native `settings.json` env first.
+ *
+ * Reading never writes the native home; the only write this can perform is to
+ * the adapter's own store, and only when the sync found something new.
+ *
+ * @param worldHome - the world's DSH home.
+ * @param claudeHome - the native claude home.
+ * @param syncedAt - epoch ms to report as the last reconcile.
+ * @returns the panel's state.
+ */
+export function readProvidersView(worldHome, claudeHome, syncedAt) {
+    const { store, added, updated } = syncFromNative(worldHome, claudeHome);
+    const note = added.length === 0 && updated.length === 0
+        ? undefined
+        : `Imported ${added.length} provider(s) from your Claude settings.json${updated.length === 0 ? "" : ` and refreshed ${updated.join(", ")}`}.`;
+    // A read IS the reconcile, so the timestamp is the read's own unless the
+    // caller has a better one — otherwise the panel would never have one to show.
+    return viewOf(worldHome, claudeHome, store, syncedAt ?? Date.now(), note);
+}
+/**
+ * Validate one `claudeProviders/save` request.
+ *
+ * @param request - the wire payload's `request` argument.
+ * @param existing - the entry this save replaces, so an edit that does not
+ * re-type the key keeps the stored one.
+ * @throws {TypeError} naming the offending field.
+ */
+export function normalizeSaveRequest(request, existing) {
+    if (!isRecord(request) || !isRecord(request["provider"])) {
+        throw new TypeError("claudeProviders/save: provider must be an object");
+    }
+    const raw = request["provider"];
+    const id = raw["id"];
+    if (!isProviderId(id)) {
+        throw new TypeError(`claudeProviders/save: id must match /^[a-z0-9][a-z0-9-]*$/ (got ${JSON.stringify(id)})`);
+    }
+    const label = nonEmpty(raw["label"]);
+    if (label === undefined)
+        throw new TypeError("claudeProviders/save: label must be a non-empty string");
+    const baseUrl = nonEmpty(raw["baseUrl"]);
+    if (baseUrl === undefined)
+        throw new TypeError("claudeProviders/save: baseUrl must be a non-empty string");
+    let parsed;
+    try {
+        parsed = new URL(baseUrl);
+    }
+    catch {
+        throw new TypeError(`claudeProviders/save: baseUrl is not a URL (got ${JSON.stringify(baseUrl)})`);
+    }
+    if (parsed.protocol !== "http:" && parsed.protocol !== "https:") {
+        throw new TypeError(`claudeProviders/save: baseUrl must be http(s) (got ${parsed.protocol})`);
+    }
+    const rawModels = raw["models"];
+    // An empty list is legal: it is the state a provider folded in from a native
+    // settings env that names no alias model arrives in, and the panel must be
+    // able to save an edit without inventing models.
+    if (!Array.isArray(rawModels)) {
+        throw new TypeError("claudeProviders/save: models must be an array");
+    }
+    const models = rawModels.map((value) => {
+        if (!isRecord(value))
+            throw new TypeError("claudeProviders/save: every entry of models must be an object");
+        const modelId = nonEmpty(value["id"]);
+        if (modelId === undefined)
+            throw new TypeError("claudeProviders/save: every entry of models needs a non-empty id");
+        const displayName = nonEmpty(value["displayName"]);
+        const contextWindow = value["contextWindow"];
+        return {
+            id: modelId,
+            ...(displayName === undefined ? {} : { displayName }),
+            ...(typeof contextWindow === "number" && Number.isSafeInteger(contextWindow) && contextWindow > 0
+                ? { contextWindow }
+                : {}),
+        };
+    });
+    // `aliases` is deliberately NOT a save field: the DEFAULT_*_MODEL mapping is
+    // derived by the native fold (spec §2.2), the panel never edits it, and a
+    // save of a folded entry drops it — the next reconcile re-derives it from
+    // the live settings env for as long as the endpoint still matches.
+    const rawAuth = raw["auth"];
+    if (!isRecord(rawAuth))
+        throw new TypeError("claudeProviders/save: auth must be an object");
+    const kind = rawAuth["kind"];
+    if (kind !== "authToken" && kind !== "apiKey") {
+        throw new TypeError(`claudeProviders/save: auth.kind must be "authToken" or "apiKey" (got ${JSON.stringify(kind)})`);
+    }
+    const value = rawAuth["value"];
+    if (typeof value !== "string")
+        throw new TypeError("claudeProviders/save: auth.value must be a string");
+    // An empty value on an edit means "keep the stored one" — the panel is
+    // write-only for keys, so it cannot echo the existing value back. The keep
+    // is per kind: a secret of the other shape is not this provider's key.
+    const kept = value === "" && existing?.auth.kind === kind ? existing.auth.value : value;
+    const auth = { kind, value: kept };
+    return { id, label, baseUrl, auth, models, origin: "user" };
+}
+/**
+ * Insert or replace one provider.
+ *
+ * Nothing native is written, and nothing is "activated": the entry sits in the
+ * list, and the next session that picks one of its models gets a child pinned
+ * to it — `claude-launch.ts` builds the provider's environment at spawn.
+ */
+export function saveProvider(worldHome, claudeHome, request, syncedAt) {
+    const store = readProviderStore(worldHome);
+    const id = isRecord(request) && isRecord(request["provider"]) ? request["provider"]["id"] : undefined;
+    const existing = store.providers.find((entry) => entry.id === id);
+    const entry = normalizeSaveRequest(request, existing);
+    const next = upsertProvider(store, entry);
+    writeProviderStore(worldHome, next);
+    return viewOf(worldHome, claudeHome, next, syncedAt);
+}
+/** Drop one provider. The native settings are left alone — removing from this list is not unconfiguring Claude Code. */
+export function removeProviderEntry(worldHome, claudeHome, request, syncedAt) {
+    const id = isRecord(request) ? nonEmpty(request["id"]) : undefined;
+    if (id === undefined)
+        throw new TypeError("claudeProviders/remove: id must be a non-empty string");
+    const store = readProviderStore(worldHome);
+    const next = removeProvider(store, id);
+    writeProviderStore(worldHome, next);
+    return viewOf(worldHome, claudeHome, next, syncedAt);
+}
+/**
+ * The adapter's provider Remote. One instance per world context.
+ */
+let ClaudeProvidersGateway = (() => {
+    let _classSuper = TypertRemoteService;
+    let _instanceExtraInitializers = [];
+    let _get_decorators;
+    let _save_decorators;
+    let _remove_decorators;
+    return class ClaudeProvidersGateway extends _classSuper {
+        static {
+            const _metadata = typeof Symbol === "function" && Symbol.metadata ? Object.create(_classSuper[Symbol.metadata] ?? null) : void 0;
+            _get_decorators = [Remote("get")];
+            _save_decorators = [Remote("save")];
+            _remove_decorators = [Remote("remove")];
+            __esDecorate(this, null, _get_decorators, { kind: "method", name: "get", static: false, private: false, access: { has: obj => "get" in obj, get: obj => obj.get }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _save_decorators, { kind: "method", name: "save", static: false, private: false, access: { has: obj => "save" in obj, get: obj => obj.save }, metadata: _metadata }, null, _instanceExtraInitializers);
+            __esDecorate(this, null, _remove_decorators, { kind: "method", name: "remove", static: false, private: false, access: { has: obj => "remove" in obj, get: obj => obj.remove }, metadata: _metadata }, null, _instanceExtraInitializers);
+            if (_metadata) Object.defineProperty(this, Symbol.metadata, { enumerable: true, configurable: true, writable: true, value: _metadata });
+        }
+        worldHome = __runInitializers(this, _instanceExtraInitializers);
+        claudeHome;
+        onChange;
+        /**
+         * @param ctx - the world context this service registers on (namespace `claudeProviders`).
+         * @param worldHome - the world's DSH home holding adapter state (`<dshHome>/agents/claude`).
+         * @param claudeHome - the USER's real claude home (native settings live there), resolved lazily so construction stays zero-IO.
+         * @param onChange - notified after any mutation, so the provider's `ctx.llm` routes can be re-registered.
+         */
+        constructor(ctx, worldHome, claudeHome, onChange = () => { }) {
+            super(ctx, "claudeProviders");
+            this.worldHome = worldHome;
+            this.claudeHome = claudeHome;
+            this.onChange = onChange;
+        }
+        /** Read the panel state, reconciling the store with the native settings env first. Never writes the native home. */
+        async get() {
+            const view = readProvidersView(this.worldHome, this.claudeHome());
+            this.onChange();
+            return view;
+        }
+        /** Add or edit one provider. */
+        async save(request) {
+            const view = saveProvider(this.worldHome, this.claudeHome(), request);
+            this.onChange();
+            return view;
+        }
+        /** Drop one provider from the list. */
+        async remove(request) {
+            const view = removeProviderEntry(this.worldHome, this.claudeHome(), request);
+            this.onChange();
+            return view;
+        }
+    };
+})();
+export { ClaudeProvidersGateway };