agentsw 0.3.0

package/dist/targets/codex.js

@@ -0,0 +1,136 @@
+import fs from "node:fs";
+import path from "node:path";
+import { parse as parseToml, stringify as stringifyToml } from "smol-toml";
+import { backupFile, home, readJsonIfExists, readTextIfExists, writeFileAtomic } from "../fsutil.js";
+const dir = path.join(home, ".codex");
+const configFile = path.join(dir, "config.toml");
+const authFile = path.join(dir, "auth.json");
+/**
+ * Codex CLI: [model_providers.<id>] in ~/.codex/config.toml selects a custom
+ * OpenAI-protocol endpoint; the key ships via ~/.codex/auth.json OPENAI_API_KEY.
+ * TOML round-trip via smol-toml preserves data but not comments (backed up first).
+ */
+export const codex = {
+    id: "codex",
+    name: "Codex CLI",
+    protocols: ["openai"],
+    configPaths: [configFile, authFile],
+    detect: () => fs.existsSync(dir),
+    async apply(provider) {
+        const notes = [];
+        const text = readTextIfExists(configFile);
+        const config = (text ? parseToml(text) : {});
+        config.model_provider = provider.id;
+        config.model = provider.defaultModel;
+        const model = provider.models.find((m) => m.id === provider.defaultModel);
+        if (provider.reasoningEffort && model?.reasoning !== false) {
+            config.model_reasoning_effort = provider.reasoningEffort;
+        }
+        // Codex only speaks the OpenAI Responses API (wire_api = "chat" was removed Feb 2026).
+        // requires_openai_auth = true makes Codex take the key from auth.json instead of an env var.
+        const providers = (config.model_providers ?? {});
+        providers[provider.id] = {
+            name: provider.name,
+            base_url: provider.baseUrl.replace(/\/$/, ""),
+            wire_api: "responses",
+            requires_openai_auth: true,
+        };
+        notes.push("codex requires an OpenAI Responses-compatible endpoint (/v1/responses); chat-completions-only endpoints will not work");
+        config.model_providers = providers;
+        const configBackup = backupFile(configFile);
+        if (configBackup)
+            notes.push(`backup: ${configBackup}`);
+        if (text?.includes("#"))
+            notes.push("config.toml comments are not preserved by TOML round-trip");
+        writeFileAtomic(configFile, stringifyToml(config) + "\n");
+        const auth = readJsonIfExists(authFile) ?? {};
+        auth.auth_mode = "apikey";
+        auth.OPENAI_API_KEY = provider.apiKey;
+        const authBackup = backupFile(authFile);
+        if (authBackup)
+            notes.push(`backup: ${authBackup}`);
+        writeFileAtomic(authFile, JSON.stringify(auth, null, 2) + "\n", 0o600);
+        return { app: this.id, changed: [configFile, authFile], notes };
+    },
+    async prune(provider) {
+        const text = readTextIfExists(configFile);
+        if (!text)
+            return { app: this.id, changed: [], notes: [], skipped: "no config.toml" };
+        const config = parseToml(text);
+        const providers = config.model_providers;
+        if (!providers?.[provider.id]) {
+            return { app: this.id, changed: [], notes: [], skipped: `no model_providers.${provider.id} entry` };
+        }
+        delete providers[provider.id];
+        if (Object.keys(providers).length === 0)
+            delete config.model_providers;
+        const notes = [];
+        if (config.model_provider === provider.id) {
+            delete config.model_provider;
+            delete config.model;
+            delete config.model_reasoning_effort;
+            notes.push("codex was pointing at this provider; model selection reset to defaults");
+        }
+        const backup = backupFile(configFile);
+        if (backup)
+            notes.push(`backup: ${backup}`);
+        writeFileAtomic(configFile, stringifyToml(config) + "\n");
+        notes.push("auth.json OPENAI_API_KEY left in place (not attributable to one provider)");
+        return { app: this.id, changed: [configFile], notes };
+    },
+    current() {
+        const text = readTextIfExists(configFile);
+        if (!text)
+            return undefined;
+        try {
+            const config = parseToml(text);
+            if (!config.model_provider)
+                return undefined;
+            return `${String(config.model_provider)} · ${String(config.model ?? "?")}`;
+        }
+        catch {
+            return undefined;
+        }
+    },
+    candidates() {
+        const text = readTextIfExists(configFile);
+        if (!text)
+            return [];
+        let config;
+        try {
+            config = parseToml(text);
+        }
+        catch {
+            return [];
+        }
+        const providers = config.model_providers;
+        if (!providers)
+            return [];
+        const auth = readJsonIfExists(authFile);
+        const authKey = auth?.OPENAI_API_KEY || auth?.tokens?.access_token;
+        const active = typeof config.model_provider === "string" ? config.model_provider : undefined;
+        const self = this.id;
+        return Object.entries(providers).flatMap(([id, entry]) => {
+            if (!entry || typeof entry.base_url !== "string")
+                return [];
+            const envKey = typeof entry.env_key === "string" ? entry.env_key : undefined;
+            const apiKey = (envKey ? process.env[envKey] : undefined) ?? (active === id && entry.requires_openai_auth ? authKey : undefined);
+            const models = active === id && typeof config.model === "string" ? [config.model] : [];
+            return [
+                {
+                    id,
+                    name: typeof entry.name === "string" ? entry.name : id,
+                    protocol: "openai",
+                    // codex config declares its wire explicitly; legacy configs may still carry "chat"
+                    openaiApi: entry.wire_api === "chat" ? "completions" : "responses",
+                    baseUrl: entry.base_url,
+                    apiKey: apiKey || undefined,
+                    keyEnv: envKey,
+                    models,
+                    defaultModel: models[0],
+                    source: self,
+                },
+            ];
+        });
+    },
+};

package/dist/targets/dsh.js

@@ -0,0 +1,296 @@
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+import { backupFile, expandHome, home, readTextIfExists, writeFileAtomic } from "../fsutil.js";
+import { apiValue, classifyApi, mergeModels } from "./wire.js";
+/** `$DSH_HOME`, or `~/.dsh` (packages/util/home-paths `resolveDshHome`). */
+function dshHome() {
+    const env = process.env.DSH_HOME?.trim();
+    return env ? expandHome(env) : path.join(home, ".dsh");
+}
+/**
+ * Settings document: `<harness home>/settings.yaml` by default; the extension
+ * picks the format, so an existing `.yml`/`.json` document is written in place.
+ */
+function settingsFile() {
+    const dir = dshHome();
+    for (const name of ["settings.yaml", "settings.yml", "settings.json"]) {
+        const file = path.join(dir, name);
+        if (fs.existsSync(file))
+            return file;
+    }
+    return path.join(dir, "settings.yaml");
+}
+const credentialsFile = () => path.join(dshHome(), ".credentials.yaml");
+/** Layout version of `.credentials.yaml` this build reads and writes. */
+const CREDENTIALS_VERSION = 1;
+/** Credential reference: a POSIX identifier (`/^[A-Za-z_][A-Za-z0-9_]*$/`). */
+const credentialRef = (id) => `AGENTSW_${id.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`;
+/** Thinking levels a `reasoningEfforts` entry may offer (llm-pi-ai THINKING_LEVEL_GATE). */
+const THINKING_LEVELS = ["off", "minimal", "low", "medium", "high", "xhigh", "max"];
+/** Per-model keys this adapter writes; one that stops being emitted is cleared, not inherited. */
+const OWNED_MODEL_KEYS = ["id", "name", "contextWindow", "maxTokens", "input", "reasoningEfforts"];
+/** models.dev efforts -> `{ level: wire spelling }`; an unoffered level is omitted, not nulled. */
+function reasoningEfforts(efforts) {
+    const map = {};
+    if (efforts.includes("none"))
+        map.off = "none";
+    for (const level of THINKING_LEVELS) {
+        if (level !== "off" && efforts.includes(level))
+            map[level] = level;
+    }
+    return map;
+}
+function modelEntry(m) {
+    return {
+        id: m.id,
+        ...(m.name ? { name: m.name } : {}),
+        ...(m.contextWindow ? { contextWindow: m.contextWindow } : {}),
+        ...(m.maxOutput ? { maxTokens: m.maxOutput } : {}),
+        input: m.imageInput ? ["text", "image"] : ["text"],
+        ...(m.reasoning === false
+            ? { reasoningEfforts: false }
+            : m.reasoning && m.reasoningEfforts?.length
+                ? { reasoningEfforts: reasoningEfforts(m.reasoningEfforts) }
+                : {}),
+    };
+}
+function parseSettings(file) {
+    const text = readTextIfExists(file);
+    const doc = text ? YAML.parseDocument(text) : new YAML.Document({});
+    if (doc.errors.length) {
+        throw new Error(`${file} has settings errors; refusing to rewrite: ${doc.errors[0]?.message}`);
+    }
+    if (doc.contents == null)
+        doc.contents = doc.createNode({});
+    return doc;
+}
+/** JSON documents re-serialize without comments; YAML keeps them (dsh reads both). */
+function renderSettings(file, doc) {
+    return file.endsWith(".json") ? JSON.stringify(doc.toJSON(), null, 2) + "\n" : doc.toString();
+}
+/**
+ * DeepSeek Harness (dsh): provider routes live in the `llm-pi-ai` section of
+ * `$DSH_HOME/settings.yaml`, the picked default in `agent-default-model`, and
+ * the key in `$DSH_HOME/.credentials.yaml` — settings carry only a reference.
+ */
+export const dsh = {
+    id: "dsh",
+    name: "DeepSeek Harness",
+    protocols: ["openai", "anthropic"],
+    configPaths: [settingsFile(), credentialsFile()],
+    detect: () => fs.existsSync(dshHome()),
+    async apply(provider) {
+        const notes = [];
+        const file = settingsFile();
+        const doc = parseSettings(file);
+        const at = ["llm-pi-ai", "providers", provider.id];
+        const prev = doc.getIn(at)?.toJSON?.();
+        const ref = credentialRef(provider.id);
+        const entry = {
+            displayName: provider.name,
+            apiKeyEnv: ref, // credential reference, never the secret
+            api: apiValue(provider.protocol, provider.openaiApi, prev?.api),
+            baseURL: provider.baseUrl,
+            models: mergeModels(prev?.models, provider.models.map(modelEntry), OWNED_MODEL_KEYS),
+        };
+        if (YAML.isMap(doc.getIn(at))) {
+            // Key-by-key: compat, headers, defaultInput, retryPolicy and their comments are the user's.
+            for (const [key, value] of Object.entries(entry))
+                doc.setIn([...at, key], doc.createNode(value));
+        }
+        else {
+            doc.setIn(at, doc.createNode(entry));
+        }
+        if (doc.hasIn([...at, "modelOverrides"])) {
+            // llm-pi-ai refuses modelOverrides beside an explicit models list.
+            doc.deleteIn([...at, "modelOverrides"]);
+            notes.push("dropped modelOverrides (llm-pi-ai refuses it beside an explicit models list)");
+        }
+        // The picker writes this section whole; a partial write would keep a stale reasoningEffort.
+        doc.set("agent-default-model", doc.createNode({ provider: provider.id, model: provider.defaultModel }));
+        const backup = backupFile(file);
+        if (backup)
+            notes.push(`backup: ${backup}`);
+        writeFileAtomic(file, renderSettings(file, doc));
+        const changed = [file, writeCredential(ref, provider.apiKey, notes)];
+        notes.push(`select in dsh with the model picker, or run: dsh web`);
+        return { app: this.id, changed, notes };
+    },
+    async prune(provider) {
+        const notes = [];
+        // The stored key is removed even when the route is already gone, so a hand-deleted
+        // route never leaves its secret behind.
+        const droppedCredential = deleteCredential(credentialRef(provider.id), notes);
+        const file = settingsFile();
+        const doc = fs.existsSync(file) ? parseSettings(file) : undefined;
+        const at = ["llm-pi-ai", "providers", provider.id];
+        if (!doc?.hasIn(at)) {
+            const why = doc ? `no llm-pi-ai.providers.${provider.id} entry` : "no settings document";
+            if (!droppedCredential)
+                return { app: this.id, changed: [], notes, skipped: why };
+            notes.push(why);
+            return { app: this.id, changed: [droppedCredential], notes };
+        }
+        doc.deleteIn(at);
+        if (doc.getIn(["agent-default-model", "provider"]) === provider.id) {
+            doc.delete("agent-default-model");
+            notes.push("default model selection reset (was pointing at this provider)");
+        }
+        // leave no "providers: {}" / "llm-pi-ai: {}" behind
+        for (const empty of [["llm-pi-ai", "providers"], ["llm-pi-ai"]]) {
+            const node = doc.getIn(empty);
+            if (YAML.isMap(node) && node.items.length === 0)
+                doc.deleteIn(empty);
+        }
+        const backup = backupFile(file);
+        if (backup)
+            notes.push(`backup: ${backup}`);
+        writeFileAtomic(file, renderSettings(file, doc));
+        const changed = [file];
+        if (droppedCredential)
+            changed.push(droppedCredential);
+        return { app: this.id, changed, notes };
+    },
+    current() {
+        const text = readTextIfExists(settingsFile());
+        if (!text)
+            return undefined;
+        try {
+            const parsed = YAML.parse(text);
+            const selection = parsed?.["agent-default-model"];
+            if (!selection?.provider)
+                return undefined;
+            return `${selection.provider} · ${selection.model ?? "?"}`;
+        }
+        catch {
+            return undefined;
+        }
+    },
+    candidates() {
+        const text = readTextIfExists(settingsFile());
+        if (!text)
+            return [];
+        let parsed;
+        try {
+            parsed = YAML.parse(text);
+        }
+        catch {
+            return [];
+        }
+        const providers = parsed?.["llm-pi-ai"]?.providers;
+        if (!providers)
+            return [];
+        const refs = readCredentialRefs();
+        const selection = parsed?.["agent-default-model"];
+        const self = this.id;
+        return Object.entries(providers).flatMap(([id, entry]) => {
+            if (!entry || typeof entry.baseURL !== "string")
+                return [];
+            const wire = classifyApi(entry.api);
+            if (!wire)
+                return [];
+            const keyEnv = typeof entry.apiKeyEnv === "string" && entry.apiKeyEnv ? entry.apiKeyEnv : undefined;
+            // dsh credential precedence: inherited process environment first, then the managed store.
+            const apiKey = keyEnv ? (process.env[keyEnv] ?? refs[keyEnv]) : undefined;
+            const models = Array.isArray(entry.models)
+                ? entry.models.map((m) => (typeof m?.id === "string" ? m.id : "")).filter(Boolean)
+                : [];
+            const defaultModel = selection?.provider === id ? selection.model : undefined;
+            if (defaultModel && !models.includes(defaultModel))
+                models.unshift(defaultModel);
+            return [
+                {
+                    id,
+                    name: typeof entry.displayName === "string" ? entry.displayName : id,
+                    protocol: wire.protocol,
+                    openaiApi: wire.openaiApi,
+                    baseUrl: entry.baseURL,
+                    apiKey,
+                    keyEnv,
+                    models,
+                    defaultModel,
+                    source: self,
+                },
+            ];
+        });
+    },
+};
+/** Read the managed store's `refs` section; an unreadable document yields no keys. */
+function readCredentialRefs() {
+    const text = readTextIfExists(credentialsFile());
+    if (!text)
+        return {};
+    try {
+        const parsed = YAML.parse(text);
+        const refs = parsed?.refs;
+        if (refs && typeof refs === "object")
+            return refs;
+        // pre-release flat layout: top-level reference-to-secret mapping
+        if (parsed && !("version" in parsed))
+            return parsed;
+        return {};
+    }
+    catch {
+        return {};
+    }
+}
+function parseCredentials(file) {
+    const text = readTextIfExists(file);
+    const doc = text ? YAML.parseDocument(text) : new YAML.Document({});
+    if (doc.errors.length) {
+        throw new Error(`${file} has YAML errors; refusing to rewrite: ${doc.errors[0]?.message}`);
+    }
+    if (doc.contents == null)
+        doc.contents = doc.createNode({});
+    return doc;
+}
+/**
+ * Store the key under `refs`, migrating a pre-release flat document first.
+ * The flat layout is recognized exactly the way dsh recognizes it — a mapping
+ * of reference names to non-empty string scalars — so a document that only
+ * looks unversioned (a hand-written `refs:` block, a future layout) is refused
+ * instead of being re-rooted one level deeper. Returns the file.
+ */
+function writeCredential(ref, apiKey, notes) {
+    const file = credentialsFile();
+    const doc = parseCredentials(file);
+    const root = (doc.toJSON() ?? {});
+    const version = root.version;
+    if (version !== undefined && version !== CREDENTIALS_VERSION) {
+        throw new Error(`${file} declares version ${JSON.stringify(version)}; agentsw writes version ${CREDENTIALS_VERSION}`);
+    }
+    if (version === undefined && Object.keys(root).length > 0) {
+        const flat = Object.entries(root).every(([key, value]) => /^[A-Za-z_][A-Za-z0-9_]*$/.test(key) && typeof value === "string" && value.length > 0);
+        if (!flat) {
+            throw new Error(`${file} is neither the version ${CREDENTIALS_VERSION} layout nor a pre-release flat document; refusing to rewrite it`);
+        }
+        doc.contents = doc.createNode({ version: CREDENTIALS_VERSION, refs: root });
+        notes.push(`migrated ${file} to the version ${CREDENTIALS_VERSION} layout`);
+    }
+    doc.set("version", CREDENTIALS_VERSION);
+    doc.setIn(["refs", ref], apiKey);
+    const backup = backupFile(file);
+    if (backup)
+        notes.push(`backup: ${backup}`);
+    // dsh refuses a credentials document readable beyond its owner.
+    writeFileAtomic(file, doc.toString(), 0o600);
+    return file;
+}
+/** Drop this provider's reference. Returns the file when it was rewritten. */
+function deleteCredential(ref, notes) {
+    const file = credentialsFile();
+    const text = readTextIfExists(file);
+    if (!text)
+        return undefined;
+    const doc = parseCredentials(file);
+    const at = doc.hasIn(["refs", ref]) ? ["refs", ref] : doc.has(ref) ? [ref] : undefined;
+    if (!at)
+        return undefined;
+    doc.deleteIn(at);
+    const backup = backupFile(file);
+    if (backup)
+        notes.push(`backup: ${backup}`);
+    writeFileAtomic(file, doc.toString(), 0o600);
+    return file;
+}

package/dist/targets/hermes.js

@@ -0,0 +1,173 @@
+import fs from "node:fs";
+import path from "node:path";
+import YAML from "yaml";
+import { backupFile, readTextIfExists, writeFileAtomic } from "../fsutil.js";
+function hermesHome() {
+    const env = process.env.HERMES_HOME?.trim();
+    if (env)
+        return env;
+    if (process.platform === "win32" && process.env.LOCALAPPDATA) {
+        return path.join(process.env.LOCALAPPDATA, "hermes");
+    }
+    return path.join(process.env.HOME ?? "", ".hermes");
+}
+/**
+ * hermes (NousResearch): providers dict + model section in ~/.hermes/config.yaml,
+ * API key in ~/.hermes/.env referenced via key_env. hermes refuses to load an
+ * unparseable config.yaml, so we round-trip through YAML Document (comments kept).
+ */
+export const hermes = {
+    id: "hermes",
+    name: "Hermes",
+    protocols: ["openai", "anthropic"],
+    configPaths: [path.join(hermesHome(), "config.yaml"), path.join(hermesHome(), ".env")],
+    detect: () => fs.existsSync(hermesHome()),
+    async apply(provider) {
+        const home = hermesHome();
+        const configFile = path.join(home, "config.yaml");
+        const envFile = path.join(home, ".env");
+        const notes = [];
+        const text = readTextIfExists(configFile);
+        const doc = text ? YAML.parseDocument(text) : new YAML.Document({});
+        if (doc.errors.length) {
+            throw new Error(`${configFile} has YAML errors; refusing to rewrite: ${doc.errors[0]?.message}`);
+        }
+        if (doc.contents == null)
+            doc.contents = doc.createNode({});
+        const keyVar = `AGENTSW_${provider.id.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`;
+        const at = ["providers", provider.id];
+        const prev = doc.getIn(at)?.toJSON?.();
+        const prevModels = (prev?.models ?? {});
+        const models = {};
+        for (const m of provider.models) {
+            const old = { ...prevModels[m.id] };
+            delete old.context_length; // owned: a model that loses its size must not keep the old one
+            models[m.id] = { ...old, ...(m.contextWindow ? { context_length: m.contextWindow } : {}) };
+        }
+        const entry = {
+            name: provider.name,
+            api: provider.baseUrl,
+            key_env: keyVar,
+            transport: provider.protocol === "anthropic" ? "anthropic_messages" : "chat_completions",
+            default_model: provider.defaultModel,
+            models,
+        };
+        // Key-by-key when the route exists: provider-level keys agentsw does not model
+        // (and their comments) belong to the user.
+        if (YAML.isMap(doc.getIn(at))) {
+            for (const [key, value] of Object.entries(entry))
+                doc.setIn([...at, key], doc.createNode(value));
+        }
+        else {
+            doc.setIn(at, doc.createNode(entry));
+        }
+        doc.setIn(["model", "provider"], provider.id);
+        doc.setIn(["model", "default"], provider.defaultModel);
+        const configBackup = backupFile(configFile);
+        if (configBackup)
+            notes.push(`backup: ${configBackup}`);
+        writeFileAtomic(configFile, doc.toString());
+        // upsert the key into ~/.hermes/.env
+        const envText = readTextIfExists(envFile) ?? "";
+        const line = `${keyVar}=${provider.apiKey}`;
+        const pattern = new RegExp(`^${keyVar}=.*$`, "m");
+        const nextEnv = pattern.test(envText)
+            ? envText.replace(pattern, line)
+            : envText + (envText.endsWith("\n") || envText === "" ? "" : "\n") + line + "\n";
+        const envBackup = backupFile(envFile);
+        if (envBackup)
+            notes.push(`backup: ${envBackup}`);
+        writeFileAtomic(envFile, nextEnv, 0o600);
+        return { app: this.id, changed: [configFile, envFile], notes };
+    },
+    async prune(provider) {
+        const home = hermesHome();
+        const configFile = path.join(home, "config.yaml");
+        const envFile = path.join(home, ".env");
+        const text = readTextIfExists(configFile);
+        if (!text)
+            return { app: this.id, changed: [], notes: [], skipped: "no config.yaml" };
+        const doc = YAML.parseDocument(text);
+        if (doc.errors.length) {
+            throw new Error(`${configFile} has YAML errors; refusing to rewrite: ${doc.errors[0]?.message}`);
+        }
+        if (!doc.hasIn(["providers", provider.id])) {
+            return { app: this.id, changed: [], notes: [], skipped: `no providers.${provider.id} entry` };
+        }
+        doc.deleteIn(["providers", provider.id]);
+        const notes = [];
+        if (doc.getIn(["model", "provider"]) === provider.id) {
+            doc.deleteIn(["model", "provider"]);
+            doc.deleteIn(["model", "default"]);
+            notes.push("model selection reset (was pointing at this provider)");
+        }
+        // drop now-empty sections instead of leaving "model: {}" / "providers: {}"
+        for (const key of ["model", "providers"]) {
+            const node = doc.get(key);
+            if (YAML.isMap(node) && node.items.length === 0)
+                doc.delete(key);
+        }
+        const changed = [configFile];
+        const configBackup = backupFile(configFile);
+        if (configBackup)
+            notes.push(`backup: ${configBackup}`);
+        writeFileAtomic(configFile, doc.toString());
+        const keyVar = `AGENTSW_${provider.id.toUpperCase().replace(/[^A-Z0-9]/g, "_")}_API_KEY`;
+        const envText = readTextIfExists(envFile);
+        if (envText && new RegExp(`^${keyVar}=`, "m").test(envText)) {
+            const envBackup = backupFile(envFile);
+            if (envBackup)
+                notes.push(`backup: ${envBackup}`);
+            writeFileAtomic(envFile, envText.replace(new RegExp(`^${keyVar}=.*\\n?`, "m"), ""), 0o600);
+            changed.push(envFile);
+        }
+        return { app: this.id, changed, notes };
+    },
+    current() {
+        const text = readTextIfExists(path.join(hermesHome(), "config.yaml"));
+        if (!text)
+            return undefined;
+        try {
+            const parsed = YAML.parse(text);
+            if (!parsed?.model?.provider)
+                return undefined;
+            return `${parsed.model.provider} · ${parsed.model.default ?? parsed.model.model ?? "?"}`;
+        }
+        catch {
+            return undefined;
+        }
+    },
+    candidates() {
+        const hh = hermesHome();
+        const text = readTextIfExists(path.join(hh, "config.yaml"));
+        if (!text)
+            return [];
+        let parsed;
+        try {
+            parsed = YAML.parse(text);
+        }
+        catch {
+            return [];
+        }
+        if (!parsed?.providers)
+            return [];
+        const envText = readTextIfExists(path.join(hh, ".env")) ?? "";
+        const readEnv = (key) => process.env[key] ?? (envText.match(new RegExp(`^${key.replace(/[.*+?^${}()|[\]\\]/g, "\\$&")}=(.*)$`, "m"))?.[1]?.trim() || undefined);
+        const self = this.id;
+        return Object.entries(parsed.providers).flatMap(([id, entry]) => {
+            if (!entry || typeof entry.api !== "string" || !entry.api)
+                return [];
+            const protocol = entry.transport === "anthropic_messages" ? "anthropic" : entry.transport === "chat_completions" ? "openai" : undefined;
+            if (!protocol)
+                return [];
+            const keyEnv = typeof entry.key_env === "string" && entry.key_env ? entry.key_env : undefined;
+            const apiKey = keyEnv ? readEnv(keyEnv) : undefined;
+            const models = Object.keys(entry.models ?? {});
+            const active = parsed?.model?.provider === id ? parsed?.model?.default ?? parsed?.model?.model : undefined;
+            const defaultModel = entry.default_model ?? active;
+            if (defaultModel && !models.includes(defaultModel))
+                models.unshift(defaultModel);
+            return [{ id, name: entry.name ?? id, protocol, baseUrl: entry.api, apiKey, keyEnv, models, defaultModel, source: self }];
+        });
+    },
+};

package/dist/targets/index.js

@@ -0,0 +1,26 @@
+import { claudecode } from "./claudecode.js";
+import { dsh } from "./dsh.js";
+import { codex } from "./codex.js";
+import { omp } from "./omp.js";
+import { opencode } from "./opencode.js";
+import { hermes } from "./hermes.js";
+import { pi, prime } from "./pistyle.js";
+import { workbuddy } from "./workbuddy.js";
+export const targets = [claudecode, codex, omp, pi, prime, opencode, hermes, workbuddy, dsh];
+export function resolveTargets(filter) {
+    if (!filter || filter === "all")
+        return targets;
+    const wanted = filter.split(",").map((s) => s.trim().toLowerCase()).filter(Boolean);
+    const out = [];
+    for (const w of wanted) {
+        const hit = targets.find((t) => t.id === w || t.name.toLowerCase() === w);
+        if (!hit) {
+            throw new Error(`unknown app "${w}" (supported: ${targets.map((t) => t.id).join(", ")})`);
+        }
+        out.push(hit);
+    }
+    return out;
+}
+export function supportsProtocol(target, protocol) {
+    return target.protocols.includes(protocol);
+}