modelmux-cli 0.0.1 → 0.3.1

package/dist/commands/basic.js

@@ -0,0 +1,72 @@
+/** `modelmux down`, `logs` and `status`. */
+import { existsSync } from "node:fs";
+import { makeContext } from "../context.js";
+import { CliError } from "../errors.js";
+import * as health from "../health.js";
+import { resolveImage, serviceName } from "../stack.js";
+export const NOT_SET_UP = "ModelMux is not set up on this machine yet.";
+export async function down(_args, console) {
+    const ctx = makeContext(console);
+    if (!existsSync(ctx.stack.composeFile)) {
+        console.success("ModelMux is not running.");
+        return 0;
+    }
+    await ctx.stack.compose(["down"], { timeout: 120 });
+    console.success("Stopped ModelMux. Your logins are kept.");
+    return 0;
+}
+export async function logs(args, console) {
+    const ctx = makeContext(console);
+    const stack = ctx.stack;
+    if (!existsSync(stack.composeFile))
+        throw new CliError(NOT_SET_UP, { hint: "Start it with: modelmux up" });
+    const services = args.provider ? [serviceName(ctx.providers.get(args.provider))] : [];
+    const follow = args.follow ? ["--follow"] : [];
+    return ctx.docker.passthrough([
+        "compose", "-p", "modelmux", "-f", stack.composeFile,
+        "logs", args.provider ? "--no-log-prefix" : "--timestamps",
+        "--tail", String(Math.max(args.tail, 0)), ...follow, ...services,
+    ]);
+}
+export async function status(_args, console) {
+    const ctx = makeContext(console);
+    await ctx.docker.checkAvailable();
+    const stack = ctx.stack;
+    const states = await stack.states();
+    let image;
+    try {
+        image = resolveImage(ctx.config);
+    }
+    catch (error) {
+        if (!(error instanceof CliError))
+            throw error;
+        image = null;
+    }
+    const rows = [["PROVIDER", "CONTAINER", "LOGIN", "HEALTH", "URL"]];
+    for (const [name, provider] of ctx.providers) {
+        const state = states.get(serviceName(provider));
+        const port = ctx.config.port(name);
+        const container = state ? state.state : "not started";
+        const login = image === null ? "?" : (await stack.loggedIn(provider, image)) ? "yes" : "no";
+        let healthy;
+        if (state && state.state === "running")
+            healthy = (await health.server.ready(port)) ? "ready" : "starting";
+        else
+            healthy = "-";
+        const url = healthy === "ready" ? `${health.baseUrl(port)}/v1` : "-";
+        rows.push([name, container, login, healthy, url]);
+    }
+    const widths = rows[0].map((_, i) => Math.max(...rows.map((row) => row[i].length)));
+    for (const row of rows) {
+        console.print(row.map((cell, i) => cell.padEnd(widths[i])).join("  ").trimEnd());
+    }
+    if (image === null)
+        console.step("No server image chosen yet: run 'modelmux up' first.");
+    for (const [name, provider] of ctx.providers) {
+        const state = states.get(serviceName(provider));
+        if (state && ["exited", "dead"].includes(state.state)) {
+            console.step(`${provider.displayName} has stopped. If its login expired: modelmux login ${name}`);
+        }
+    }
+    return 0;
+}

package/dist/commands/configCmd.js

@@ -0,0 +1,62 @@
+/** `modelmux key show` and `modelmux config <target>`. */
+import { KEY_ENV, loadTemplate, render } from "../clientconfig.js";
+import { makeContext } from "../context.js";
+import { CliError } from "../errors.js";
+import * as health from "../health.js";
+import { getProvider } from "../providers.js";
+import { readApiKey } from "../secretsStore.js";
+function key(home) {
+    const found = readApiKey(home);
+    if (found === null) {
+        throw new CliError("ModelMux is not set up yet, so there is no API key.", { hint: "Run: modelmux up" });
+    }
+    return found;
+}
+export async function keyShow(_args, console) {
+    const ctx = makeContext(console);
+    console.reveal(key(ctx.home).value);
+    console.note("Treat this like a password. Clients send it as: Authorization: Bearer <key>");
+    return 0;
+}
+export async function modelsFor(port, apiKey) {
+    const [status, body] = await health.server.getJson(port, "/v1/models", { apiKey });
+    if (status !== 200 || typeof body !== "object" || body === null || Array.isArray(body))
+        return [];
+    const data = body.data;
+    if (!Array.isArray(data))
+        return [];
+    return data
+        .filter((m) => typeof m === "object" && m !== null && !Array.isArray(m) && typeof m.id === "string")
+        .map((m) => m.id);
+}
+export async function config(args, console) {
+    const ctx = makeContext(console);
+    const template = loadTemplate(args.target);
+    const apiKey = key(ctx.home);
+    const names = args.provider ? [args.provider] : [...ctx.providers.keys()];
+    const targets = [];
+    for (const name of names) {
+        const provider = getProvider(name);
+        const port = ctx.config.port(name);
+        let models = await modelsFor(port, apiKey.value);
+        if (!models.length) {
+            models = [provider.exampleModel];
+            console.note(`${provider.displayName} is not running; using its example model '${provider.exampleModel}'.`);
+        }
+        targets.push({ provider: name, displayName: provider.displayName, baseUrl: `${health.baseUrl(port)}/v1`, models });
+    }
+    const text = render(template, targets, args.reveal_key ? apiKey.value : null);
+    if (args.reveal_key) {
+        console.reveal(text.replace(/\n+$/, ""));
+    }
+    else {
+        console.print(text.replace(/\n+$/, ""));
+        if (template.keyStyle !== "env") {
+            console.note(`Set ${KEY_ENV} first: export ${KEY_ENV}=$(modelmux key show)`);
+        }
+        else {
+            console.note("Add the key yourself (modelmux key show), or use --reveal-key.");
+        }
+    }
+    return 0;
+}

package/dist/commands/doctor.js

@@ -0,0 +1,194 @@
+/** `modelmux doctor`: diagnose common problems, each with a suggested fix. */
+import { existsSync, statSync } from "node:fs";
+import path from "node:path";
+import { makeContext } from "../context.js";
+import { CliError, DockerError } from "../errors.js";
+import * as health from "../health.js";
+import { ports } from "../ports.js";
+import { readApiKey, SECRETS_FILE } from "../secretsStore.js";
+import { resolveImage, serviceName } from "../stack.js";
+import * as updates from "../updates.js";
+import { VERSION } from "../version.js";
+export class Report {
+    console;
+    failures = 0;
+    warnings = 0;
+    constructor(console) {
+        this.console = console;
+    }
+    ok(text) {
+        this.console.success(text);
+    }
+    warn(text, hint = null) {
+        this.warnings += 1;
+        this.console.warn(text + (hint ? `\n    ${hint}` : ""));
+    }
+    fail(text, hint = null) {
+        this.failures += 1;
+        this.console.error(text, hint);
+    }
+}
+/** The server's own reason for refusing to start, from its recent logs. */
+export async function startupFailureReason(ctx, provider) {
+    const result = await ctx.stack.compose(["logs", "--no-log-prefix", "--tail", "200", serviceName(provider)], { check: false });
+    let reason = null;
+    for (const line of result.stdout.split(/\r\n|\r|\n/)) {
+        let entry;
+        try {
+            entry = JSON.parse(line);
+        }
+        catch {
+            continue;
+        }
+        if (typeof entry === "object" && entry !== null && !Array.isArray(entry)) {
+            const record = entry;
+            if (record.event === "probe_failed") {
+                reason = typeof record.reason === "string" ? record.reason : reason;
+            }
+        }
+    }
+    return reason;
+}
+async function checkDocker(ctx, report) {
+    let version;
+    try {
+        version = await ctx.docker.checkAvailable();
+    }
+    catch (error) {
+        if (!(error instanceof DockerError))
+            throw error;
+        report.fail(error.message, error.hint);
+        return false;
+    }
+    report.ok(`Docker ${version} is running, with Compose v2`);
+    return true;
+}
+async function checkNetworkAndVersion(report) {
+    if (await updates.registry.registryReachable()) {
+        report.ok("The image registry (ghcr.io) is reachable");
+    }
+    else {
+        report.warn("Cannot reach ghcr.io (needed to download the server image)", "Check your connection or proxy (HTTPS_PROXY, and Docker's proxy settings).");
+    }
+    const latest = await updates.registry.latestVersion();
+    if (latest === null) {
+        report.warn("Could not check npm for a newer modelmux-cli");
+    }
+    else if (updates.newerAvailable(VERSION, latest)) {
+        report.warn(`modelmux-cli ${latest} is available (you have ${VERSION})`, updates.UPGRADE_HINT);
+    }
+    else {
+        report.ok(`modelmux-cli ${VERSION} is the latest version`);
+    }
+}
+function checkFiles(ctx, report) {
+    const keyPath = path.join(ctx.home, SECRETS_FILE);
+    if (!existsSync(keyPath)) {
+        report.fail("ModelMux is not set up on this machine yet", "Run: modelmux up");
+        return false;
+    }
+    if (process.platform !== "win32") {
+        for (const [file, mode] of [[ctx.home, 0o700], [keyPath, 0o600]]) {
+            if ((statSync(file).mode & 0o7777) !== mode) {
+                report.fail(`${file} is readable by other users`, `Fix it: chmod ${mode.toString(8)} '${file}'`);
+                return true;
+            }
+        }
+    }
+    report.ok(`Settings and API key are in ${ctx.home}`);
+    return true;
+}
+async function portConflict(ctx, provider, report) {
+    const port = ctx.config.port(provider.name);
+    if (await ports.portFree(port))
+        return false;
+    report.fail(`${provider.displayName}: port ${port} is used by another program`, `Choose another: modelmux up --port ${provider.name}=<port>`);
+    return true;
+}
+export function stoppedHint(provider, reason) {
+    if (reason && reason.includes("auth")) {
+        return `The login has expired or was revoked: modelmux login ${provider.name} --force`;
+    }
+    if (reason && ["version", "flag", "feature", "config key"].some((word) => reason.includes(word))) {
+        return "The CLI inside the image is not supported: modelmux upgrade";
+    }
+    return `See its logs: modelmux logs ${provider.name}`;
+}
+async function checkRunning(ctx, provider, apiKey, report) {
+    const { name, displayName: display } = provider;
+    const port = ctx.config.port(name);
+    if (!(await health.server.ready(port))) {
+        report.warn(`${display}: running but not ready yet`, `Watch it: modelmux logs ${name} -f`);
+        return;
+    }
+    const [status] = await health.server.getJson(port, "/v1/models", { apiKey });
+    if (status === 200) {
+        report.ok(`${display}: logged in, running and answering at ${health.baseUrl(port)}/v1`);
+    }
+    else if (status === 401) {
+        report.fail(`${display}: the server does not accept the saved API key`, "Recreate it with the current key: modelmux up");
+    }
+    else {
+        report.fail(`${display}: the API did not answer correctly (HTTP ${status})`, `See its logs: modelmux logs ${name}`);
+    }
+}
+async function checkProvider(ctx, provider, image, apiKey, report) {
+    const display = provider.displayName;
+    if (!(await ctx.stack.loggedIn(provider, image))) {
+        report.warn(`${display}: not logged in`, `Run: modelmux login ${provider.name}`);
+        await portConflict(ctx, provider, report);
+        return;
+    }
+    const state = (await ctx.stack.states()).get(serviceName(provider));
+    if (state === undefined) {
+        if (!(await portConflict(ctx, provider, report))) {
+            report.warn(`${display}: logged in but not running`, "Start it: modelmux up");
+        }
+        return;
+    }
+    if (state.state !== "running") {
+        const reason = await startupFailureReason(ctx, provider);
+        const detail = reason ? ` (${reason})` : "";
+        report.fail(`${display}: the server stopped${detail}`, stoppedHint(provider, reason));
+        return;
+    }
+    await checkRunning(ctx, provider, apiKey, report);
+}
+export async function run(_args, console) {
+    const ctx = makeContext(console);
+    const report = new Report(console);
+    const dockerOk = await checkDocker(ctx, report);
+    await checkNetworkAndVersion(report);
+    const setUp = checkFiles(ctx, report);
+    if (dockerOk && setUp) {
+        let image = null;
+        try {
+            image = resolveImage(ctx.config);
+        }
+        catch (error) {
+            if (!(error instanceof CliError))
+                throw error;
+            report.fail(error.message, error.hint);
+        }
+        if (image !== null) {
+            if (await ctx.stack.imagePresent(image))
+                report.ok(`Server image ${image} is present`);
+            else
+                report.warn(`Server image ${image} is not downloaded yet`, "Run: modelmux up");
+            const key = readApiKey(ctx.home);
+            for (const provider of ctx.providers.values()) {
+                await checkProvider(ctx, provider, image, key ? key.value : "", report);
+            }
+        }
+    }
+    console.print();
+    if (report.failures) {
+        console.error(`${report.failures} problem(s) found.`);
+        return 1;
+    }
+    if (report.warnings)
+        console.success(`No problems, ${report.warnings} note(s).`);
+    else
+        console.success("Everything looks good.");
+    return 0;
+}

package/dist/commands/login.js

@@ -0,0 +1,185 @@
+/**
+ * `modelmux login <provider>`: guided login, then a real test.
+ *
+ * The provider's own login command runs in a short-lived, hardened helper
+ * container with only that provider's login volume. On Linux and macOS
+ * Docker gives it a terminal (`-it`) fed straight from the user's terminal,
+ * while its output passes through here so the login link can be spotted and
+ * opened in the browser. On Windows (or with `--raw`) the user's console is
+ * attached directly.
+ *
+ * Keystrokes, pasted codes and API keys are never stored or logged.
+ */
+import { randomBytes } from "node:crypto";
+import { openBrowser } from "../browser.js";
+import { makeContext } from "../context.js";
+import { CliError, DockerError, Interrupted, Timeout, UsageError } from "../errors.js";
+import * as health from "../health.js";
+import { interrupt, resetInterrupt } from "../interrupt.js";
+import { ask as askLine, readSecret } from "../prompt.js";
+import { getProvider } from "../providers.js";
+import { registerSecret } from "../redact.js";
+import { resolveImage, serviceName } from "../stack.js";
+import { LinkScanner } from "../terminal.js";
+import { repr } from "../text.js";
+import * as upModule from "./up.js";
+export const SECRET_LOGIN_TIMEOUT = 120.0;
+/** Replaceable in tests. */
+export const io = {
+    openBrowser,
+    readSecret,
+    ask: askLine,
+    stdinIsTTY: () => process.stdin.isTTY === true,
+};
+export function useTty(args) {
+    return process.platform !== "win32" && !args.raw;
+}
+export function chooseMethod(provider, requested) {
+    const name = requested || provider.defaultLoginMethod;
+    const method = provider.loginMethods.get(name);
+    if (method === undefined) {
+        const options = [...provider.loginMethods.values()].map((m) => `${m.name} (${m.description})`).join(", ");
+        throw new UsageError(`${provider.displayName} has no login method ${repr(name)}.`, {
+            hint: `Choose: ${options}`,
+        });
+    }
+    return method;
+}
+/**
+ * (Re)start the provider and wait for /health/ready: the server's startup
+ * check makes one tiny real request, so ready means the login works.
+ */
+export async function ensureRunningAndTested(ctx, provider) {
+    const port = ctx.config.port(provider.name);
+    const state = (await ctx.stack.states()).get(serviceName(provider));
+    if (state !== undefined && state.state === "running" && (await health.server.ready(port))) {
+        ctx.console.success(`${provider.displayName} is running at ${health.baseUrl(port)}/v1`);
+    }
+    else {
+        await upModule.checkPorts(ctx, [provider]);
+        await ctx.stack.compose(["up", "-d", "--force-recreate", serviceName(provider)], {
+            timeout: upModule.COMPOSE_UP_TIMEOUT,
+        });
+        await upModule.startAndWait(ctx, provider);
+    }
+    ctx.console.success(`${provider.displayName} is logged in and tested.`);
+    ctx.console.step("Configure your tools: modelmux config litellm (or openai-python, langchain)");
+}
+export function linkHandler(provider, noBrowser) {
+    const scanner = new LinkScanner(provider.linkPattern);
+    return async (data) => {
+        const link = scanner.feed(data);
+        if (link === null)
+            return null;
+        if (noBrowser)
+            return Buffer.from("\r\n-> Open the link above in your browser.\r\n");
+        let opened = false;
+        try {
+            opened = await io.openBrowser(link);
+        }
+        catch {
+            opened = false; // no usable browser here
+        }
+        if (opened)
+            return Buffer.from("\r\n-> Opened your browser. If it did not open, use the link above.\r\n");
+        return Buffer.from("\r\n-> Could not open a browser here: open the link above yourself.\r\n");
+    };
+}
+/**
+ * Treat SIGTERM and SIGHUP (terminal closed) like Ctrl+C while logging in,
+ * so the helper container is always removed and the user sees "Cancelled.".
+ */
+export async function cancelOnSignals(work) {
+    if (process.platform === "win32")
+        return work();
+    const signals = ["SIGTERM", "SIGHUP"];
+    const handler = () => interrupt();
+    for (const sig of signals)
+        process.on(sig, handler);
+    try {
+        return await work();
+    }
+    finally {
+        for (const sig of signals)
+            process.removeListener(sig, handler);
+    }
+}
+async function interactiveLogin(ctx, provider, method, image, args) {
+    if (!io.stdinIsTTY()) {
+        throw new UsageError("Logging in needs an interactive terminal.", {
+            hint: `Run 'modelmux login ${provider.name}' in a terminal.`,
+        });
+    }
+    const name = `modelmux-login-${provider.name}-${randomBytes(4).toString("hex")}`;
+    const runArgs = ctx.stack.helperArgs(provider, image, method.command, ["-it", "--name", name]);
+    try {
+        return await cancelOnSignals(async () => {
+            if (useTty(args)) {
+                return ctx.docker.runTty(runArgs, {
+                    onOutput: linkHandler(provider, args.no_browser),
+                    timeout: provider.loginTimeout,
+                });
+            }
+            ctx.console.step("Follow the instructions below; open the link they show in your browser.");
+            return ctx.docker.passthrough(runArgs, { timeout: provider.loginTimeout });
+        });
+    }
+    catch (error) {
+        if (error instanceof Timeout || error instanceof DockerError) {
+            await remove(ctx, name);
+            if (error instanceof DockerError && !error.message.includes("in time"))
+                throw error;
+            throw new CliError("The login timed out.", { hint: `Start again: modelmux login ${provider.name}` });
+        }
+        if (error instanceof Interrupted)
+            await remove(ctx, name);
+        throw error;
+    }
+}
+async function secretLogin(ctx, provider, method, image) {
+    const prompt = method.secretStdin || "Secret";
+    const secret = (await io.readSecret(`${prompt} (input is hidden): `)).trim();
+    if (!secret)
+        throw new UsageError(`No ${prompt} entered.`);
+    registerSecret(secret);
+    const runArgs = ctx.stack.helperArgs(provider, image, method.command, ["-i"]);
+    const result = await ctx.docker.run(runArgs, {
+        inputText: secret + "\n",
+        check: false,
+        timeout: SECRET_LOGIN_TIMEOUT,
+    });
+    return result.returncode;
+}
+/** Remove the helper container, even after Ctrl+C. */
+async function remove(ctx, container) {
+    resetInterrupt(); // the cleanup itself must not be cancelled
+    await ctx.docker.run(["rm", "-f", container], { check: false });
+}
+export async function run(args, console) {
+    const ctx = makeContext(console);
+    const provider = getProvider(args.provider);
+    const method = chooseMethod(provider, args.method);
+    const image = resolveImage(ctx.config);
+    await upModule.prepare(ctx, image);
+    const stack = ctx.stack;
+    if (!args.force && (await stack.loggedIn(provider, image))) {
+        console.success(`${provider.displayName} is already logged in (use --force to log in again).`);
+        await ensureRunningAndTested(ctx, provider);
+        return 0;
+    }
+    console.step(`Logging in to ${provider.displayName}: ${method.description}.`);
+    if (method.secretStdin)
+        await secretLogin(ctx, provider, method, image);
+    else
+        await interactiveLogin(ctx, provider, method, image, args);
+    console.print();
+    if (!(await stack.loggedIn(provider, image))) {
+        throw new CliError(`The ${provider.displayName} login did not complete.`, {
+            hint: `Try again: modelmux login ${provider.name} (add --raw to see only the ` +
+                "provider's own output).",
+        });
+    }
+    console.success(`Logged in to ${provider.displayName}.`);
+    await ensureRunningAndTested(ctx, provider);
+    return 0;
+}

package/dist/commands/logout.js

@@ -0,0 +1,57 @@
+/** `modelmux logout <provider>`: stop it and delete its saved login. */
+import { existsSync } from "node:fs";
+import { makeContext } from "../context.js";
+import { CliError, UsageError } from "../errors.js";
+import { ask } from "../prompt.js";
+import { getProvider } from "../providers.js";
+import { resolveImage, serviceName, volumeName } from "../stack.js";
+/** Replaceable in tests. */
+export const io = {
+    ask,
+    stdinIsTTY: () => process.stdin.isTTY === true,
+};
+export async function confirm(question) {
+    if (!io.stdinIsTTY()) {
+        throw new UsageError("Logout needs confirmation.", {
+            hint: "Add --yes to confirm when not in a terminal.",
+        });
+    }
+    return ["y", "yes"].includes((await io.ask(`${question} [y/N] `)).trim().toLowerCase());
+}
+export async function run(args, console) {
+    const ctx = makeContext(console);
+    const provider = getProvider(args.provider);
+    const stack = ctx.stack;
+    if (!(await stack.volumeExists(provider))) {
+        console.success(`${provider.displayName} is not logged in; nothing to remove.`);
+        return 0;
+    }
+    if (!args.yes && !(await confirm(`Remove the saved ${provider.displayName} login?`))) {
+        console.step("Nothing changed.");
+        return 0;
+    }
+    if (existsSync(stack.composeFile)) {
+        await stack.compose(["rm", "--stop", "--force", serviceName(provider)], { check: false });
+    }
+    let image;
+    try {
+        image = resolveImage(ctx.config);
+    }
+    catch (error) {
+        if (!(error instanceof CliError))
+            throw error;
+        image = null;
+    }
+    if (image !== null) {
+        // Best effort: lets the provider revoke the token, not just forget it.
+        const result = await ctx.docker.run(stack.helperArgs(provider, image, provider.logoutCommand), {
+            check: false,
+            timeout: 60,
+        });
+        if (!result.ok)
+            console.detail("The provider's own logout did not succeed; removing the login anyway.");
+    }
+    await ctx.docker.run(["volume", "rm", volumeName(provider)]);
+    console.success(`Logged out of ${provider.displayName} and removed its saved login.`);
+    return 0;
+}