@b3labs/b3iq-cli 0.0.0-stage → 0.1.0

package/dist/commands/commands.js

@@ -0,0 +1,39 @@
+import { api } from "../lib/api.js";
+import { resolveMachine, machineLabel } from "../lib/machines.js";
+import { CliError, emit, emitIds, isQuiet, kv, table } from "../lib/output.js";
+const DEFAULT_LIMIT = 20;
+const MAX_LIMIT = 50;
+const statusLabel = (c) => (c.error ? `${c.status} (${c.error})` : c.status);
+export async function commandsList(machine, limitFlag) {
+    const node = await resolveMachine(machine);
+    const limit = Math.min(MAX_LIMIT, Math.max(1, Number(limitFlag ?? DEFAULT_LIMIT) || DEFAULT_LIMIT));
+    const { commands } = await api.nodeCommands(node.node_id, limit);
+    if (isQuiet()) {
+        emitIds(commands.map((c) => c.command_id));
+        return;
+    }
+    emit(commands, () => {
+        if (commands.length === 0) {
+            process.stderr.write(`${machineLabel(node)} has no recent commands.\n`);
+            return;
+        }
+        table(["COMMAND", "TYPE", "STATUS", "CREATED"], commands.map((c) => [c.command_id, c.type, statusLabel(c), c.created_at ?? "—"]));
+    });
+}
+export async function commandsGet(commandId, machine) {
+    if (!commandId)
+        throw new CliError("Usage: b3iq commands get <command-id> --machine <m>", "usage", 1);
+    const node = await resolveMachine(machine);
+    const { command } = await api.nodeCommand(node.node_id, commandId);
+    emit(command, () => {
+        const rows = [
+            ["Command", command.command_id],
+            ["Machine", machineLabel(node)],
+            ["Type", command.type],
+            ["Status", statusLabel(command)],
+            ["Created", command.created_at ?? "—"],
+            ["Completed", command.completed_at ?? "—"],
+        ];
+        kv(rows);
+    });
+}

package/dist/commands/logs.js

@@ -0,0 +1,41 @@
+import { api } from "../lib/api.js";
+import { emit, isJSON, log, table } from "../lib/output.js";
+const FOLLOW_POLL_MS = 5_000;
+function renderRows(rows) {
+    table(["TIME", "MODEL", "STATUS", "MS", "TOKENS", "NODE"], rows.map((r) => [
+        new Date(r.created_at).toLocaleTimeString(),
+        r.model_id ?? "—",
+        r.error_code ? `${r.status} (${r.error_code})` : r.status,
+        String(r.duration_ms ?? ""),
+        String(r.total_tokens ?? ""),
+        (r.selected_node_id ?? "").slice(0, 8),
+    ]));
+}
+export async function logsCmd(limitFlag, follow) {
+    const limit = Math.min(200, Math.max(1, Number(limitFlag ?? 50) || 50));
+    const { entries } = await api.logs(limit);
+    const oldestFirst = [...entries].reverse();
+    if (!follow) {
+        emit(oldestFirst, () => renderRows(oldestFirst));
+        return;
+    }
+    const seenEventIds = new Set(oldestFirst.map((r) => r.event_id));
+    if (isJSON())
+        for (const r of oldestFirst)
+            process.stdout.write(JSON.stringify(r) + "\n");
+    else
+        renderRows(oldestFirst);
+    log("following (ctrl-c to stop)…");
+    for (;;) {
+        await new Promise((r) => setTimeout(r, FOLLOW_POLL_MS));
+        const { entries: next } = await api.logs(limit);
+        const unseenEvents = [...next].reverse().filter((r) => !seenEventIds.has(r.event_id));
+        for (const r of unseenEvents) {
+            seenEventIds.add(r.event_id);
+            if (isJSON())
+                process.stdout.write(JSON.stringify(r) + "\n");
+        }
+        if (!isJSON() && unseenEvents.length)
+            renderRows(unseenEvents);
+    }
+}

package/dist/commands/machines.js

@@ -0,0 +1,104 @@
+import { api } from "../lib/api.js";
+import { machineLabel, resolveMachine, resolveMachineOrRental } from "../lib/machines.js";
+import { queuedThenWait } from "../lib/commands-wait.js";
+import { emit, emitIds, isQuiet, kv, log, success, table } from "../lib/output.js";
+import { listedOrgLabel } from "../lib/config.js";
+export function provisioningLabel(p) {
+    if (!p)
+        return "—";
+    if (p.failed)
+        return `failed at ${p.stage ?? "unknown stage"}${p.reason ? `: ${p.reason}` : ""}`;
+    return p.stage ? `ok (${p.stage})` : "—";
+}
+export async function machinesList() {
+    const { nodes, org_context } = await api.nodes();
+    if (isQuiet()) {
+        emitIds(nodes.map((n) => n.node_id));
+        return;
+    }
+    emit(nodes, () => {
+        if (org_context)
+            log(`machines of organization ${listedOrgLabel(org_context)}`);
+        if (nodes.length === 0) {
+            process.stderr.write(org_context ? "No machines in this organization.\n" : "No machines on this account.\n");
+            return;
+        }
+        table(["MACHINE", "STATUS", "STATE", "MODELS", "MODE", "NODE ID"], nodes.map((n) => [
+            machineLabel(n),
+            n.liveness ?? "—",
+            n.state ?? "—",
+            `${n.models_ready ?? 0}/${n.models_total ?? 0}`,
+            n.mode ?? "—",
+            n.node_id,
+        ]));
+    });
+}
+export async function machinesGet(selector) {
+    const node = await resolveMachine(selector);
+    const detail = await api.node(node.node_id);
+    emit(detail, () => {
+        const rows = [
+            ["Machine", machineLabel(node)],
+            ["Node ID", node.node_id],
+            ["Status", node.liveness ?? "—"],
+            ["State", detail.state ?? "—"],
+            ["Provisioning", provisioningLabel(detail.provisioning)],
+            ["Mode", node.mode ?? "—"],
+            ["Models", `${node.models_ready ?? 0}/${node.models_total ?? 0}`],
+            ["Last seen", node.last_seen_at ?? "—"],
+        ];
+        kv(rows);
+    });
+}
+const QUALIFY_TIMEOUT_MS = 10 * 60 * 1000;
+export async function machinesQualify(selector, wait) {
+    const node = await resolveMachine(selector);
+    const row = await queuedThenWait(node.node_id, await api.qualify(node.node_id), {
+        wait,
+        timeoutMs: QUALIFY_TIMEOUT_MS,
+        describe: `qualify ${machineLabel(node)}`,
+    });
+    emit(row, () => {
+        if (row.status === "completed")
+            success(`${machineLabel(node)} re-qualified. Read the verdict: \`b3iq machines get ${node.node_id}\`.`);
+        else
+            process.stdout.write(`${row.command_id}\n`);
+    });
+}
+function cardsLabel(ids, cards) {
+    if (ids.length === 0)
+        return "—";
+    const indexOf = new Map(cards.map((card) => [card.pci_bus_id, card.index]));
+    return ids.map((id) => (indexOf.has(id) ? String(indexOf.get(id)) : id)).join(", ");
+}
+export async function machinesGuests(selector) {
+    const target = await resolveMachineOrRental(selector);
+    const view = await api.nodeGuests(target.node.node_id);
+    if (isQuiet()) {
+        emitIds(view.guests.map((g) => g.guest_id));
+        return;
+    }
+    const label = machineLabel(target.node);
+    emit(view, () => {
+        if (view.host_role !== "hypervisor") {
+            process.stderr.write(`${label} is not a KVM host, so it runs no guests.\n`);
+            return;
+        }
+        if (view.lease) {
+            kv([["Rental", `${view.lease.phase}, ${view.lease.starts_at} to ${view.lease.ends_at}`]]);
+        }
+        if (view.guests.length === 0) {
+            process.stderr.write(view.access === "guest" ? `Your guest on ${label} is not created yet.\n` : `No guests on ${label} right now.\n`);
+        }
+        else if (view.access === "guest") {
+            table(["GUEST", "STATE", "SSH", "GPUS", "IMAGE"], view.guests.map((g) => [g.guest_id, g.state, g.ssh_hostname && g.ssh_user ? `${g.ssh_user}@${g.ssh_hostname}` : "—", cardsLabel(g.gpu_pci_ids, view.gpus), g.image_version ?? "—"]));
+        }
+        else {
+            table(["GUEST", "KIND", "STATE", "GPUS", "IMAGE", "CREATED"], view.guests.map((g) => [g.guest_id, g.kind, g.state, cardsLabel(g.gpu_pci_ids, view.gpus), g.image_version ?? "—", g.created_at]));
+        }
+        if (view.gpus.length > 0) {
+            process.stdout.write("\n");
+            table(["GPU", "PCI", "STATE", "REASONS", "IN USE"], view.gpus.map((c) => [String(c.index), c.pci_bus_id, c.qualification_state ?? "—", c.qualification_reasons.join(", ") || "—", c.in_use ? "yes" : "no"]));
+        }
+    });
+}

package/dist/commands/media-mcp.js

@@ -0,0 +1,19 @@
+import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { z } from "zod";
+import { InferenceGateway } from "../lib/inference.js";
+import { VERSION } from "../lib/version.js";
+export function mediaMcpServer(options = {}) {
+    const server = new McpServer({ name: "b3iq-media", version: VERSION });
+    const gateway = new InferenceGateway(options);
+    const result = (value) => ({ content: [{ type: "text", text: JSON.stringify(value) }] });
+    server.registerTool("b3iq_models", { description: "List models and serving metadata on machines permitted by the dashboard API key. Use exact returned model IDs and b3iq.modality to choose image/video models. Do not substitute a text or other media model.", inputSchema: {} }, async (_args, extra) => result(await gateway.models(extra.signal)));
+    server.registerTool("b3iq_generate_image", { description: "Generate an image or edit a user-provided reference on a permitted owned machine. For editing, pass image_path as the absolute path to the user's PNG/JPEG/WebP attachment (at most 5 MiB) and choose a model advertising image input. Only send an attachment the user asked to use; never substitute text-to-image when editing is unavailable. Returns a job ID; call b3iq_image_status until completed. Older hosts may return a completed PNG path directly. Never resubmit while it is running.", inputSchema: { model: z.string().min(1), prompt: z.string().min(1).max(32000), image_path: z.string().min(1).optional() } }, async (args, extra) => result(await gateway.image(args.model, args.prompt, extra.signal, args.image_path)));
+    server.registerTool("b3iq_image_status", { description: "Check an image job. When completed, save its PNG in the configured B3IQ media directory. Stopping a status read does not stop generation.", inputSchema: { id: z.string().regex(/^med_[a-f0-9-]{36}$/) } }, async (args, extra) => result(await gateway.imageStatus(args.id, extra.signal)));
+    server.registerTool("b3iq_generate_video", { description: "Submit one video generation job to a permitted owned machine. Returns a job ID; call b3iq_video_status until completed. Do not resubmit while it is running.", inputSchema: { model: z.string().min(1), prompt: z.string().min(1).max(32000), seconds: z.number().int().min(1).max(30).default(1) } }, async (args, extra) => result(await gateway.video(args.model, args.prompt, args.seconds, extra.signal)));
+    server.registerTool("b3iq_video_status", { description: "Check a video job. When completed, download its MP4 to the configured media directory. Cancelling this read does not cancel the GPU job.", inputSchema: { id: z.string().regex(/^vid_[a-f0-9-]{36}$/) } }, async (args, extra) => result(await gateway.videoStatus(args.id, extra.signal)));
+    return server;
+}
+export async function runMediaMcp(options) {
+    await mediaMcpServer(options).connect(new StdioServerTransport());
+}

package/dist/commands/misc.js

@@ -0,0 +1,257 @@
+import { spawnSync } from "node:child_process";
+import { hostname } from "node:os";
+import { api, deviceAuth, whoAmI } from "../lib/api.js";
+import { machineLabel } from "../lib/machines.js";
+import { readConfig, writeConfig, clearToken, resolveSettings, configPath, orgLabel, loginApprovalUrl, isLoopbackHost } from "../lib/config.js";
+import { CliError, EXIT_CODE, emit, kv, log, plain, success, table, warn } from "../lib/output.js";
+const MIN_DEVICE_POLL_SECONDS = 2;
+const RATE_LIMIT_BACKOFF_SECONDS = 5;
+const BROWSER_OPEN_TIMEOUT_MS = 5_000;
+const RETIRED_TOKEN_PREFIX = "b3iq_pat_";
+async function verifySavedTokenAndAnnounce(saved) {
+    const { user, organization, expiresAt } = await whoAmI(saved);
+    writeConfig({ org_id: organization?.id, org_name: organization?.name ?? undefined, expires_at: expiresAt ?? undefined });
+    const scope = organization ? ` for organization ${orgLabel(organization.id, organization.name)}` : "";
+    success(`Logged in as ${user.email ?? user.id}${scope}. Token saved to ${configPath()} (0600).`);
+}
+export async function login(token) {
+    if (!token) {
+        if (!process.stdin.isTTY) {
+            throw new CliError("No API key and no TTY. Pipe one with `b3iq login --token-stdin`, or set B3IQ_TOKEN.", "usage", 1);
+        }
+        return loginViaDeviceFlow();
+    }
+    const key = token.trim();
+    if (!key || /[\r\n]/.test(key))
+        throw new CliError("Supply one API key.", "usage", 1);
+    writeConfig({ token: key, expires_at: undefined, pat_id: undefined, org_id: undefined, org_name: undefined });
+    try {
+        await verifySavedTokenAndAnnounce({ token: key });
+    }
+    catch (e) {
+        clearToken();
+        throw e;
+    }
+}
+async function loginViaDeviceFlow() {
+    const pairing = await deviceAuth.start(`b3iq CLI on ${hostname()}`);
+    log("in the browser, choose your personal account or one of your organizations");
+    log(`confirm this code in your browser: ${pairing.user_code}`);
+    const approvalUrl = loginApprovalUrl(pairing.verification_uri_complete, pairing.user_code);
+    log(approvalUrl);
+    openBrowserBestEffort(approvalUrl);
+    const deadline = Date.now() + pairing.expires_in * 1000;
+    let pollSeconds = Math.max(MIN_DEVICE_POLL_SECONDS, pairing.interval);
+    while (Date.now() < deadline) {
+        await new Promise((r) => setTimeout(r, pollSeconds * 1000));
+        let result;
+        try {
+            result = await deviceAuth.poll(pairing.device_code);
+        }
+        catch (e) {
+            if (e instanceof CliError && e.code === "ratelimited") {
+                pollSeconds += RATE_LIMIT_BACKOFF_SECONDS;
+                continue;
+            }
+            throw e;
+        }
+        if (result.status === "authorization_pending")
+            continue;
+        if (result.status === "complete" && result.token) {
+            const orgId = result.api_key?.organization_id ?? undefined;
+            writeConfig({ token: result.token, expires_at: result.api_key?.expires_at ?? undefined, pat_id: undefined, org_id: orgId, org_name: undefined });
+            await verifySavedTokenAndAnnounce({ token: result.token, orgId });
+            return;
+        }
+        throw new CliError(`Unexpected login state "${result.status}" — run \`b3iq login\` again.`, "api");
+    }
+    throw new CliError("Login expired before it was approved — run `b3iq login` again.", "auth", 3);
+}
+export function browserTarget(url, platform = process.platform) {
+    let parsed;
+    try {
+        parsed = new URL(url);
+    }
+    catch {
+        return undefined;
+    }
+    if (parsed.username || parsed.password)
+        return undefined;
+    if (!(parsed.protocol === "https:" || (parsed.protocol === "http:" && isLoopbackHost(parsed.hostname))))
+        return undefined;
+    if (/%(?![0-9A-Fa-f]{2})/.test(parsed.href))
+        return undefined;
+    if (platform !== "win32")
+        return parsed.href;
+    return parsed.href.replace(/[&|<>^()]/g, "^$&").replace(/%/g, "%^");
+}
+function openBrowserBestEffort(url) {
+    const target = browserTarget(url);
+    if (!target)
+        return;
+    const cmd = process.platform === "darwin" ? "open" : process.platform === "win32" ? "cmd" : "xdg-open";
+    const args = process.platform === "win32" ? ["/c", "start", "", target] : [target];
+    try {
+        spawnSync(cmd, args, { stdio: "ignore", timeout: BROWSER_OPEN_TIMEOUT_MS });
+    }
+    catch {
+    }
+}
+export async function logout(revoke) {
+    const cfg = readConfig();
+    if (revoke && cfg.token && (cfg.pat_id || cfg.token.startsWith(RETIRED_TOKEN_PREFIX))) {
+        log("this CLI token was already retired server-side");
+    }
+    else if (revoke && cfg.token) {
+        const saved = { token: cfg.token, orgId: cfg.org_id };
+        try {
+            await api.revokeCurrentCredential(saved);
+            log("token revoked server-side");
+        }
+        catch (e) {
+            warn(`could not revoke server-side (${e instanceof Error ? e.message : e}) — removing locally anyway`);
+        }
+    }
+    clearToken();
+    success("Logged out.");
+}
+export async function whoami() {
+    const { user, organization } = await whoAmI();
+    const shown = { id: user.id, email: user.email ?? null, displayName: user.displayName ?? null, avatarUrl: user.avatarUrl ?? null };
+    emit({ ...shown, organization }, () => {
+        process.stdout.write(`  ${plain(user.email ?? user.displayName ?? user.id)}\n`);
+        process.stdout.write(`  ${organization ? `organization ${plain(orgLabel(organization.id, organization.name))}` : "personal account"}\n`);
+    });
+}
+function accountDetail({ user, organization }) {
+    const who = user.email ?? user.id;
+    return organization ? `${who} · organization ${orgLabel(organization.id, organization.name)}` : who;
+}
+function refusedForOrgKey(error) {
+    return error instanceof CliError && error.diagnosis?.observed?.http_status === 403;
+}
+export async function status() {
+    const [{ nodes, org_context }, servable] = await Promise.all([
+        api.nodes(),
+        api.models().then((r) => r.models, (e) => e),
+    ]);
+    if (!Array.isArray(servable) && !(org_context && refusedForOrgKey(servable)))
+        throw servable;
+    const models = Array.isArray(servable) ? servable : null;
+    const online = nodes.filter((n) => n.liveness === "online").length;
+    emit({ machines_total: nodes.length, machines_online: online, models_servable: models?.length ?? null, nodes, models }, () => {
+        const modelSummary = models ? `${models.length} servable models` : "servable models need a personal login";
+        process.stdout.write(`  ${online}/${nodes.length} machines online · ${modelSummary}\n\n`);
+        if (nodes.length) {
+            table(["MACHINE", "STATUS", "MODELS"], nodes.map((n) => [machineLabel(n), n.liveness ?? "—", `${n.models_ready ?? 0}/${n.models_total ?? 0}`]));
+        }
+    });
+}
+export function configCmd(positionals) {
+    const [key, value] = positionals;
+    if (!key) {
+        const { token, ...rest } = readConfig();
+        emit({ ...rest, token_present: Boolean(token) }, () => {
+            kv([...Object.entries(rest).map(([k, v]) => [k, String(v)]), ["token", token ? "***" : "(none)"]], 16);
+        });
+        return;
+    }
+    if (key === "default-machine") {
+        if (!value)
+            throw new CliError("Usage: b3iq config default-machine <machine-id>", "usage", 1);
+        writeConfig({ default_machine: value });
+        success(`Default machine set to ${value}.`);
+        return;
+    }
+    throw new CliError(`Unknown config key "${key}". Supported: default-machine.`, "usage", 1);
+}
+export async function doctor() {
+    const checks = [];
+    const settings = resolveSettings();
+    checks.push({ name: "config", ok: true, detail: `${configPath()} · api_url=${settings.apiUrl}` });
+    checks.push({
+        name: "auth",
+        ok: !!settings.token,
+        detail: settings.token ? "token present" : "no token — run `b3iq login` or set B3IQ_TOKEN",
+    });
+    const cloudflared = spawnSync("cloudflared", ["--version"], { stdio: "pipe" });
+    const cloudflaredInstalled = cloudflared.status === 0;
+    checks.push({
+        name: "cloudflared",
+        ok: cloudflaredInstalled,
+        detail: cloudflaredInstalled
+            ? String(cloudflared.stdout).trim().split("\n")[0]
+            : "not installed (needed for `b3iq ssh`) — brew install cloudflared",
+    });
+    if (settings.token) {
+        try {
+            checks.push({ name: "api", ok: true, detail: `reachable as ${accountDetail(await whoAmI())}` });
+        }
+        catch (e) {
+            checks.push({ name: "api", ok: false, detail: e instanceof Error ? e.message : String(e) });
+        }
+    }
+    emit({ checks }, () => {
+        for (const c of checks)
+            (c.ok ? success : warn)(`${c.name}: ${c.detail}`);
+    });
+    if (checks.some((c) => !c.ok))
+        process.exit(EXIT_CODE.api);
+}
+export function help() {
+    process.stderr.write([
+        "b3iq — manage your b3iq machines from the terminal or an agent",
+        "",
+        "USAGE  b3iq <command> [args] [--json|--pretty] [--quiet]",
+        "",
+        "  login                   sign in via your browser; pick personal or an organization there",
+        "                          [--token-stdin saves an API key read from a pipe]",
+        "  logout [--revoke]       forget the saved token (--revoke kills it server-side)",
+        "  whoami                  show the logged-in account and organization",
+        "  status                  fleet overview (machines + servable models; models need a personal login)",
+        "  machines list           list your machines            [--quiet ⇒ node ids]",
+        "  machines get <machine>  one machine's detail",
+        "  machines qualify <machine>  re-run the hardware qualification [--no-wait]",
+        "  machines guests <machine>   a KVM host's guests and cards  [--quiet ⇒ guest ids]",
+        "  plugins list [--machine <m>]   installable plugins (per-machine: installed, with state)",
+        "  plugins install <plugin> --machine <m>  install onto a machine [--no-wait]",
+        "  plugins remove <plugin> --machine <m>   remove it, with what it installed",
+        "  models list [--machine <m>]    servable models (per-machine: full catalog; fleet-wide needs a personal login)",
+        "  models install <model> --machine <m>   install onto a machine [--no-wait]",
+        "  models context <model> --machine <m>   verify/save coding context [--tokens N|--reset] [--no-wait]",
+        "  models remove <model> --machine <m>    uninstall from a machine",
+        "  runtimes check --machine <m>           installed and pinned update versions",
+        "  runtimes upgrade <runtime> --machine <m> --target-version <v>  upgrade when idle",
+        "  runtimes policy <runtime> --machine <m> --mode manual|scheduled [--hour-utc <0..23>]",
+        "  runtimes list --machine <m>            engines a machine runs",
+        "  runtimes restart <runtime> --machine <m>  bounce an engine [--no-wait]",
+        "  commands list --machine <m> [--limit N]  a machine's recent commands",
+        "  commands get <id> --machine <m>          one command's status and result",
+        "  logs [--limit N] [--follow]            recent inference requests (personal login)",
+        "  ssh [<machine>] [-- cmd]  open an SSH session; asks which machine when none is given.",
+        "                          A rented KVM host opens your guest, as its user. With direct SSH",
+        "                          on for the account: the machine's own address first, then the",
+        "                          Cloudflare Tunnel; reconnects a dropped shell.",
+        "                          [--direct|--tunnel] [--no-reconnect]",
+        "  config [default-machine <id>]  view / set config",
+        "  doctor                  diagnose auth, API reachability, cloudflared",
+        "  inference models [--machine <id>]      discover exact served model IDs",
+        "  inference setup <codex|claude|opencode> --model <id>  generate opt-in native config",
+        "  inference <codex|claude|opencode> --model <id> [-- args]  launch terminal client",
+        "  inference setup codex --desktop [--install] [--activate] --model <id>  separate desktop; preserve normal defaults",
+        "    --setup-name <name>                 keep an existing Codex setup and create a separate one",
+        "  inference setup claude --desktop [--install] [--activate] --model <id>  save; activation is explicit",
+        "  inference restore claude --desktop     restore the provider recorded before activation",
+        "  inference setup opencode --desktop --install --model <id>  add provider; preserve defaults",
+        "    --client-version 1|2 (OpenCode launch auto-detects; setup defaults to 2)",
+        "  inference key-save | key-clear         save a key from stdin / remove it",
+        "  mcp media               run the owned-model media MCP server (stdio)",
+        "",
+        "Output: stdout is data, stderr is logs. JSON is automatic when piped;",
+        "        --json forces it, --quiet prints only ids. Exit: 0 ok / 1 usage /",
+        "        2 api / 3 auth / 4 rate-limited.",
+        "Failures name the check that failed and the next command. JSON errors add",
+        "diagnostic, cause, observed, recovery, and limitation. Exit codes stay the same.",
+        "",
+    ].join("\n"));
+}

package/dist/commands/models.js

@@ -0,0 +1,141 @@
+import { api } from "../lib/api.js";
+import { contextSavedLines, explainProfileRefusal } from "../lib/diagnosis.js";
+import { resolveMachine, machineLabel, noteReportedOffline } from "../lib/machines.js";
+import { enqueueAndWait } from "../lib/commands-wait.js";
+import { CliError, emit, emitIds, isQuiet, log, success, table } from "../lib/output.js";
+export async function modelsList(machine) {
+    if (machine)
+        return machineCatalog(machine);
+    const { models } = await api.models();
+    const id = (m) => m.id ?? m.model ?? "";
+    if (isQuiet()) {
+        emitIds(models.map(id));
+        return;
+    }
+    emit(models, () => {
+        if (models.length === 0) {
+            process.stderr.write("No servable models yet. See what a machine can run: `b3iq models list --machine <m>`.\n");
+            return;
+        }
+        table(["MODEL", "MODALITY", "MACHINES"], models.map((m) => [id(m), m.modality ?? "text", String(m.nodes_online ?? 0)]));
+    });
+}
+async function machineCatalog(machine) {
+    const node = await resolveMachine(machine);
+    const profiles = (await api.node(node.node_id)).model_profiles ?? [];
+    const pid = (p) => p.id ?? p.model ?? "";
+    if (isQuiet()) {
+        emitIds(profiles.filter((p) => p.status === "installed").map(pid));
+        return;
+    }
+    emit(profiles, () => {
+        if (profiles.length === 0) {
+            process.stderr.write(`${machineLabel(node)} advertises no model catalog yet (agent offline or still enrolling?).\n`);
+            return;
+        }
+        table(["MODEL", "RUNTIME", "STATUS"], profiles.map((p) => [p.name ?? pid(p), p.runtime_kind ?? "—", p.status ?? "—"]));
+    });
+}
+export function matchProfiles(profiles, selector) {
+    const lower = selector.trim().toLowerCase();
+    const exact = profiles.filter((p) => p.id?.toLowerCase() === lower || p.model?.toLowerCase() === lower || p.name?.toLowerCase() === lower);
+    if (exact.length)
+        return exact;
+    return profiles.filter((p) => (p.id ?? "").toLowerCase().includes(lower) ||
+        (p.model ?? "").toLowerCase().includes(lower) ||
+        (p.name ?? "").toLowerCase().includes(lower));
+}
+function requireOneProfile(profiles, selector, wantStatus, verb, node) {
+    const matches = matchProfiles(profiles, selector);
+    const eligible = matches.filter((p) => p.status === wantStatus);
+    if (matches.length === 0 || eligible.length !== 1) {
+        throw explainProfileRefusal({
+            selector,
+            wantStatus,
+            verb,
+            matches,
+            catalogSize: profiles.length,
+            nodeId: node.node_id,
+            liveness: node.liveness,
+        });
+    }
+    return eligible[0];
+}
+const FALLBACK_RUNTIME_KIND = "ollama";
+function commandParams(profile) {
+    return {
+        profile_id: profile.id,
+        model: profile.model,
+        runtime_id: profile.runtime_kind ?? FALLBACK_RUNTIME_KIND,
+        runtime_kind: profile.runtime_kind,
+    };
+}
+const INSTALL_TIMEOUT_MS = 45 * 60 * 1000;
+const UNINSTALL_TIMEOUT_MS = 5 * 60 * 1000;
+export async function modelsInstall(selector, machine, wait) {
+    if (!selector)
+        throw new CliError("Usage: b3iq models install <model> --machine <m>", "usage", 1);
+    const node = await resolveMachine(machine);
+    noteReportedOffline(node);
+    const profiles = (await api.node(node.node_id)).model_profiles ?? [];
+    const profile = requireOneProfile(profiles, selector, "ready_to_install", "install", node);
+    const name = profile.name ?? profile.model ?? profile.id ?? selector;
+    const row = await enqueueAndWait(node.node_id, "model.install", commandParams(profile), {
+        wait,
+        timeoutMs: INSTALL_TIMEOUT_MS,
+        describe: `install ${name} on ${machineLabel(node)}`,
+    });
+    emit(row, () => {
+        if (row.status === "completed")
+            success(`${name} installed on ${machineLabel(node)}.`);
+        else
+            process.stdout.write(`${row.command_id}\n`);
+    });
+}
+export async function modelsRemove(selector, machine, wait) {
+    if (!selector)
+        throw new CliError("Usage: b3iq models remove <model> --machine <m>", "usage", 1);
+    const node = await resolveMachine(machine);
+    noteReportedOffline(node);
+    const profiles = (await api.node(node.node_id)).model_profiles ?? [];
+    const profile = requireOneProfile(profiles, selector, "installed", "remove", node);
+    const name = profile.name ?? profile.model ?? profile.id ?? selector;
+    const row = await enqueueAndWait(node.node_id, "model.uninstall", commandParams(profile), {
+        wait,
+        timeoutMs: UNINSTALL_TIMEOUT_MS,
+        describe: `remove ${name} from ${machineLabel(node)}`,
+    });
+    emit(row, () => {
+        if (row.status === "completed")
+            success(`${name} removed from ${machineLabel(node)}.`);
+        else
+            process.stdout.write(`${row.command_id}\n`);
+    });
+}
+export async function modelsContext(selector, machine, tokens, reset, wait) {
+    if (!selector)
+        throw new CliError("Usage: b3iq models context <model> --machine <m> [--tokens <n>|--reset] [--no-wait]", "usage", 1);
+    if (tokens !== undefined && (typeof tokens !== "string" || !/^[0-9]+$/.test(tokens) || Number(tokens) < 1 || Number(tokens) > 16_777_216)) {
+        throw new CliError("--tokens requires an integer between 1 and 16777216.", "usage", 1);
+    }
+    if (reset && tokens !== undefined)
+        throw new CliError("Use --tokens or --reset, not both.", "usage", 1);
+    const node = await resolveMachine(machine);
+    noteReportedOffline(node);
+    const profile = requireOneProfile((await api.node(node.node_id)).model_profiles ?? [], selector, "installed", "configure context", node);
+    const row = await enqueueAndWait(node.node_id, "model.context.configure", {
+        profile_id: profile.id, model: profile.model,
+        ...(tokens === undefined ? {} : { context_window_tokens: Number(tokens) }),
+        ...(reset ? { reset: true } : {}),
+    }, { wait, timeoutMs: 6 * 60 * 1000, describe: `configure context for ${profile.model} on ${machineLabel(node)}` });
+    if (row.status === "completed") {
+        for (const line of contextSavedLines(profile.model ?? selector, node.node_id, machineLabel(node), row.result))
+            log(line);
+    }
+    emit(row, () => {
+        if (row.status === "completed")
+            process.stdout.write(JSON.stringify(row.result, null, 2) + "\n");
+        else
+            process.stdout.write(`${row.command_id}\n`);
+    });
+}