@nvae/llmswitch 0.2.0

package/dist/commands/launch-cmd.js

@@ -0,0 +1,83 @@
+import { isTool, TOOLS } from "../types.js";
+import { launchTool, resolveBinary, resolveLaunchTarget, } from "./launch.js";
+/**
+ * ollama-like quick start:
+ *   llms launch codex --model gpt-4.1
+ *   llms launch codex gpt-4.1
+ *   llms run claude --profile my-provider
+ *   llms launch opencode my-model -- resume
+ */
+export function registerLaunchCommand(program) {
+    program
+        .command("launch")
+        .alias("run")
+        .description("切换模型并启动对应 CLI（类似 ollama run）。例：llms launch codex --model gpt-4.1")
+        .argument("<tool>", `目标工具：${TOOLS.join(" | ")}`)
+        .argument("[parts...]", "可选：模型 ID，以及传给底层 CLI 的参数")
+        .option("-m, --model <id>", "要启用的模型 ID")
+        .option("-p, --profile <name>", "指定 profile（默认：包含该模型的 profile / 当前启用）")
+        .option("--print-only", "只写入配置，不启动 CLI")
+        .option("--dry-run", "只打印计划，不写配置、不启动")
+        .option("--json", "JSON 输出")
+        .action(async (toolArg, parts = [], opts) => {
+        if (!isTool(toolArg)) {
+            throw new Error(`未知工具「${toolArg}」。可选：${TOOLS.join(", ")}`);
+        }
+        let model = opts.model?.trim() || undefined;
+        const queue = [...parts];
+        if (!model && queue[0] && !queue[0].startsWith("-")) {
+            model = queue.shift();
+        }
+        const passthrough = queue;
+        if (opts.dryRun) {
+            const target = resolveLaunchTarget(toolArg, {
+                model,
+                profile: opts.profile,
+            });
+            const plan = {
+                tool: toolArg,
+                profile: target.profile.name,
+                model: target.model,
+                binary: resolveBinary(toolArg),
+                args: passthrough,
+                dryRun: true,
+            };
+            if (opts.json) {
+                console.log(JSON.stringify(plan, null, 2));
+            }
+            else {
+                const argStr = passthrough.length
+                    ? ` ${passthrough.join(" ")}`
+                    : "";
+                console.log(`[dry-run] 启用 ${toolArg}/${plan.profile} → ${plan.model}，然后执行：${plan.binary}${argStr}`);
+            }
+            return;
+        }
+        const plan = await launchTool({
+            tool: toolArg,
+            model,
+            profile: opts.profile,
+            args: passthrough,
+            printOnly: opts.printOnly,
+        });
+        if (opts.json) {
+            console.log(JSON.stringify({
+                tool: plan.tool,
+                profile: plan.profile.name,
+                model: plan.model,
+                binary: plan.binary,
+                args: plan.args,
+                configPath: plan.configPath,
+                applied: plan.applied,
+                printOnly: Boolean(opts.printOnly),
+            }, null, 2));
+            return;
+        }
+        // When actually spawning, launchTool already printed status before exec.
+        if (opts.printOnly) {
+            console.error(`已切换 ${plan.tool}/${plan.profile.name} → ${plan.model}`);
+            console.error(plan.restartHint);
+            console.error(`未启动 CLI（--print-only）。手动运行：${plan.binary}`);
+        }
+    });
+}

package/dist/commands/launch.js

@@ -0,0 +1,175 @@
+import { spawn } from "node:child_process";
+import { existsSync } from "node:fs";
+import { delimiter, join } from "node:path";
+import { isTool } from "../types.js";
+import { applyProfile } from "../adapters/index.js";
+import { getActiveProfile, getDefaultProfile, listProfiles, requireProfile, saveProfile, ensureDefaultProvider, } from "../store/profiles.js";
+const BINARY = {
+    claude: "claude",
+    codex: "codex",
+    opencode: "opencode",
+};
+const BINARY_ENV = {
+    claude: "CLAUDE_BIN",
+    codex: "CODEX_BIN",
+    opencode: "OPENCODE_BIN",
+};
+/**
+ * Resolve profile/model, write tool config, optionally spawn the native CLI.
+ */
+export async function launchTool(options) {
+    if (!isTool(options.tool)) {
+        throw new Error(`未知工具「${options.tool}」。可选：claude、codex、opencode`);
+    }
+    const tool = options.tool;
+    let { profile, model } = resolveLaunchTarget(tool, {
+        model: options.model,
+        profile: options.profile,
+    });
+    if (profile.models.default !== model) {
+        if (!profile.models.list.includes(model)) {
+            profile.models.list.push(model);
+        }
+        profile.models.default = model;
+        saveProfile(tool, profile);
+        profile = requireProfile(tool, profile.name);
+    }
+    else if (!profile.models.list.includes(model)) {
+        profile.models.list.push(model);
+        saveProfile(tool, profile);
+        profile = requireProfile(tool, profile.name);
+    }
+    const result = await applyProfile(tool, profile);
+    const binary = resolveBinary(tool);
+    const args = options.args ?? [];
+    const plan = {
+        tool,
+        profile,
+        model,
+        binary,
+        args,
+        applied: true,
+        configPath: result.configPath,
+        restartHint: result.restartHint,
+    };
+    if (options.dryRun || options.printOnly) {
+        return plan;
+    }
+    const binPath = which(binary);
+    if (!binPath) {
+        throw new Error(`未找到可执行文件「${binary}」。请确认已安装，或设置环境变量 ${BINARY_ENV[tool]}=/path/to/${binary}`);
+    }
+    // Announce before handing over the TTY
+    console.error(`已切换 ${tool}/${profile.name} → ${model}`);
+    console.error(`启动 ${binary}${args.length ? ` ${args.join(" ")}` : ""}`);
+    const code = await spawnInherited(binPath, args);
+    process.exitCode = code ?? 1;
+    return plan;
+}
+export function resolveLaunchTarget(tool, opts) {
+    const profiles = listProfiles(tool);
+    if (profiles.length === 0) {
+        throw new Error(`暂无 ${tool} 供应商，请先：llms ${tool} provider`);
+    }
+    ensureDefaultProvider(tool);
+    const modelQuery = opts.model?.trim() || undefined;
+    let profile = null;
+    if (opts.profile) {
+        profile = requireProfile(tool, opts.profile);
+    }
+    if (!profile && modelQuery) {
+        profile = findProfileForModel(profiles, modelQuery);
+    }
+    if (!profile) {
+        profile = getActiveProfile(tool);
+    }
+    if (!profile) {
+        profile = getDefaultProfile(tool);
+    }
+    if (!profile) {
+        throw new Error(`未指定供应商。请使用 --profile <name>，或先：llms ${tool} provider`);
+    }
+    let model = profile.models.default;
+    if (modelQuery) {
+        const inSelected = matchModel(profile.models.list, modelQuery);
+        if (inSelected) {
+            model = inSelected;
+        }
+        else if (!opts.profile) {
+            const other = findProfileForModel(profiles, modelQuery);
+            if (other) {
+                profile = other;
+                model = matchModel(other.models.list, modelQuery) || modelQuery;
+            }
+            else {
+                model = modelQuery;
+            }
+        }
+        else {
+            model = modelQuery;
+        }
+    }
+    return { profile, model };
+}
+export function findProfileForModel(profiles, query) {
+    for (const profile of profiles) {
+        if (matchModel(profile.models.list, query))
+            return profile;
+    }
+    return null;
+}
+export function matchModel(list, query) {
+    if (list.includes(query))
+        return query;
+    const ci = list.find((m) => m.toLowerCase() === query.toLowerCase());
+    if (ci)
+        return ci;
+    const fuzzy = list.filter((m) => modelFuzzyEqual(m, query));
+    if (fuzzy.length === 0)
+        return null;
+    fuzzy.sort((a, b) => a.length - b.length);
+    return fuzzy[0];
+}
+/** glm5.2 ↔ glm-5.2 ↔ GLM5.2 */
+export function modelFuzzyEqual(a, b) {
+    return normalizeModelId(a) === normalizeModelId(b);
+}
+export function normalizeModelId(id) {
+    return id.toLowerCase().replace(/[_\s./-]+/g, "");
+}
+export function resolveBinary(tool) {
+    const fromEnv = process.env[BINARY_ENV[tool]]?.trim();
+    if (fromEnv)
+        return fromEnv;
+    return BINARY[tool];
+}
+export function which(command) {
+    if (command.includes("/") || command.includes("\\")) {
+        return existsSync(command) ? command : null;
+    }
+    const pathEnv = process.env.PATH || "";
+    for (const dir of pathEnv.split(delimiter)) {
+        if (!dir)
+            continue;
+        const candidate = join(dir, command);
+        if (existsSync(candidate))
+            return candidate;
+        for (const ext of [".cmd", ".exe", ".bat"]) {
+            const win = candidate + ext;
+            if (existsSync(win))
+                return win;
+        }
+    }
+    return null;
+}
+function spawnInherited(binary, args) {
+    return new Promise((resolve, reject) => {
+        const child = spawn(binary, args, {
+            stdio: "inherit",
+            env: process.env,
+            shell: process.platform === "win32",
+        });
+        child.on("error", reject);
+        child.on("close", (code) => resolve(code));
+    });
+}