@nvae/llmswitch 0.2.0 → 0.5.0

package/dist/bridge/transport.js

@@ -0,0 +1,439 @@
+import { Buffer } from "node:buffer";
+import { request as httpRequest } from "node:http";
+import { request as httpsRequest } from "node:https";
+import { HttpsProxyAgent } from "https-proxy-agent";
+import { SocksProxyAgent } from "socks-proxy-agent";
+const SUPPORTED_TARGET_PROTOCOLS = new Set(["http:", "https:"]);
+const SUPPORTED_PROXY_PROTOCOLS = new Set([
+    "http:",
+    "https:",
+    "socks:",
+    "socks4:",
+    "socks4a:",
+    "socks5:",
+    "socks5h:",
+]);
+/** Hop-by-hop and inbound-credential headers never forwarded upstream. */
+const STRIPPED_REQUEST_HEADERS = new Set([
+    "connection",
+    "keep-alive",
+    "proxy-authenticate",
+    "proxy-authorization",
+    "te",
+    "trailer",
+    "transfer-encoding",
+    "upgrade",
+    "host",
+    "content-length",
+]);
+const DEFAULT_CONNECT_TIMEOUT_MS = 30_000;
+const DEFAULT_IDLE_TIMEOUT_MS = 90_000;
+const DEFAULT_TOTAL_TIMEOUT_MS = 600_000;
+const DEFAULT_MAX_REDIRECTS = 5;
+export class TransportTimeoutError extends Error {
+    constructor(message = "上游请求超时") {
+        super(message);
+        this.name = "TransportTimeoutError";
+    }
+}
+export class ResponseLimitError extends Error {
+    constructor(message = "上游响应超出大小限制") {
+        super(message);
+        this.name = "ResponseLimitError";
+    }
+}
+export class CrossOriginRedirectError extends Error {
+    constructor(message = "拒绝跨源 redirect") {
+        super(message);
+        this.name = "CrossOriginRedirectError";
+    }
+}
+export class TransportProtocolError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "TransportProtocolError";
+    }
+}
+/**
+ * Resolve the proxy URL for a target. A profile has a single proxy applied to
+ * all traffic; the URL scheme (http/https/socks*) selects the agent.
+ */
+export function selectProxyUrl(_target, proxy) {
+    const chosen = proxy?.trim();
+    return chosen || null;
+}
+/**
+ * Build a fresh per-request Agent for the given proxy URL. Callers own its
+ * lifecycle and must call `.destroy()` once the response is drained.
+ */
+export function createTransportAgent(_target, proxyUrl) {
+    let proxy;
+    try {
+        proxy = new URL(proxyUrl);
+    }
+    catch {
+        throw new TransportProtocolError(`无效的 proxy URL: ${proxyUrl}`);
+    }
+    if (!SUPPORTED_PROXY_PROTOCOLS.has(proxy.protocol)) {
+        throw new TransportProtocolError(`不支持的 proxy protocol: ${proxy.protocol}`);
+    }
+    if (proxy.protocol === "http:" || proxy.protocol === "https:") {
+        return new HttpsProxyAgent(proxy);
+    }
+    // socks5 resolves DNS locally; socks5h/socks4a defer to the proxy.
+    return new SocksProxyAgent(proxy);
+}
+function sanitizeHeaders(headers) {
+    const out = {};
+    if (!headers)
+        return out;
+    for (const [key, value] of Object.entries(headers)) {
+        if (value === undefined)
+            continue;
+        if (STRIPPED_REQUEST_HEADERS.has(key.toLowerCase()))
+            continue;
+        out[key] = value;
+    }
+    return out;
+}
+function isSameOrigin(a, b) {
+    return (a.protocol === b.protocol && a.hostname === b.hostname && a.port === b.port);
+}
+/**
+ * A Web-`Response`-like view. Consume the body exactly once: either as a
+ * stream (`body`) for SSE pass-through, or buffered (`text`/`json`/
+ * `arrayBuffer`) with the response size limit enforced. Both paths re-arm the
+ * idle timer, and finalize timers/abort listener/proxy Agent on completion.
+ */
+class NodeTransportResponse {
+    status;
+    statusText;
+    headers;
+    ctx;
+    consumed = false;
+    pendingFatal = null;
+    failSink = null;
+    constructor(status, statusText, headers, ctx) {
+        this.status = status;
+        this.statusText = statusText;
+        this.headers = headers;
+        this.ctx = ctx;
+    }
+    get ok() {
+        return this.status >= 200 && this.status < 300;
+    }
+    /** Routes a fatal condition (idle/total timeout, abort) to the active consumer. */
+    fail(err) {
+        if (this.failSink)
+            this.failSink(err);
+        else
+            this.pendingFatal = err;
+    }
+    get body() {
+        if (this.consumed)
+            return null;
+        this.consumed = true;
+        const ctx = this.ctx;
+        const { res } = ctx;
+        return new ReadableStream({
+            start: (controller) => {
+                let closed = false;
+                const stop = (err) => {
+                    if (closed)
+                        return;
+                    closed = true;
+                    ctx.finalize();
+                    if (err) {
+                        res.destroy();
+                        try {
+                            controller.error(err);
+                        }
+                        catch {
+                            // already errored
+                        }
+                    }
+                    else {
+                        try {
+                            controller.close();
+                        }
+                        catch {
+                            // already closed
+                        }
+                    }
+                };
+                this.failSink = (err) => stop(err);
+                if (this.pendingFatal) {
+                    stop(this.pendingFatal);
+                    return;
+                }
+                res.on("data", (chunk) => {
+                    ctx.armIdle();
+                    controller.enqueue(new Uint8Array(chunk));
+                });
+                res.on("end", () => stop(null));
+                res.on("error", (err) => stop(err));
+                res.on("aborted", () => stop(new TransportTimeoutError("上游连接中断")));
+                res.resume();
+            },
+            cancel: () => {
+                ctx.finalize();
+                res.destroy();
+            },
+        });
+    }
+    buffered() {
+        if (this.consumed) {
+            return Promise.reject(new Error("响应 body 已被消费"));
+        }
+        this.consumed = true;
+        const ctx = this.ctx;
+        const { res } = ctx;
+        const max = ctx.maxResponseBytes;
+        return new Promise((resolve, reject) => {
+            const chunks = [];
+            let total = 0;
+            let done = false;
+            const finish = (err, buf) => {
+                if (done)
+                    return;
+                done = true;
+                ctx.finalize();
+                if (err) {
+                    res.destroy();
+                    reject(err);
+                }
+                else {
+                    resolve(buf ?? Buffer.concat(chunks));
+                }
+            };
+            this.failSink = (err) => finish(err);
+            if (this.pendingFatal) {
+                finish(this.pendingFatal);
+                return;
+            }
+            res.on("data", (chunk) => {
+                ctx.armIdle();
+                total += chunk.byteLength;
+                if (max !== undefined && total > max) {
+                    finish(new ResponseLimitError());
+                    return;
+                }
+                chunks.push(chunk);
+            });
+            res.on("end", () => finish(null, Buffer.concat(chunks)));
+            res.on("error", (err) => finish(err));
+            res.on("aborted", () => finish(new TransportTimeoutError("上游连接中断")));
+            res.resume();
+        });
+    }
+    async arrayBuffer() {
+        const buf = await this.buffered();
+        return buf.buffer.slice(buf.byteOffset, buf.byteOffset + buf.byteLength);
+    }
+    async text() {
+        return (await this.buffered()).toString("utf8");
+    }
+    async json() {
+        return JSON.parse(await this.text());
+    }
+}
+export async function requestWithNodeTransport(options) {
+    const maxRedirects = options.maxRedirects ?? DEFAULT_MAX_REDIRECTS;
+    const origin = parseTarget(options.url);
+    let current = origin;
+    for (let redirects = 0;; redirects += 1) {
+        const result = await performRequest(current, options);
+        if (result.type === "redirect" &&
+            redirects < maxRedirects &&
+            result.location) {
+            const next = parseTarget(new URL(result.location, current).toString());
+            if (!isSameOrigin(next, origin)) {
+                throw new CrossOriginRedirectError(`拒绝跨源 redirect: ${current.origin} → ${next.origin}`);
+            }
+            current = next;
+            continue;
+        }
+        if (result.type === "redirect" && redirects >= maxRedirects) {
+            throw new TransportProtocolError("redirect 次数超过上限");
+        }
+        return result.response;
+    }
+}
+function parseTarget(url) {
+    let target;
+    try {
+        target = new URL(url);
+    }
+    catch {
+        throw new TransportProtocolError(`无效的目标 URL: ${url}`);
+    }
+    if (!SUPPORTED_TARGET_PROTOCOLS.has(target.protocol)) {
+        throw new TransportProtocolError(`不支持的 target protocol: ${target.protocol}`);
+    }
+    return target;
+}
+function performRequest(target, options) {
+    const proxyUrl = selectProxyUrl(target, options.proxy);
+    const agent = proxyUrl ? createTransportAgent(target, proxyUrl) : undefined;
+    const isHttps = target.protocol === "https:";
+    const requestImpl = isHttps ? httpsRequest : httpRequest;
+    const connectTimeoutMs = options.connectTimeoutMs ?? DEFAULT_CONNECT_TIMEOUT_MS;
+    const idleTimeoutMs = options.idleTimeoutMs ?? DEFAULT_IDLE_TIMEOUT_MS;
+    const totalTimeoutMs = options.totalTimeoutMs ?? DEFAULT_TOTAL_TIMEOUT_MS;
+    const maxResponseBytes = options.maxResponseBytes;
+    const headers = sanitizeHeaders(options.headers);
+    const bodyBuffer = normalizeBody(options.body);
+    if (bodyBuffer) {
+        headers["Content-Length"] = String(bodyBuffer.byteLength);
+    }
+    return new Promise((resolve, reject) => {
+        let settled = false;
+        let req = null;
+        const timers = new Set();
+        // Set once headers arrive; routes body-phase failures to the body reader.
+        let bodyController = null;
+        const timerBag = {
+            clearAll() {
+                for (const timer of timers)
+                    clearTimeout(timer);
+                timers.clear();
+            },
+        };
+        const cleanupAgent = () => {
+            if (agent && typeof agent.destroy === "function") {
+                agent.destroy();
+            }
+        };
+        const fail = (err) => {
+            if (settled)
+                return;
+            settled = true;
+            timerBag.clearAll();
+            if (options.signal)
+                options.signal.removeEventListener("abort", onAbort);
+            req?.destroy();
+            cleanupAgent();
+            reject(err);
+        };
+        // Fatal condition (timeout/abort): before headers reject the request
+        // promise; during the body phase reject the body reader instead.
+        const onFatal = (err) => {
+            if (bodyController)
+                bodyController.fail(err);
+            else
+                fail(err);
+        };
+        const onAbort = () => {
+            const reason = options.signal?.reason instanceof Error
+                ? options.signal.reason
+                : abortError();
+            onFatal(reason);
+        };
+        if (options.signal) {
+            if (options.signal.aborted) {
+                cleanupAgent();
+                reject(abortError());
+                return;
+            }
+            options.signal.addEventListener("abort", onAbort, { once: true });
+        }
+        const totalTimer = setTimeout(() => onFatal(new TransportTimeoutError("上游总超时")), totalTimeoutMs);
+        timers.add(totalTimer);
+        req = requestImpl({
+            protocol: target.protocol,
+            hostname: target.hostname,
+            port: target.port || (isHttps ? 443 : 80),
+            path: `${target.pathname}${target.search}`,
+            method: options.method ?? "GET",
+            headers,
+            agent,
+        }, (res) => {
+            const location = res.headers.location;
+            const status = res.statusCode ?? 0;
+            const isRedirect = status >= 300 && status < 400 && typeof location === "string";
+            if (isRedirect) {
+                // Drain and discard the redirect body, keep the connection tidy.
+                res.resume();
+                if (!settled) {
+                    settled = true;
+                    timerBag.clearAll();
+                    if (options.signal)
+                        options.signal.removeEventListener("abort", onAbort);
+                    cleanupAgent();
+                    const redirectResponse = new NodeTransportResponse(status, res.statusMessage ?? "", toHeaders(res.headers), { res, armIdle: () => undefined, finalize: () => undefined });
+                    resolve({
+                        type: "redirect",
+                        location: location,
+                        response: redirectResponse,
+                    });
+                }
+                return;
+            }
+            // Pause until a consumer (stream or buffered) attaches, so no chunk is
+            // lost between headers and consumption.
+            res.pause();
+            let idleTimer = null;
+            let finalized = false;
+            const armIdle = () => {
+                if (idleTimer) {
+                    clearTimeout(idleTimer);
+                    timers.delete(idleTimer);
+                }
+                idleTimer = setTimeout(() => bodyController?.fail(new TransportTimeoutError("上游空闲超时")), idleTimeoutMs);
+                timers.add(idleTimer);
+            };
+            const finalize = () => {
+                if (finalized)
+                    return;
+                finalized = true;
+                timerBag.clearAll();
+                if (options.signal)
+                    options.signal.removeEventListener("abort", onAbort);
+                cleanupAgent();
+            };
+            const response = new NodeTransportResponse(status, res.statusMessage ?? "", toHeaders(res.headers), { res, maxResponseBytes, armIdle, finalize });
+            bodyController = { fail: (err) => response.fail(err) };
+            armIdle();
+            if (!settled) {
+                settled = true;
+                resolve({ type: "response", response });
+            }
+        });
+        req.setTimeout(connectTimeoutMs, () => {
+            fail(new TransportTimeoutError("上游连接超时"));
+        });
+        req.on("error", (err) => fail(err));
+        if (bodyBuffer)
+            req.write(bodyBuffer);
+        req.end();
+    });
+}
+function normalizeBody(body) {
+    if (body == null)
+        return null;
+    if (Buffer.isBuffer(body))
+        return body;
+    if (typeof body === "string")
+        return Buffer.from(body, "utf8");
+    return Buffer.from(body);
+}
+function toHeaders(raw) {
+    const headers = new Headers();
+    for (const [key, value] of Object.entries(raw)) {
+        if (value === undefined)
+            continue;
+        if (Array.isArray(value)) {
+            for (const item of value)
+                headers.append(key, item);
+        }
+        else {
+            headers.set(key, value);
+        }
+    }
+    return headers;
+}
+function abortError() {
+    const err = new Error("请求已取消");
+    err.name = "AbortError";
+    return err;
+}

package/dist/cli.js

@@ -3,13 +3,16 @@ import { TOOLS } from "./types.js";
 import { registerToolCommand } from "./commands/tool.js";
 import { registerLaunchCommand } from "./commands/launch-cmd.js";
 import { registerBridgeCommand } from "./commands/bridge-cmd.js";
+import { registerSetupCommand } from "./commands/setup-cmd.js";
+import { registerHomeCommand } from "./commands/home-cmd.js";
 import { getAppConfigRoot } from "./utils/paths.js";
+import { getVersion } from "./utils/version.js";
 export function createProgram() {
     const program = new Command();
     program
         .name("llms")
         .description("为 Claude Code / Codex / OpenCode 切换供应商、模型与上游代理")
-        .version("0.2.0")
+        .version(getVersion())
         .option("--json", "部分命令支持 JSON 输出（见子命令）");
     program
         .command("path")
@@ -19,12 +22,15 @@ export function createProgram() {
     });
     registerLaunchCommand(program);
     registerBridgeCommand(program);
+    registerSetupCommand(program);
     for (const tool of TOOLS) {
         registerToolCommand(program, tool);
     }
+    registerHomeCommand(program);
     program.configureOutput({
         writeErr: (str) => process.stderr.write(str),
     });
+    program.addHelpText("afterAll", "\n反馈与建议：rchdg50@gmail.com\nGitHub Issues：https://github.com/rchdg/llmswitch/issues\n");
     return program;
 }
 export async function run(argv = process.argv) {

package/dist/commands/bridge-cmd.js

@@ -1,7 +1,8 @@
-import { ensureBridgeForProfile, isBridgeAlive, isPidRunning, readPid, runBridgeForeground, startBridgeDaemon, stopBridge, upstreamFromProfile, } from "../bridge/manager.js";
-import { bridgeBaseUrl, bridgeRootUrl, readBridgeState, writeBridgeUpstream, } from "../bridge/state.js";
+import { ensureBridgeForProfile, isBridgeAlive, isPidRunning, readPid, runBridgeForeground, startBridgeDaemon, stopBridge, } from "../bridge/manager.js";
+import { bridgeBaseUrl, bridgeRootUrl, readBridgeState, } from "../bridge/state.js";
+import { parseBridgePort } from "../bridge/runtime.js";
 import { DEFAULT_BRIDGE_HOST, DEFAULT_BRIDGE_PORT } from "../bridge/types.js";
-import { getActiveProfile, requireProfile } from "../store/profiles.js";
+import { getActiveProfile, resolveProfileOrThrow } from "../store/profiles.js";
 import { isTool } from "../types.js";
 export function registerBridgeCommand(program) {
     const bridge = program
@@ -12,25 +13,27 @@ export function registerBridgeCommand(program) {
         .description("前台运行 bridge（守护进程由 use/launch 自动拉起）")
         .option("--host <host>", "监听地址", DEFAULT_BRIDGE_HOST)
         .option("--port <port>", "监听端口", String(DEFAULT_BRIDGE_PORT))
+        .option("--allow-remote", "允许非回环监听（仍强制认证和限制）")
         .action(async (opts) => {
-        const port = Number(opts.port) || DEFAULT_BRIDGE_PORT;
-        await runBridgeForeground(opts.host || DEFAULT_BRIDGE_HOST, port);
+        const port = parseBridgePort(opts.port);
+        await runBridgeForeground(opts.host || DEFAULT_BRIDGE_HOST, port, Boolean(opts.allowRemote));
     });
     bridge
         .command("start")
         .description("后台启动 bridge")
         .option("--host <host>", "监听地址", DEFAULT_BRIDGE_HOST)
         .option("--port <port>", "监听端口", String(DEFAULT_BRIDGE_PORT))
+        .option("--allow-remote", "允许非回环监听（仍强制认证和限制）")
         .action(async (opts) => {
         const host = opts.host || DEFAULT_BRIDGE_HOST;
-        const port = Number(opts.port) || DEFAULT_BRIDGE_PORT;
-        const pid = await startBridgeDaemon(host, port);
+        const port = parseBridgePort(opts.port);
+        const pid = await startBridgeDaemon(host, port, Boolean(opts.allowRemote));
         for (let i = 0; i < 30; i++) {
-            if (await isBridgeAlive(host, port))
+            if (await isBridgeAlive())
                 break;
             await new Promise((r) => setTimeout(r, 100));
         }
-        if (!(await isBridgeAlive(host, port))) {
+        if (!(await isBridgeAlive())) {
             throw new Error("bridge 启动失败，请尝试：llms bridge serve");
         }
         console.log(`bridge 已启动 pid=${pid} ${bridgeRootUrl()}`);
@@ -101,13 +104,12 @@ export function registerBridgeCommand(program) {
         }
         const tool = toolName;
         const profile = opts.profile
-            ? requireProfile(tool, opts.profile)
+            ? resolveProfileOrThrow(tool, opts.profile)
             : getActiveProfile(tool);
         if (!profile) {
             throw new Error(`没有可用的 ${tool} profile`);
         }
-        writeBridgeUpstream(tool, upstreamFromProfile(profile, tool));
-        const base = await ensureBridgeForProfile(profile, tool);
-        console.log(`已刷新 ${tool} 上游 ${profile.name} → bridge ${base}`);
+        const connection = await ensureBridgeForProfile(profile, tool);
+        console.log(`已刷新 ${tool} 上游 ${profile.name} → bridge ${connection.baseUrl}`);
     });
 }

package/dist/commands/home-cmd.js

@@ -0,0 +1,8 @@
+import { pickSetupTool, runToolFlow } from "./setup-cmd.js";
+/** 无子命令时：选择工具 → 连贯启动（未配置则自动引导）。 */
+export function registerHomeCommand(program) {
+    program.action(async () => {
+        const tool = await pickSetupTool();
+        await runToolFlow(tool);
+    });
+}

package/dist/commands/launch-cmd.js

@@ -1,5 +1,8 @@
+import * as p from "@clack/prompts";
 import { isTool, TOOLS } from "../types.js";
+import { listProfiles } from "../store/profiles.js";
 import { launchTool, resolveBinary, resolveLaunchTarget, } from "./launch.js";
+import { runSetupWizard } from "./setup-cmd.js";
 /**
  * ollama-like quick start:
  *   llms launch codex --model gpt-4.1
@@ -23,6 +26,21 @@ export function registerLaunchCommand(program) {
         if (!isTool(toolArg)) {
             throw new Error(`未知工具「${toolArg}」。可选：${TOOLS.join(", ")}`);
         }
+        if (listProfiles(toolArg).length === 0 &&
+            process.stdin.isTTY &&
+            !opts.dryRun) {
+            const setup = await p.confirm({
+                message: `${toolArg} 尚未配置供应商，是否进入引导？`,
+                initialValue: true,
+            });
+            if (p.isCancel(setup)) {
+                p.cancel("已取消");
+                process.exit(0);
+            }
+            if (setup) {
+                await runSetupWizard(toolArg);
+            }
+        }
         let model = opts.model?.trim() || undefined;
         const queue = [...parts];
         if (!model && queue[0] && !queue[0].startsWith("-")) {

package/dist/commands/launch.js

@@ -3,7 +3,7 @@ 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";
+import { getActiveProfile, getDefaultProfile, listProfiles, requireProfile, resolveProfileOrThrow, saveProfile, ensureDefaultProvider, } from "../store/profiles.js";
 const BINARY = {
     claude: "claude",
     codex: "codex",
@@ -75,7 +75,7 @@ export function resolveLaunchTarget(tool, opts) {
     const modelQuery = opts.model?.trim() || undefined;
     let profile = null;
     if (opts.profile) {
-        profile = requireProfile(tool, opts.profile);
+        profile = resolveProfileOrThrow(tool, opts.profile);
     }
     if (!profile && modelQuery) {
         profile = findProfileForModel(profiles, modelQuery);