@nvae/llmswitch 0.2.0

package/dist/utils/base-url.js

@@ -0,0 +1,40 @@
+export function isOpenAiApiFormat(format) {
+    return format === "openai-chat" || format === "openai-responses";
+}
+/**
+ * Ensure an OpenAI-compatible base URL ends with exactly one `/v1`
+ * (no trailing slash after it).
+ *
+ * Examples:
+ * - `http://host:8000` → `http://host:8000/v1`
+ * - `http://host:8000/` → `http://host:8000/v1`
+ * - `http://host:8000/v1` → `http://host:8000/v1`
+ * - `http://host:8000/v1/` → `http://host:8000/v1`
+ * - `http://host:8000/v1/v1` → `http://host:8000/v1`
+ * - `https://api.openai.com/v1/v1/` → `https://api.openai.com/v1`
+ */
+export function ensureOpenAiV1BaseUrl(baseUrl) {
+    let base = baseUrl.trim();
+    if (!base)
+        return base;
+    base = base.replace(/\/+$/, "");
+    while (/\/v1$/i.test(base)) {
+        base = base.replace(/\/v1$/i, "").replace(/\/+$/, "");
+    }
+    if (!base)
+        return "/v1";
+    return `${base}/v1`;
+}
+/**
+ * Normalize base URL for the given API format.
+ * OpenAI formats always get a single trailing `/v1`; others only trim trailing slashes.
+ */
+export function normalizeBaseUrlForFormat(apiFormat, baseUrl) {
+    const trimmed = baseUrl.trim().replace(/\/+$/, "");
+    if (!trimmed)
+        return trimmed;
+    if (isOpenAiApiFormat(apiFormat)) {
+        return ensureOpenAiV1BaseUrl(trimmed);
+    }
+    return trimmed;
+}

package/dist/utils/fetch-models.js

@@ -0,0 +1,177 @@
+import { emptyProxy } from "../types.js";
+import { normalizeBaseUrlForFormat } from "./base-url.js";
+import { buildProxyEnv } from "./proxy.js";
+/**
+ * Derive the API base URL from a successful .../models endpoint.
+ */
+export function baseUrlFromModelsEndpoint(endpoint) {
+    const cleaned = endpoint.trim().replace(/\/+$/, "");
+    const match = cleaned.match(/^(.*)\/models$/i);
+    return match?.[1] || null;
+}
+/**
+ * Prefer the base URL that actually served /models when it differs from input.
+ * Common case: user enters http://host:8000 but only /v1/models works.
+ */
+export function preferResolvedBaseUrl(inputBaseUrl, resolvedBaseUrl) {
+    const input = inputBaseUrl.trim().replace(/\/+$/, "");
+    const resolved = (resolvedBaseUrl || "").trim().replace(/\/+$/, "");
+    if (!resolved)
+        return input;
+    if (resolved === input)
+        return input;
+    return resolved;
+}
+/**
+ * Resolve candidate /models URLs for a provider base URL.
+ */
+export function modelListEndpoints(baseUrl) {
+    const base = baseUrl.trim().replace(/\/+$/, "");
+    const endpoints = [];
+    const add = (url) => {
+        if (!endpoints.includes(url))
+            endpoints.push(url);
+    };
+    if (/\/v1$/i.test(base)) {
+        add(`${base}/models`);
+    }
+    else {
+        add(`${base}/models`);
+        add(`${base}/v1/models`);
+    }
+    // Common gateway: .../anthropic → also try sibling /v1/models
+    if (/\/anthropic$/i.test(base)) {
+        add(`${base.replace(/\/anthropic$/i, "")}/v1/models`);
+    }
+    return endpoints;
+}
+export function buildModelsRequestHeaders(apiFormat, apiKey) {
+    const headers = {
+        Accept: "application/json",
+    };
+    if (!apiKey)
+        return headers;
+    if (apiFormat === "anthropic") {
+        headers["x-api-key"] = apiKey;
+        headers["anthropic-version"] = "2023-06-01";
+        // Some gateways also accept Bearer
+        headers.Authorization = `Bearer ${apiKey}`;
+    }
+    else {
+        headers.Authorization = `Bearer ${apiKey}`;
+    }
+    return headers;
+}
+export function parseModelIds(payload) {
+    if (!payload || typeof payload !== "object")
+        return [];
+    const root = payload;
+    const buckets = [];
+    if (Array.isArray(root.data))
+        buckets.push(...root.data);
+    if (Array.isArray(root.models))
+        buckets.push(...root.models);
+    if (Array.isArray(payload))
+        buckets.push(...payload);
+    const ids = new Set();
+    for (const item of buckets) {
+        if (typeof item === "string" && item.trim()) {
+            ids.add(item.trim());
+            continue;
+        }
+        if (!item || typeof item !== "object")
+            continue;
+        const row = item;
+        const id = row.id ?? row.name ?? row.model;
+        if (typeof id === "string" && id.trim())
+            ids.add(id.trim());
+    }
+    return Array.from(ids).sort((a, b) => a.localeCompare(b));
+}
+/**
+ * Fetch available model IDs from the provider using baseUrl + apiKey.
+ * Tries several common /models paths; uses proxy env when configured.
+ */
+export async function fetchModelList(options) {
+    const { baseUrl, apiKey, apiFormat, proxy, timeoutMs = 20_000 } = options;
+    if (!baseUrl?.trim()) {
+        throw new Error("Base URL 为空，无法拉取模型列表");
+    }
+    if (!apiKey?.trim()) {
+        throw new Error("API Key 为空，无法拉取模型列表");
+    }
+    const effectiveBaseUrl = normalizeBaseUrlForFormat(apiFormat, baseUrl);
+    const endpoints = modelListEndpoints(effectiveBaseUrl);
+    const headers = buildModelsRequestHeaders(apiFormat, apiKey.trim());
+    const restore = applyProxyEnv(proxy);
+    const errors = [];
+    try {
+        for (const endpoint of endpoints) {
+            try {
+                const models = await requestModels(endpoint, headers, timeoutMs);
+                if (models.length > 0) {
+                    const resolvedBaseUrl = baseUrlFromModelsEndpoint(endpoint) || effectiveBaseUrl;
+                    return {
+                        models,
+                        endpoint,
+                        resolvedBaseUrl: normalizeBaseUrlForFormat(apiFormat, resolvedBaseUrl),
+                    };
+                }
+                errors.push(`${endpoint} → 返回空列表`);
+            }
+            catch (err) {
+                const msg = err instanceof Error ? err.message : String(err);
+                errors.push(`${endpoint} → ${msg}`);
+            }
+        }
+    }
+    finally {
+        restore();
+    }
+    throw new Error(`无法从接口拉取模型列表。\n${errors.map((e) => `  - ${e}`).join("\n")}`);
+}
+async function requestModels(endpoint, headers, timeoutMs) {
+    const controller = new AbortController();
+    const timer = setTimeout(() => controller.abort(), timeoutMs);
+    try {
+        const res = await fetch(endpoint, {
+            method: "GET",
+            headers,
+            signal: controller.signal,
+        });
+        if (!res.ok) {
+            const body = (await res.text().catch(() => "")).slice(0, 200);
+            throw new Error(`HTTP ${res.status}${body ? `: ${body}` : ""}`);
+        }
+        const json = await res.json();
+        return parseModelIds(json);
+    }
+    catch (err) {
+        if (err instanceof Error && err.name === "AbortError") {
+            throw new Error(`请求超时（${timeoutMs}ms）`);
+        }
+        throw err;
+    }
+    finally {
+        clearTimeout(timer);
+    }
+}
+function applyProxyEnv(proxy) {
+    if (emptyProxy(proxy))
+        return () => undefined;
+    const next = buildProxyEnv(proxy);
+    const keys = Object.keys(next);
+    const backup = new Map();
+    for (const key of keys) {
+        backup.set(key, process.env[key]);
+        process.env[key] = next[key];
+    }
+    return () => {
+        for (const [key, value] of backup) {
+            if (value === undefined)
+                delete process.env[key];
+            else
+                process.env[key] = value;
+        }
+    };
+}

package/dist/utils/fs.js

@@ -0,0 +1,40 @@
+import { chmodSync, copyFileSync, existsSync, mkdirSync, renameSync, writeFileSync, } from "node:fs";
+import { dirname, join } from "node:path";
+import { randomBytes } from "node:crypto";
+export function ensureDir(dir) {
+    mkdirSync(dir, { recursive: true });
+}
+export function atomicWriteFile(filePath, content, mode = 0o600) {
+    ensureDir(dirname(filePath));
+    const tmp = join(dirname(filePath), `.${randomBytes(8).toString("hex")}.tmp`);
+    writeFileSync(tmp, content, { encoding: "utf8", mode });
+    try {
+        chmodSync(tmp, mode);
+    }
+    catch {
+        // Windows may ignore mode; continue.
+    }
+    renameSync(tmp, filePath);
+    try {
+        chmodSync(filePath, mode);
+    }
+    catch {
+        // ignore
+    }
+}
+export function backupFile(sourcePath, backupDir, label) {
+    if (!existsSync(sourcePath))
+        return undefined;
+    ensureDir(backupDir);
+    const stamp = new Date().toISOString().replace(/[:.]/g, "-");
+    const dest = join(backupDir, `${label}-${stamp}.bak`);
+    copyFileSync(sourcePath, dest);
+    return dest;
+}
+export function maskSecret(value) {
+    if (!value)
+        return "(empty)";
+    if (value.length <= 8)
+        return "****";
+    return `${value.slice(0, 4)}…${value.slice(-4)}`;
+}

package/dist/utils/paths.js

@@ -0,0 +1,67 @@
+import { homedir, platform } from "node:os";
+import { join } from "node:path";
+export function getAppConfigRoot() {
+    if (process.env.LLM_SWITCH_HOME) {
+        return process.env.LLM_SWITCH_HOME;
+    }
+    if (platform() === "win32") {
+        const base = process.env.APPDATA || join(homedir(), "AppData", "Roaming");
+        return join(base, "llm-switch");
+    }
+    const xdg = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+    return join(xdg, "llm-switch");
+}
+export function getToolStoreDir(tool) {
+    return join(getAppConfigRoot(), tool);
+}
+export function getProfilesDir(tool) {
+    return join(getToolStoreDir(tool), "profiles");
+}
+export function getProfilePath(tool, name) {
+    return join(getProfilesDir(tool), `${name}.json`);
+}
+export function getStatePath(tool) {
+    return join(getToolStoreDir(tool), "state.json");
+}
+export function getBackupsDir(tool) {
+    return join(getToolStoreDir(tool), "backups");
+}
+export function getClaudeConfigDir() {
+    return process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+}
+export function getClaudeSettingsPath() {
+    return join(getClaudeConfigDir(), "settings.json");
+}
+export function getCodexHome() {
+    return process.env.CODEX_HOME || join(homedir(), ".codex");
+}
+export function getCodexConfigPath() {
+    return join(getCodexHome(), "config.toml");
+}
+export function getCodexAuthPath() {
+    return join(getCodexHome(), "auth.json");
+}
+export function getCodexEnvPath() {
+    return join(getCodexHome(), ".env");
+}
+export function getOpenCodeConfigDir() {
+    if (process.env.OPENCODE_CONFIG_DIR) {
+        return process.env.OPENCODE_CONFIG_DIR;
+    }
+    const xdg = process.env.XDG_CONFIG_HOME || join(homedir(), ".config");
+    return join(xdg, "opencode");
+}
+export function getOpenCodeConfigPath() {
+    return join(getOpenCodeConfigDir(), "opencode.json");
+}
+export function getOpenCodeAuthPath() {
+    if (process.env.OPENCODE_DATA_DIR) {
+        return join(process.env.OPENCODE_DATA_DIR, "auth.json");
+    }
+    if (platform() === "win32") {
+        const base = process.env.LOCALAPPDATA || join(homedir(), "AppData", "Local");
+        return join(base, "opencode", "auth.json");
+    }
+    const data = process.env.XDG_DATA_HOME || join(homedir(), ".local", "share");
+    return join(data, "opencode", "auth.json");
+}

package/dist/utils/proxy.js

@@ -0,0 +1,68 @@
+import { emptyProxy } from "../types.js";
+export const PROXY_ENV_KEYS = [
+    "HTTP_PROXY",
+    "HTTPS_PROXY",
+    "ALL_PROXY",
+    "http_proxy",
+    "https_proxy",
+    "all_proxy",
+];
+/**
+ * Build proxy env vars for injection into tool configs.
+ * Prefer explicit http/https; when only `all` is set (e.g. socks5h),
+ * set ALL_PROXY (and lowercase) and also mirror to HTTP(S)_PROXY
+ * so runtimes that only read those still attempt the proxy URL.
+ */
+export function buildProxyEnv(proxy) {
+    if (emptyProxy(proxy))
+        return {};
+    const env = {};
+    const http = proxy.http?.trim();
+    const https = proxy.https?.trim();
+    const all = proxy.all?.trim();
+    if (all) {
+        env.ALL_PROXY = all;
+        env.all_proxy = all;
+    }
+    if (http) {
+        env.HTTP_PROXY = http;
+        env.http_proxy = http;
+    }
+    else if (all) {
+        env.HTTP_PROXY = all;
+        env.http_proxy = all;
+    }
+    if (https) {
+        env.HTTPS_PROXY = https;
+        env.https_proxy = https;
+    }
+    else if (all) {
+        env.HTTPS_PROXY = all;
+        env.https_proxy = all;
+    }
+    return env;
+}
+export function clearProxyEnvKeys(env) {
+    for (const key of PROXY_ENV_KEYS) {
+        delete env[key];
+    }
+}
+export function applyProxyToEnvRecord(env, proxy) {
+    clearProxyEnvKeys(env);
+    const next = buildProxyEnv(proxy);
+    for (const [k, v] of Object.entries(next)) {
+        env[k] = v;
+    }
+}
+export function formatProxySummary(proxy) {
+    if (emptyProxy(proxy))
+        return "(none)";
+    const parts = [];
+    if (proxy?.http)
+        parts.push(`http=${proxy.http}`);
+    if (proxy?.https)
+        parts.push(`https=${proxy.https}`);
+    if (proxy?.all)
+        parts.push(`all=${proxy.all}`);
+    return parts.join(", ");
+}

package/package.json

@@ -0,0 +1,49 @@
+{
+  "name": "@nvae/llmswitch",
+  "version": "0.2.0",
+  "description": "CLI to switch LLM providers and models for Claude Code, Codex, and OpenCode",
+  "type": "module",
+  "bin": {
+    "llms": "dist/index.js",
+    "llm-switch": "dist/index.js"
+  },
+  "files": [
+    "dist",
+    "README.md",
+    "LICENSE"
+  ],
+  "scripts": {
+    "build": "tsc -p tsconfig.build.json",
+    "dev": "bun run ./src/index.ts",
+    "start": "bun run ./src/index.ts",
+    "test": "bun test",
+    "typecheck": "tsc -p tsconfig.json --noEmit",
+    "prepublishOnly": "bun run typecheck && bun run build"
+  },
+  "engines": {
+    "node": ">=20"
+  },
+  "publishConfig": {
+    "access": "public"
+  },
+  "keywords": [
+    "cli",
+    "llm",
+    "claude-code",
+    "codex",
+    "opencode",
+    "provider",
+    "model-switch"
+  ],
+  "license": "MIT",
+  "dependencies": {
+    "@clack/prompts": "^0.11.0",
+    "commander": "^14.0.0",
+    "smol-toml": "^1.4.2"
+  },
+  "devDependencies": {
+    "@types/bun": "^1.2.19",
+    "@types/node": "^24.0.0",
+    "typescript": "^5.8.3"
+  }
+}