clawdbot 2026.1.4-1

package/dist/commands/models/scan.js

@@ -0,0 +1,266 @@
+import { cancel, isCancel, multiselect } from "@clack/prompts";
+import { discoverAuthStorage } from "@mariozechner/pi-coding-agent";
+import { resolveClawdbotAgentDir } from "../../agents/agent-paths.js";
+import { scanOpenRouterModels, } from "../../agents/model-scan.js";
+import { CONFIG_PATH_CLAWDBOT } from "../../config/config.js";
+import { warn } from "../../globals.js";
+import { buildAllowlistSet, formatMs, formatTokenK, updateConfig, } from "./shared.js";
+const MODEL_PAD = 42;
+const CTX_PAD = 8;
+const pad = (value, size) => value.padEnd(size);
+const truncate = (value, max) => {
+    if (value.length <= max)
+        return value;
+    if (max <= 3)
+        return value.slice(0, max);
+    return `${value.slice(0, max - 3)}...`;
+};
+function sortScanResults(results) {
+    return results.slice().sort((a, b) => {
+        const aImage = a.image.ok ? 1 : 0;
+        const bImage = b.image.ok ? 1 : 0;
+        if (aImage !== bImage)
+            return bImage - aImage;
+        const aToolLatency = a.tool.latencyMs ?? Number.POSITIVE_INFINITY;
+        const bToolLatency = b.tool.latencyMs ?? Number.POSITIVE_INFINITY;
+        if (aToolLatency !== bToolLatency)
+            return aToolLatency - bToolLatency;
+        const aCtx = a.contextLength ?? 0;
+        const bCtx = b.contextLength ?? 0;
+        if (aCtx !== bCtx)
+            return bCtx - aCtx;
+        const aParams = a.inferredParamB ?? 0;
+        const bParams = b.inferredParamB ?? 0;
+        if (aParams !== bParams)
+            return bParams - aParams;
+        return a.modelRef.localeCompare(b.modelRef);
+    });
+}
+function sortImageResults(results) {
+    return results.slice().sort((a, b) => {
+        const aLatency = a.image.latencyMs ?? Number.POSITIVE_INFINITY;
+        const bLatency = b.image.latencyMs ?? Number.POSITIVE_INFINITY;
+        if (aLatency !== bLatency)
+            return aLatency - bLatency;
+        const aCtx = a.contextLength ?? 0;
+        const bCtx = b.contextLength ?? 0;
+        if (aCtx !== bCtx)
+            return bCtx - aCtx;
+        const aParams = a.inferredParamB ?? 0;
+        const bParams = b.inferredParamB ?? 0;
+        if (aParams !== bParams)
+            return bParams - aParams;
+        return a.modelRef.localeCompare(b.modelRef);
+    });
+}
+function buildScanHint(result) {
+    const toolLabel = result.tool.ok
+        ? `tool ${formatMs(result.tool.latencyMs)}`
+        : "tool fail";
+    const imageLabel = result.image.skipped
+        ? "img skip"
+        : result.image.ok
+            ? `img ${formatMs(result.image.latencyMs)}`
+            : "img fail";
+    const ctxLabel = result.contextLength
+        ? `ctx ${formatTokenK(result.contextLength)}`
+        : "ctx ?";
+    const paramLabel = result.inferredParamB ? `${result.inferredParamB}b` : null;
+    return [toolLabel, imageLabel, ctxLabel, paramLabel]
+        .filter(Boolean)
+        .join(" | ");
+}
+function printScanSummary(results, runtime) {
+    const toolOk = results.filter((r) => r.tool.ok);
+    const imageOk = results.filter((r) => r.image.ok);
+    const toolImageOk = results.filter((r) => r.tool.ok && r.image.ok);
+    const imageOnly = imageOk.filter((r) => !r.tool.ok);
+    runtime.log(`Scan results: tested ${results.length}, tool ok ${toolOk.length}, image ok ${imageOk.length}, tool+image ok ${toolImageOk.length}, image only ${imageOnly.length}`);
+}
+function printScanTable(results, runtime) {
+    const header = [
+        pad("Model", MODEL_PAD),
+        pad("Tool", 10),
+        pad("Image", 10),
+        pad("Ctx", CTX_PAD),
+        pad("Params", 8),
+        "Notes",
+    ].join(" ");
+    runtime.log(header);
+    for (const entry of results) {
+        const modelLabel = pad(truncate(entry.modelRef, MODEL_PAD), MODEL_PAD);
+        const toolLabel = pad(entry.tool.ok ? formatMs(entry.tool.latencyMs) : "fail", 10);
+        const imageLabel = pad(entry.image.ok
+            ? formatMs(entry.image.latencyMs)
+            : entry.image.skipped
+                ? "skip"
+                : "fail", 10);
+        const ctxLabel = pad(formatTokenK(entry.contextLength), CTX_PAD);
+        const paramsLabel = pad(entry.inferredParamB ? `${entry.inferredParamB}b` : "-", 8);
+        const notes = entry.modality ? `modality:${entry.modality}` : "";
+        runtime.log([modelLabel, toolLabel, imageLabel, ctxLabel, paramsLabel, notes].join(" "));
+    }
+}
+export async function modelsScanCommand(opts, runtime) {
+    const minParams = opts.minParams ? Number(opts.minParams) : undefined;
+    if (minParams !== undefined &&
+        (!Number.isFinite(minParams) || minParams < 0)) {
+        throw new Error("--min-params must be >= 0");
+    }
+    const maxAgeDays = opts.maxAgeDays ? Number(opts.maxAgeDays) : undefined;
+    if (maxAgeDays !== undefined &&
+        (!Number.isFinite(maxAgeDays) || maxAgeDays < 0)) {
+        throw new Error("--max-age-days must be >= 0");
+    }
+    const maxCandidates = opts.maxCandidates ? Number(opts.maxCandidates) : 6;
+    if (!Number.isFinite(maxCandidates) || maxCandidates <= 0) {
+        throw new Error("--max-candidates must be > 0");
+    }
+    const timeout = opts.timeout ? Number(opts.timeout) : undefined;
+    if (timeout !== undefined && (!Number.isFinite(timeout) || timeout <= 0)) {
+        throw new Error("--timeout must be > 0");
+    }
+    const concurrency = opts.concurrency ? Number(opts.concurrency) : undefined;
+    if (concurrency !== undefined &&
+        (!Number.isFinite(concurrency) || concurrency <= 0)) {
+        throw new Error("--concurrency must be > 0");
+    }
+    const authStorage = discoverAuthStorage(resolveClawdbotAgentDir());
+    const storedKey = await authStorage.getApiKey("openrouter");
+    const results = await scanOpenRouterModels({
+        apiKey: storedKey ?? undefined,
+        minParamB: minParams,
+        maxAgeDays,
+        providerFilter: opts.provider,
+        timeoutMs: timeout,
+        concurrency,
+    });
+    const toolOk = results.filter((entry) => entry.tool.ok);
+    if (toolOk.length === 0) {
+        throw new Error("No tool-capable OpenRouter free models found.");
+    }
+    const sorted = sortScanResults(results);
+    const toolSorted = sortScanResults(toolOk);
+    const imageOk = results.filter((entry) => entry.image.ok);
+    const imageSorted = sortImageResults(imageOk);
+    const imagePreferred = toolSorted.filter((entry) => entry.image.ok);
+    const preselectPool = imagePreferred.length > 0 ? imagePreferred : toolSorted;
+    const preselected = preselectPool
+        .slice(0, Math.floor(maxCandidates))
+        .map((entry) => entry.modelRef);
+    const imagePreselected = imageSorted
+        .slice(0, Math.floor(maxCandidates))
+        .map((entry) => entry.modelRef);
+    if (!opts.json) {
+        printScanSummary(results, runtime);
+        printScanTable(sorted, runtime);
+    }
+    const noInput = opts.input === false;
+    const canPrompt = process.stdin.isTTY && !opts.yes && !noInput && !opts.json;
+    let selected = preselected;
+    let selectedImages = imagePreselected;
+    if (canPrompt) {
+        const selection = await multiselect({
+            message: "Select fallback models (ordered)",
+            options: toolSorted.map((entry) => ({
+                value: entry.modelRef,
+                label: entry.modelRef,
+                hint: buildScanHint(entry),
+            })),
+            initialValues: preselected,
+        });
+        if (isCancel(selection)) {
+            cancel("Model scan cancelled.");
+            runtime.exit(0);
+        }
+        selected = selection;
+        if (imageSorted.length > 0) {
+            const imageSelection = await multiselect({
+                message: "Select image fallback models (ordered)",
+                options: imageSorted.map((entry) => ({
+                    value: entry.modelRef,
+                    label: entry.modelRef,
+                    hint: buildScanHint(entry),
+                })),
+                initialValues: imagePreselected,
+            });
+            if (isCancel(imageSelection)) {
+                cancel("Model scan cancelled.");
+                runtime.exit(0);
+            }
+            selectedImages = imageSelection;
+        }
+    }
+    else if (!process.stdin.isTTY && !opts.yes && !noInput && !opts.json) {
+        throw new Error("Non-interactive scan: pass --yes to apply defaults.");
+    }
+    if (selected.length === 0) {
+        throw new Error("No models selected for fallbacks.");
+    }
+    if (opts.setImage && selectedImages.length === 0) {
+        throw new Error("No image-capable models selected for image model.");
+    }
+    const updated = await updateConfig((cfg) => {
+        const agent = {
+            ...cfg.agent,
+            modelFallbacks: selected,
+            ...(opts.setDefault ? { model: selected[0] } : {}),
+            ...(opts.setImage && selectedImages.length > 0
+                ? { imageModel: selectedImages[0] }
+                : {}),
+        };
+        if (imageSorted.length > 0) {
+            agent.imageModelFallbacks = selectedImages;
+        }
+        return {
+            ...cfg,
+            agent,
+        };
+    });
+    const allowlist = buildAllowlistSet(updated);
+    const allowlistMissing = allowlist.size > 0 ? selected.filter((entry) => !allowlist.has(entry)) : [];
+    const allowlistMissingImages = allowlist.size > 0
+        ? selectedImages.filter((entry) => !allowlist.has(entry))
+        : [];
+    if (opts.json) {
+        runtime.log(JSON.stringify({
+            selected,
+            selectedImages,
+            setDefault: Boolean(opts.setDefault),
+            setImage: Boolean(opts.setImage),
+            results,
+            warnings: allowlistMissing.length > 0 || allowlistMissingImages.length > 0
+                ? [
+                    ...(allowlistMissing.length > 0
+                        ? [
+                            `Selected models not in agent.allowedModels: ${allowlistMissing.join(", ")}`,
+                        ]
+                        : []),
+                    ...(allowlistMissingImages.length > 0
+                        ? [
+                            `Selected image models not in agent.allowedModels: ${allowlistMissingImages.join(", ")}`,
+                        ]
+                        : []),
+                ]
+                : [],
+        }, null, 2));
+        return;
+    }
+    if (allowlistMissing.length > 0) {
+        runtime.log(warn(`Warning: ${allowlistMissing.length} selected models are not in agent.allowedModels and will be ignored by fallback: ${allowlistMissing.join(", ")}`));
+    }
+    if (allowlistMissingImages.length > 0) {
+        runtime.log(warn(`Warning: ${allowlistMissingImages.length} selected image models are not in agent.allowedModels and will be ignored by fallback: ${allowlistMissingImages.join(", ")}`));
+    }
+    runtime.log(`Updated ${CONFIG_PATH_CLAWDBOT}`);
+    runtime.log(`Fallbacks: ${selected.join(", ")}`);
+    if (selectedImages.length > 0) {
+        runtime.log(`Image fallbacks: ${selectedImages.join(", ")}`);
+    }
+    if (opts.setDefault) {
+        runtime.log(`Default model: ${selected[0]}`);
+    }
+    if (opts.setImage && selectedImages.length > 0) {
+        runtime.log(`Image model: ${selectedImages[0]}`);
+    }
+}

package/dist/commands/models/set-image.js

@@ -0,0 +1,23 @@
+import { CONFIG_PATH_CLAWDBOT } from "../../config/config.js";
+import { buildAllowlistSet, modelKey, resolveModelTarget, updateConfig, } from "./shared.js";
+export async function modelsSetImageCommand(modelRaw, runtime) {
+    const updated = await updateConfig((cfg) => {
+        const resolved = resolveModelTarget({ raw: modelRaw, cfg });
+        const allowlist = buildAllowlistSet(cfg);
+        if (allowlist.size > 0) {
+            const key = modelKey(resolved.provider, resolved.model);
+            if (!allowlist.has(key)) {
+                throw new Error(`Model ${key} is not in agent.allowedModels.`);
+            }
+        }
+        return {
+            ...cfg,
+            agent: {
+                ...cfg.agent,
+                imageModel: `${resolved.provider}/${resolved.model}`,
+            },
+        };
+    });
+    runtime.log(`Updated ${CONFIG_PATH_CLAWDBOT}`);
+    runtime.log(`Image model: ${updated.agent?.imageModel ?? modelRaw}`);
+}

package/dist/commands/models/set.js

@@ -0,0 +1,23 @@
+import { CONFIG_PATH_CLAWDBOT } from "../../config/config.js";
+import { buildAllowlistSet, modelKey, resolveModelTarget, updateConfig, } from "./shared.js";
+export async function modelsSetCommand(modelRaw, runtime) {
+    const updated = await updateConfig((cfg) => {
+        const resolved = resolveModelTarget({ raw: modelRaw, cfg });
+        const allowlist = buildAllowlistSet(cfg);
+        if (allowlist.size > 0) {
+            const key = modelKey(resolved.provider, resolved.model);
+            if (!allowlist.has(key)) {
+                throw new Error(`Model ${key} is not in agent.allowedModels.`);
+            }
+        }
+        return {
+            ...cfg,
+            agent: {
+                ...cfg.agent,
+                model: `${resolved.provider}/${resolved.model}`,
+            },
+        };
+    });
+    runtime.log(`Updated ${CONFIG_PATH_CLAWDBOT}`);
+    runtime.log(`Default model: ${updated.agent?.model ?? modelRaw}`);
+}

package/dist/commands/models/shared.js

@@ -0,0 +1,72 @@
+import { DEFAULT_MODEL, DEFAULT_PROVIDER } from "../../agents/defaults.js";
+import { buildModelAliasIndex, modelKey, parseModelRef, resolveModelRefFromString, } from "../../agents/model-selection.js";
+import { readConfigFileSnapshot, writeConfigFile, } from "../../config/config.js";
+export const ensureFlagCompatibility = (opts) => {
+    if (opts.json && opts.plain) {
+        throw new Error("Choose either --json or --plain, not both.");
+    }
+};
+export const formatTokenK = (value) => {
+    if (!value || !Number.isFinite(value))
+        return "-";
+    if (value < 1024)
+        return `${Math.round(value)}`;
+    return `${Math.round(value / 1024)}k`;
+};
+export const formatMs = (value) => {
+    if (value === null || value === undefined)
+        return "-";
+    if (!Number.isFinite(value))
+        return "-";
+    if (value < 1000)
+        return `${Math.round(value)}ms`;
+    return `${Math.round(value / 100) / 10}s`;
+};
+export async function updateConfig(mutator) {
+    const snapshot = await readConfigFileSnapshot();
+    if (!snapshot.valid) {
+        const issues = snapshot.issues
+            .map((issue) => `- ${issue.path}: ${issue.message}`)
+            .join("\n");
+        throw new Error(`Invalid config at ${snapshot.path}\n${issues}`);
+    }
+    const next = mutator(snapshot.config);
+    await writeConfigFile(next);
+    return next;
+}
+export function resolveModelTarget(params) {
+    const aliasIndex = buildModelAliasIndex({
+        cfg: params.cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+    });
+    const resolved = resolveModelRefFromString({
+        raw: params.raw,
+        defaultProvider: DEFAULT_PROVIDER,
+        aliasIndex,
+    });
+    if (!resolved) {
+        throw new Error(`Invalid model reference: ${params.raw}`);
+    }
+    return resolved.ref;
+}
+export function buildAllowlistSet(cfg) {
+    const allowed = new Set();
+    for (const raw of cfg.agent?.allowedModels ?? []) {
+        const parsed = parseModelRef(String(raw ?? ""), DEFAULT_PROVIDER);
+        if (!parsed)
+            continue;
+        allowed.add(modelKey(parsed.provider, parsed.model));
+    }
+    return allowed;
+}
+export function normalizeAlias(alias) {
+    const trimmed = alias.trim();
+    if (!trimmed)
+        throw new Error("Alias cannot be empty.");
+    if (!/^[A-Za-z0-9_.:-]+$/.test(trimmed)) {
+        throw new Error("Alias must use letters, numbers, dots, underscores, colons, or dashes.");
+    }
+    return trimmed;
+}
+export { modelKey };
+export { DEFAULT_MODEL, DEFAULT_PROVIDER };

package/dist/commands/models.js

@@ -0,0 +1,7 @@
+export { modelsAliasesAddCommand, modelsAliasesListCommand, modelsAliasesRemoveCommand, } from "./models/aliases.js";
+export { modelsFallbacksAddCommand, modelsFallbacksClearCommand, modelsFallbacksListCommand, modelsFallbacksRemoveCommand, } from "./models/fallbacks.js";
+export { modelsImageFallbacksAddCommand, modelsImageFallbacksClearCommand, modelsImageFallbacksListCommand, modelsImageFallbacksRemoveCommand, } from "./models/image-fallbacks.js";
+export { modelsListCommand, modelsStatusCommand } from "./models/list.js";
+export { modelsScanCommand } from "./models/scan.js";
+export { modelsSetCommand } from "./models/set.js";
+export { modelsSetImageCommand } from "./models/set-image.js";

package/dist/commands/onboard-auth.js

@@ -0,0 +1,70 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import { discoverAuthStorage } from "@mariozechner/pi-coding-agent";
+import { resolveClawdbotAgentDir } from "../agents/agent-paths.js";
+import { resolveOAuthPath } from "../config/paths.js";
+export async function writeOAuthCredentials(provider, creds) {
+    const filePath = resolveOAuthPath();
+    const dir = path.dirname(filePath);
+    await fs.mkdir(dir, { recursive: true, mode: 0o700 });
+    let storage = {};
+    try {
+        const raw = await fs.readFile(filePath, "utf8");
+        const parsed = JSON.parse(raw);
+        if (parsed && typeof parsed === "object")
+            storage = parsed;
+    }
+    catch {
+        // ignore
+    }
+    storage[provider] = creds;
+    await fs.writeFile(filePath, `${JSON.stringify(storage, null, 2)}\n`, "utf8");
+    await fs.chmod(filePath, 0o600);
+}
+export async function setAnthropicApiKey(key) {
+    const agentDir = resolveClawdbotAgentDir();
+    const authStorage = discoverAuthStorage(agentDir);
+    authStorage.set("anthropic", { type: "api_key", key });
+}
+export function applyMinimaxConfig(cfg) {
+    const allowed = new Set(cfg.agent?.allowedModels ?? []);
+    allowed.add("anthropic/claude-opus-4-5");
+    allowed.add("lmstudio/minimax-m2.1-gs32");
+    const aliases = { ...cfg.agent?.modelAliases };
+    if (!aliases.Opus)
+        aliases.Opus = "anthropic/claude-opus-4-5";
+    if (!aliases.Minimax)
+        aliases.Minimax = "lmstudio/minimax-m2.1-gs32";
+    const providers = { ...cfg.models?.providers };
+    if (!providers.lmstudio) {
+        providers.lmstudio = {
+            baseUrl: "http://127.0.0.1:1234/v1",
+            apiKey: "lmstudio",
+            api: "openai-responses",
+            models: [
+                {
+                    id: "minimax-m2.1-gs32",
+                    name: "MiniMax M2.1 GS32",
+                    reasoning: false,
+                    input: ["text"],
+                    cost: { input: 0, output: 0, cacheRead: 0, cacheWrite: 0 },
+                    contextWindow: 196608,
+                    maxTokens: 8192,
+                },
+            ],
+        };
+    }
+    return {
+        ...cfg,
+        agent: {
+            ...cfg.agent,
+            model: "Minimax",
+            allowedModels: Array.from(allowed),
+            modelAliases: aliases,
+        },
+        models: {
+            mode: cfg.models?.mode ?? "merge",
+            providers,
+        },
+    };
+}