agentsw 0.3.0

package/dist/menu.js

@@ -0,0 +1,157 @@
+import pc from "picocolors";
+import prompts from "prompts";
+import { cmdAdd, cmdApps, cmdDiscover, cmdImport, cmdList, cmdRemove, cmdStatus, cmdSync, cmdUpgrade, cmdUse, } from "./commands.js";
+import { getLocale, setLocale, t } from "./i18n.js";
+import { loadStore, saveStore } from "./store.js";
+function bye() {
+    console.log(pc.dim(`\n${t("menu.bye")}`));
+    process.exit(0);
+}
+const cancel = { onCancel: () => bye() };
+async function askToggle(message, initial = false) {
+    const { v } = await prompts({ type: "toggle", name: "v", message, active: t("menu.yes"), inactive: t("menu.no"), initial }, cancel);
+    return v === true;
+}
+async function chooseLanguage() {
+    const { language } = await prompts({
+        type: "select",
+        name: "language",
+        message: t("language.prompt"),
+        hint: t("menu.selectInstructions"),
+        initial: getLocale() === "zh-CN" ? 1 : 0,
+        choices: [
+            { title: "English", value: "en" },
+            { title: "简体中文", value: "zh-CN" },
+        ],
+    }, cancel);
+    setLocale(language);
+    const store = loadStore();
+    store.language = language;
+    saveStore(store);
+    console.log(pc.green(t("language.saved")));
+}
+/** select an existing provider; prints a hint and returns undefined when none configured */
+async function pickProvider(message) {
+    const store = loadStore();
+    const ids = Object.keys(store.providers);
+    if (ids.length === 0) {
+        console.log(pc.yellow(t("menu.noProvidersHint")));
+        return undefined;
+    }
+    const { id } = await prompts({
+        type: "select",
+        name: "id",
+        message,
+        hint: t("menu.selectInstructions"),
+        choices: ids.map((pid) => {
+            const p = store.providers[pid];
+            return {
+                title: `${pid} · ${p.protocol} · ${t("menu.defaultModel")} ${p.defaultModel}${store.active === pid ? `  (${t("menu.active")})` : ""}`,
+                value: pid,
+            };
+        }),
+    }, cancel);
+    if (!id)
+        return undefined;
+    const p = store.providers[id];
+    return { id, defaultModel: p.defaultModel, models: p.models.map((m) => m.id) };
+}
+export async function cmdMenu() {
+    if (!loadStore().language)
+        await chooseLanguage();
+    console.log(pc.bold("agentsw") + pc.dim(t("menu.title")));
+    if (Object.keys(loadStore().providers).length === 0) {
+        console.log(pc.yellow(t("menu.noProviders")));
+        if (await askToggle(t("menu.firstScan"), true))
+            await cmdImport({});
+    }
+    for (;;) {
+        console.log("");
+        const { action } = await prompts({
+            type: "select",
+            name: "action",
+            message: t("menu.what"),
+            hint: t("menu.selectInstructions"),
+            choices: [
+                { title: t("menu.add"), value: "add" },
+                { title: t("menu.import"), value: "import" },
+                { title: t("menu.use"), value: "use" },
+                { title: t("menu.status"), value: "status" },
+                { title: t("menu.list"), value: "list" },
+                { title: t("menu.sync"), value: "sync" },
+                { title: t("menu.discover"), value: "discover" },
+                { title: t("menu.remove"), value: "remove" },
+                { title: t("menu.apps"), value: "apps" },
+                { title: t("menu.language"), value: "language" },
+                { title: t("menu.quit"), value: "quit" },
+            ],
+        }, cancel);
+        if (action === undefined || action === "quit")
+            return;
+        if (action === "add") {
+            const { src } = await prompts({
+                type: "select",
+                name: "src",
+                message: t("menu.modelSource"),
+                hint: t("menu.selectInstructions"),
+                choices: [
+                    { title: t("menu.modelDiscover"), value: "discover" },
+                    { title: t("menu.modelManual"), value: "manual" },
+                ],
+            }, cancel);
+            await cmdAdd({ discover: src === "discover" });
+        }
+        else if (action === "import") {
+            await cmdImport({});
+        }
+        else if (action === "use") {
+            const picked = await pickProvider(t("menu.pickProvider"));
+            if (!picked)
+                continue;
+            const { model } = await prompts({
+                type: picked.models.length > 1 ? "select" : null,
+                name: "model",
+                message: t("menu.defaultModel"),
+                hint: t("menu.selectInstructions"),
+                choices: [
+                    { title: t("menu.keepDefault", { model: picked.defaultModel }), value: "" },
+                    ...picked.models.filter((m) => m !== picked.defaultModel).map((m) => ({ title: m, value: m })),
+                ],
+            }, cancel);
+            await cmdUse(picked.id, { model: model || undefined });
+        }
+        else if (action === "status") {
+            cmdStatus();
+        }
+        else if (action === "list") {
+            cmdList();
+        }
+        else if (action === "sync") {
+            await cmdSync({});
+        }
+        else if (action === "discover") {
+            const picked = await pickProvider(t("menu.discoverFor"));
+            if (!picked)
+                continue;
+            const sync = await askToggle(t("menu.pushRefresh"));
+            await cmdDiscover(picked.id, { sync });
+        }
+        else if (action === "remove") {
+            const picked = await pickProvider(t("menu.removeProvider"));
+            if (!picked)
+                continue;
+            if (!(await askToggle(t("menu.reallyRemove", { id: pc.bold(picked.id) }))))
+                continue;
+            const prune = await askToggle(t("menu.pruneConfigs"));
+            await cmdRemove(picked.id, { prune });
+        }
+        else if (action === "apps") {
+            await cmdApps();
+            if (await askToggle(t("menu.upgrade")))
+                await cmdUpgrade([]);
+        }
+        else if (action === "language") {
+            await chooseLanguage();
+        }
+    }
+}

package/dist/modelsdev.js

@@ -0,0 +1,110 @@
+import path from "node:path";
+import fs from "node:fs";
+import { configDir } from "./store.js";
+import { readJsonIfExists, writeFileAtomic } from "./fsutil.js";
+const API_URL = "https://models.dev/api.json";
+const CACHE_FILE = path.join(configDir, "models-dev.json");
+const CACHE_TTL_MS = 24 * 60 * 60 * 1000;
+export async function loadCatalog(opts = {}) {
+    if (!opts.refresh) {
+        try {
+            const stat = fs.statSync(CACHE_FILE);
+            const fresh = Date.now() - stat.mtimeMs < CACHE_TTL_MS;
+            if (fresh || opts.offline)
+                return readJsonIfExists(CACHE_FILE);
+        }
+        catch {
+            /* no cache */
+        }
+    }
+    if (opts.offline)
+        return readJsonIfExists(CACHE_FILE);
+    try {
+        const res = await fetch(API_URL, { signal: AbortSignal.timeout(15000) });
+        if (!res.ok)
+            throw new Error(`models.dev responded ${res.status}`);
+        const text = await res.text();
+        JSON.parse(text); // validate before caching
+        writeFileAtomic(CACHE_FILE, text);
+        return JSON.parse(text);
+    }
+    catch (err) {
+        // network failure: fall back to stale cache if present
+        const cached = readJsonIfExists(CACHE_FILE);
+        if (cached)
+            return cached;
+        process.stderr.write(`warning: could not fetch models.dev catalog: ${err.message}\n`);
+        return undefined;
+    }
+}
+function toModelSpec(id, m) {
+    const efforts = m.reasoning_options?.find((o) => o.type === "effort")?.values;
+    return {
+        id,
+        name: m.name,
+        contextWindow: m.limit?.context,
+        maxInput: m.limit?.input,
+        maxOutput: m.limit?.output,
+        reasoning: m.reasoning,
+        reasoningEfforts: efforts?.length ? efforts : undefined,
+        imageInput: m.attachment || m.modalities?.input?.includes("image") || undefined,
+        cost: m.cost
+            ? { input: m.cost.input, output: m.cost.output, cacheRead: m.cost.cache_read, cacheWrite: m.cost.cache_write }
+            : undefined,
+    };
+}
+/**
+ * Find catalog metadata for a model id.
+ * Match order: hinted provider exact → hinted provider basename → any provider exact → any basename.
+ * Basename = id segment after the last "/" (gateways list ids like "anthropic/claude-opus-4.7").
+ */
+export function findModelMeta(catalog, modelId, providerHint) {
+    const base = modelId.slice(modelId.lastIndexOf("/") + 1).toLowerCase();
+    const scan = (p) => {
+        if (p.models[modelId])
+            return p.models[modelId];
+        for (const [id, m] of Object.entries(p.models)) {
+            if (id.slice(id.lastIndexOf("/") + 1).toLowerCase() === base)
+                return m;
+        }
+        return undefined;
+    };
+    const hinted = providerHint ? catalog[providerHint] : undefined;
+    if (hinted) {
+        const m = scan(hinted);
+        if (m)
+            return { spec: toModelSpec(modelId, m), provider: hinted.id };
+    }
+    for (const p of Object.values(catalog)) {
+        if (p === hinted)
+            continue;
+        const m = scan(p);
+        if (m)
+            return { spec: toModelSpec(modelId, m), provider: p.id };
+    }
+    return undefined;
+}
+/** Enrich a list of model ids with models.dev metadata; unmatched ids pass through bare. */
+export function enrichModels(catalog, ids, providerHint) {
+    return ids.map((id) => {
+        const hit = catalog ? findModelMeta(catalog, id, providerHint) : undefined;
+        return hit?.spec ?? { id };
+    });
+}
+/** Search catalog models by substring across provider/model ids and names. */
+export function searchCatalog(catalog, query, limit = 50) {
+    const q = query.toLowerCase();
+    const out = [];
+    for (const p of Object.values(catalog)) {
+        for (const [id, m] of Object.entries(p.models)) {
+            if (id.toLowerCase().includes(q) ||
+                (m.name?.toLowerCase().includes(q) ?? false) ||
+                p.id.toLowerCase().includes(q)) {
+                out.push({ provider: p.id, spec: toModelSpec(id, m) });
+                if (out.length >= limit)
+                    return out;
+            }
+        }
+    }
+    return out;
+}

package/dist/slug.js

@@ -0,0 +1,18 @@
+/** Derive a provider-id slug from a base URL host, for apps whose config carries no provider name. */
+export function slugFromBaseUrl(baseUrl) {
+    let host = "";
+    try {
+        host = new URL(baseUrl).hostname;
+    }
+    catch {
+        return "imported";
+    }
+    const labels = host.split(".").filter((l) => l && !["api", "www"].includes(l.toLowerCase()));
+    const first = labels.find((l) => /[a-z]/i.test(l)) ?? labels[0] ?? host;
+    const slug = first.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^[-_]+|[-_]+$/g, "");
+    return /^[a-z0-9]/.test(slug) ? slug : "imported";
+}
+/** True for bare UPPER_SNAKE names that apps may treat as env-var references (omp, prime). */
+export function looksLikeEnvName(v) {
+    return /^[A-Z][A-Z0-9_]*$/.test(v);
+}

package/dist/sources/ccswitch.js

@@ -0,0 +1,151 @@
+import fs from "node:fs";
+import { createRequire } from "node:module";
+import path from "node:path";
+import { parse as parseToml } from "smol-toml";
+import { home } from "../fsutil.js";
+import { slugFromBaseUrl } from "../slug.js";
+import { classifyApi } from "../targets/wire.js";
+/** cc-switch (the Tauri desktop switcher) keeps every managed app's providers in one SQLite file. */
+const storeFile = path.join(home, ".cc-switch", "cc-switch.db");
+/** Source id shown in the `import` preview. */
+export const CC_SWITCH_SOURCE = "cc-switch";
+/** Claude Code / Claude Desktop rows: the env block, same shape agentsw's claude adapter writes. */
+function fromEnvShape(settings) {
+    const env = settings.env;
+    if (!env?.ANTHROPIC_BASE_URL)
+        return undefined;
+    const models = [
+        typeof settings.model === "string" ? settings.model : undefined,
+        env.ANTHROPIC_MODEL,
+        env.ANTHROPIC_DEFAULT_OPUS_MODEL,
+        env.ANTHROPIC_DEFAULT_SONNET_MODEL,
+        env.ANTHROPIC_DEFAULT_HAIKU_MODEL,
+    ].filter((m) => Boolean(m));
+    return {
+        protocol: "anthropic",
+        baseUrl: env.ANTHROPIC_BASE_URL,
+        apiKey: env.ANTHROPIC_AUTH_TOKEN || env.ANTHROPIC_API_KEY || undefined,
+        models: [...new Set(models)],
+        defaultModel: models[0],
+    };
+}
+/** Codex rows: `settings_config.config` is literal `config.toml` text, the key rides in `auth`. */
+function fromCodexShape(settings) {
+    const text = typeof settings.config === "string" ? settings.config : "";
+    if (!text)
+        return undefined;
+    let config;
+    try {
+        config = parseToml(text);
+    }
+    catch {
+        return undefined;
+    }
+    const providers = config.model_providers;
+    const active = typeof config.model_provider === "string" ? config.model_provider : undefined;
+    const entry = (active ? providers?.[active] : undefined) ?? Object.values(providers ?? {})[0];
+    if (!entry || typeof entry.base_url !== "string")
+        return undefined;
+    const model = typeof config.model === "string" ? config.model : undefined;
+    const auth = settings.auth;
+    return {
+        protocol: "openai",
+        // codex speaks the Responses API; only a legacy row still says "chat"
+        openaiApi: entry.wire_api === "chat" ? "completions" : "responses",
+        baseUrl: entry.base_url,
+        apiKey: auth?.OPENAI_API_KEY || undefined,
+        models: model ? [model] : [],
+        defaultModel: model,
+    };
+}
+/** opencode / OpenClaw / Hermes / pi rows carry the pi-family `api` + `baseUrl` + `models` shape. */
+function fromPiShape(settings, meta) {
+    if (typeof settings.baseUrl !== "string" || !settings.baseUrl)
+        return undefined;
+    const wire = classifyApi(settings.api) ?? (meta.apiFormat === "anthropic" ? { protocol: "anthropic" } : undefined);
+    if (!wire)
+        return undefined;
+    const models = Array.isArray(settings.models)
+        ? settings.models.map((m) => (typeof m?.id === "string" ? m.id : "")).filter(Boolean)
+        : [];
+    return {
+        protocol: wire.protocol,
+        openaiApi: wire.openaiApi,
+        baseUrl: settings.baseUrl,
+        apiKey: typeof settings.apiKey === "string" && settings.apiKey ? settings.apiKey : undefined,
+        models,
+        defaultModel: typeof settings.model === "string" ? settings.model : models[0],
+    };
+}
+/**
+ * Load `node:sqlite`, swallowing the one-off "SQLite is an experimental feature"
+ * warning it emits asynchronously on load: that this reader uses the built-in
+ * driver is an implementation detail, not something an `import` run should shout
+ * about. Every other warning is handed straight back to Node's own printer.
+ */
+function requireSqlite() {
+    const printers = process.listeners("warning");
+    process.removeAllListeners("warning");
+    process.on("warning", (warning) => {
+        if (warning.name === "ExperimentalWarning" && /sqlite/i.test(warning.message))
+            return;
+        for (const printer of printers)
+            printer(warning);
+    });
+    return createRequire(import.meta.url)("node:sqlite");
+}
+/**
+ * Read cc-switch's provider store so a user of the desktop app does not have to
+ * re-enter anything. The database is opened read-only and nothing is ever written
+ * back; a store this build cannot read (no `node:sqlite`, a newer schema, a locked
+ * file) yields no candidates instead of failing the whole scan.
+ */
+export function ccSwitchCandidates() {
+    if (!fs.existsSync(storeFile))
+        return [];
+    let rows;
+    try {
+        const db = new (requireSqlite().DatabaseSync)(storeFile, { readOnly: true });
+        try {
+            rows = db.prepare("SELECT app_type, name, settings_config, meta FROM providers").all();
+        }
+        finally {
+            db.close();
+        }
+    }
+    catch {
+        return [];
+    }
+    const out = [];
+    for (const row of rows) {
+        let settings;
+        let meta;
+        try {
+            settings = JSON.parse(row.settings_config || "{}");
+            meta = JSON.parse(row.meta || "{}");
+        }
+        catch {
+            continue;
+        }
+        // Rows are matched by shape rather than by app name, so an app cc-switch adds
+        // later still imports as long as it stores one of these three layouts.
+        const parsed = fromEnvShape(settings) ?? fromCodexShape(settings) ?? fromPiShape(settings, meta);
+        if (!parsed)
+            continue;
+        const name = row.name || row.app_type;
+        // cc-switch ids are UUIDs; the display name is what the user recognizes.
+        const slug = name.toLowerCase().replace(/[^a-z0-9_-]+/g, "-").replace(/^[-_]+|[-_]+$/g, "");
+        out.push({
+            id: /^[a-z0-9]/.test(slug) ? slug : slugFromBaseUrl(parsed.baseUrl),
+            name,
+            protocol: parsed.protocol,
+            ...(parsed.openaiApi ? { openaiApi: parsed.openaiApi } : {}),
+            baseUrl: parsed.baseUrl,
+            apiKey: parsed.apiKey,
+            models: parsed.models,
+            defaultModel: parsed.defaultModel,
+            source: CC_SWITCH_SOURCE,
+        });
+    }
+    return out;
+}

package/dist/store.js

@@ -0,0 +1,23 @@
+import path from "node:path";
+import { home, readJsonIfExists, writeFileAtomic } from "./fsutil.js";
+export const configDir = path.join(home, ".config", "agentsw");
+export const configFile = path.join(configDir, "config.json");
+export function loadStore() {
+    const store = readJsonIfExists(configFile);
+    if (!store)
+        return { version: 1, providers: {} };
+    if (!store.providers)
+        store.providers = {};
+    return store;
+}
+export function saveStore(store) {
+    writeFileAtomic(configFile, JSON.stringify(store, null, 2) + "\n", 0o600);
+}
+export function getProvider(store, id) {
+    const p = store.providers[id];
+    if (!p) {
+        const known = Object.keys(store.providers);
+        throw new Error(`unknown provider "${id}"${known.length ? ` (known: ${known.join(", ")})` : " (none configured; run: agentsw add)"}`);
+    }
+    return p;
+}

package/dist/targets/claudecode.js

@@ -0,0 +1,96 @@
+import fs from "node:fs";
+import path from "node:path";
+import { backupFile, home, readJsonIfExists, writeFileAtomic } from "../fsutil.js";
+import { slugFromBaseUrl } from "../slug.js";
+const dir = path.join(home, ".claude");
+const settingsFile = path.join(dir, "settings.json");
+/**
+ * Claude Code reads Anthropic-protocol endpoints via env vars in ~/.claude/settings.json.
+ * We merge the "env" block and leave every other setting untouched.
+ */
+export const claudecode = {
+    id: "claude",
+    name: "Claude Code",
+    protocols: ["anthropic"],
+    configPaths: [settingsFile],
+    detect: () => fs.existsSync(dir),
+    async apply(provider) {
+        const notes = [];
+        const settings = readJsonIfExists(settingsFile) ?? {};
+        const env = { ...settings.env };
+        env.ANTHROPIC_BASE_URL = provider.baseUrl;
+        env.ANTHROPIC_AUTH_TOKEN = provider.apiKey;
+        delete env.ANTHROPIC_API_KEY; // AUTH_TOKEN and API_KEY conflict; keep one
+        env.ANTHROPIC_MODEL = provider.defaultModel;
+        env.ANTHROPIC_DEFAULT_OPUS_MODEL = provider.defaultModel;
+        env.ANTHROPIC_DEFAULT_SONNET_MODEL = provider.defaultModel;
+        env.ANTHROPIC_REASONING_MODEL = provider.defaultModel;
+        const small = provider.smallModel ?? provider.defaultModel;
+        env.ANTHROPIC_DEFAULT_HAIKU_MODEL = small;
+        env.ANTHROPIC_SMALL_FAST_MODEL = small;
+        settings.env = env;
+        const backup = backupFile(settingsFile);
+        if (backup)
+            notes.push(`backup: ${backup}`);
+        writeFileAtomic(settingsFile, JSON.stringify(settings, null, 2) + "\n");
+        return { app: this.id, changed: [settingsFile], notes };
+    },
+    async prune(provider) {
+        const settings = readJsonIfExists(settingsFile);
+        const env = settings?.env;
+        if (!settings || !env || env.ANTHROPIC_BASE_URL !== provider.baseUrl) {
+            return { app: this.id, changed: [], notes: [], skipped: "claude env does not point at this provider" };
+        }
+        for (const key of [
+            "ANTHROPIC_BASE_URL",
+            "ANTHROPIC_AUTH_TOKEN",
+            "ANTHROPIC_MODEL",
+            "ANTHROPIC_DEFAULT_OPUS_MODEL",
+            "ANTHROPIC_DEFAULT_SONNET_MODEL",
+            "ANTHROPIC_DEFAULT_HAIKU_MODEL",
+            "ANTHROPIC_REASONING_MODEL",
+            "ANTHROPIC_SMALL_FAST_MODEL",
+        ]) {
+            delete env[key];
+        }
+        const notes = [];
+        const backup = backupFile(settingsFile);
+        if (backup)
+            notes.push(`backup: ${backup}`);
+        writeFileAtomic(settingsFile, JSON.stringify(settings, null, 2) + "\n");
+        return { app: this.id, changed: [settingsFile], notes };
+    },
+    current() {
+        const env = readJsonIfExists(settingsFile)?.env;
+        if (!env?.ANTHROPIC_BASE_URL)
+            return undefined;
+        return `${env.ANTHROPIC_BASE_URL} · ${env.ANTHROPIC_MODEL ?? "?"}`;
+    },
+    candidates() {
+        const env = readJsonIfExists(settingsFile)?.env;
+        const baseUrl = env?.ANTHROPIC_BASE_URL;
+        if (!baseUrl)
+            return [];
+        const models = [
+            env.ANTHROPIC_MODEL,
+            env.ANTHROPIC_DEFAULT_OPUS_MODEL,
+            env.ANTHROPIC_DEFAULT_SONNET_MODEL,
+            env.ANTHROPIC_DEFAULT_HAIKU_MODEL,
+            env.ANTHROPIC_REASONING_MODEL,
+            env.ANTHROPIC_SMALL_FAST_MODEL,
+        ].filter((m) => !!m);
+        const id = slugFromBaseUrl(baseUrl);
+        return [
+            {
+                id,
+                name: id,
+                protocol: "anthropic",
+                baseUrl,
+                apiKey: env.ANTHROPIC_AUTH_TOKEN || env.ANTHROPIC_API_KEY || undefined,
+                models: [...new Set(models)],
+                defaultModel: env.ANTHROPIC_MODEL,
+                source: this.id,
+            },
+        ];
+    },
+};