clawdbot 2026.1.4-1

package/dist/commands/doctor.js

@@ -0,0 +1,484 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import { confirm, intro, note, outro } from "@clack/prompts";
+import { DEFAULT_SANDBOX_BROWSER_IMAGE, DEFAULT_SANDBOX_COMMON_IMAGE, DEFAULT_SANDBOX_IMAGE, } from "../agents/sandbox.js";
+import { buildWorkspaceSkillStatus } from "../agents/skills-status.js";
+import { CONFIG_PATH_CLAWDBOT, createConfigIO, migrateLegacyConfig, readConfigFileSnapshot, writeConfigFile, } from "../config/config.js";
+import { resolveGatewayPort, resolveIsNixMode } from "../config/paths.js";
+import { GATEWAY_LAUNCH_AGENT_LABEL } from "../daemon/constants.js";
+import { findLegacyGatewayServices, uninstallLegacyGatewayServices, } from "../daemon/legacy.js";
+import { resolveGatewayProgramArguments } from "../daemon/program-args.js";
+import { resolveGatewayService } from "../daemon/service.js";
+import { runCommandWithTimeout, runExec } from "../process/exec.js";
+import { defaultRuntime } from "../runtime.js";
+import { resolveUserPath, sleep } from "../utils.js";
+import { healthCommand } from "./health.js";
+import { applyWizardMetadata, DEFAULT_WORKSPACE, guardCancel, printWizardHeader, } from "./onboard-helpers.js";
+function resolveMode(cfg) {
+    return cfg.gateway?.mode === "remote" ? "remote" : "local";
+}
+function resolveLegacyConfigPath(env) {
+    const override = env.CLAWDIS_CONFIG_PATH?.trim();
+    if (override)
+        return override;
+    return path.join(os.homedir(), ".clawdis", "clawdis.json");
+}
+function replacePathSegment(value, from, to) {
+    if (!value)
+        return value;
+    const pattern = new RegExp(`(^|[\\/])${from}([\\/]|$)`, "g");
+    if (!pattern.test(value))
+        return value;
+    return value.replace(pattern, `$1${to}$2`);
+}
+function replaceLegacyName(value) {
+    if (!value)
+        return value;
+    const replacedClawdis = value.replace(/clawdis/g, "clawdbot");
+    return replacedClawdis.replace(/clawd(?!bot)/g, "clawdbot");
+}
+function replaceModernName(value) {
+    if (!value)
+        return value;
+    if (!value.includes("clawdbot"))
+        return value;
+    return value.replace(/clawdbot/g, "clawdis");
+}
+function resolveSandboxScript(scriptRel) {
+    const candidates = new Set();
+    candidates.add(process.cwd());
+    const argv1 = process.argv[1];
+    if (argv1) {
+        const normalized = path.resolve(argv1);
+        candidates.add(path.resolve(path.dirname(normalized), ".."));
+        candidates.add(path.resolve(path.dirname(normalized)));
+    }
+    for (const root of candidates) {
+        const scriptPath = path.join(root, scriptRel);
+        if (fs.existsSync(scriptPath)) {
+            return { scriptPath, cwd: root };
+        }
+    }
+    return null;
+}
+async function runSandboxScript(scriptRel, runtime) {
+    const script = resolveSandboxScript(scriptRel);
+    if (!script) {
+        note(`Unable to locate ${scriptRel}. Run it from the repo root.`, "Sandbox");
+        return false;
+    }
+    runtime.log(`Running ${scriptRel}...`);
+    const result = await runCommandWithTimeout(["bash", script.scriptPath], {
+        timeoutMs: 20 * 60 * 1000,
+        cwd: script.cwd,
+    });
+    if (result.code !== 0) {
+        runtime.error(`Failed running ${scriptRel}: ${result.stderr.trim() || result.stdout.trim() || "unknown error"}`);
+        return false;
+    }
+    runtime.log(`Completed ${scriptRel}.`);
+    return true;
+}
+async function isDockerAvailable() {
+    try {
+        await runExec("docker", ["version", "--format", "{{.Server.Version}}"], {
+            timeoutMs: 5_000,
+        });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+async function dockerImageExists(image) {
+    try {
+        await runExec("docker", ["image", "inspect", image], { timeoutMs: 5_000 });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function resolveSandboxDockerImage(cfg) {
+    const image = cfg.agent?.sandbox?.docker?.image?.trim();
+    return image ? image : DEFAULT_SANDBOX_IMAGE;
+}
+function resolveSandboxBrowserImage(cfg) {
+    const image = cfg.agent?.sandbox?.browser?.image?.trim();
+    return image ? image : DEFAULT_SANDBOX_BROWSER_IMAGE;
+}
+function updateSandboxDockerImage(cfg, image) {
+    return {
+        ...cfg,
+        agent: {
+            ...cfg.agent,
+            sandbox: {
+                ...cfg.agent?.sandbox,
+                docker: {
+                    ...cfg.agent?.sandbox?.docker,
+                    image,
+                },
+            },
+        },
+    };
+}
+function updateSandboxBrowserImage(cfg, image) {
+    return {
+        ...cfg,
+        agent: {
+            ...cfg.agent,
+            sandbox: {
+                ...cfg.agent?.sandbox,
+                browser: {
+                    ...cfg.agent?.sandbox?.browser,
+                    image,
+                },
+            },
+        },
+    };
+}
+async function handleMissingSandboxImage(params, runtime) {
+    const exists = await dockerImageExists(params.image);
+    if (exists)
+        return;
+    const buildHint = params.buildScript
+        ? `Build it with ${params.buildScript}.`
+        : "Build or pull it first.";
+    note(`Sandbox ${params.label} image missing: ${params.image}. ${buildHint}`, "Sandbox");
+    let built = false;
+    if (params.buildScript) {
+        const build = guardCancel(await confirm({
+            message: `Build ${params.label} sandbox image now?`,
+            initialValue: true,
+        }), runtime);
+        if (build) {
+            built = await runSandboxScript(params.buildScript, runtime);
+        }
+    }
+    if (built)
+        return;
+    const legacyImage = replaceModernName(params.image);
+    if (!legacyImage || legacyImage === params.image)
+        return;
+    const legacyExists = await dockerImageExists(legacyImage);
+    if (!legacyExists)
+        return;
+    const fallback = guardCancel(await confirm({
+        message: `Switch config to legacy image ${legacyImage}?`,
+        initialValue: false,
+    }), runtime);
+    if (!fallback)
+        return;
+    params.updateConfig(legacyImage);
+}
+async function maybeRepairSandboxImages(cfg, runtime) {
+    const sandbox = cfg.agent?.sandbox;
+    const mode = sandbox?.mode ?? "off";
+    if (!sandbox || mode === "off")
+        return cfg;
+    const dockerAvailable = await isDockerAvailable();
+    if (!dockerAvailable) {
+        note("Docker not available; skipping sandbox image checks.", "Sandbox");
+        return cfg;
+    }
+    let next = cfg;
+    const changes = [];
+    const dockerImage = resolveSandboxDockerImage(cfg);
+    await handleMissingSandboxImage({
+        label: "base",
+        image: dockerImage,
+        buildScript: dockerImage === DEFAULT_SANDBOX_COMMON_IMAGE
+            ? "scripts/sandbox-common-setup.sh"
+            : dockerImage === DEFAULT_SANDBOX_IMAGE
+                ? "scripts/sandbox-setup.sh"
+                : undefined,
+        updateConfig: (image) => {
+            next = updateSandboxDockerImage(next, image);
+            changes.push(`Updated agent.sandbox.docker.image → ${image}`);
+        },
+    }, runtime);
+    if (sandbox.browser?.enabled) {
+        await handleMissingSandboxImage({
+            label: "browser",
+            image: resolveSandboxBrowserImage(cfg),
+            buildScript: "scripts/sandbox-browser-setup.sh",
+            updateConfig: (image) => {
+                next = updateSandboxBrowserImage(next, image);
+                changes.push(`Updated agent.sandbox.browser.image → ${image}`);
+            },
+        }, runtime);
+    }
+    if (changes.length > 0) {
+        note(changes.join("\n"), "Doctor changes");
+    }
+    return next;
+}
+function normalizeLegacyConfigValues(cfg) {
+    const changes = [];
+    let next = cfg;
+    const workspace = cfg.agent?.workspace;
+    const updatedWorkspace = replacePathSegment(replacePathSegment(workspace, "clawdis", "clawdbot"), "clawd", "clawdbot");
+    if (updatedWorkspace && updatedWorkspace !== workspace) {
+        next = {
+            ...next,
+            agent: {
+                ...next.agent,
+                workspace: updatedWorkspace,
+            },
+        };
+        changes.push(`Updated agent.workspace → ${updatedWorkspace}`);
+    }
+    const workspaceRoot = cfg.agent?.sandbox?.workspaceRoot;
+    const updatedWorkspaceRoot = replacePathSegment(replacePathSegment(workspaceRoot, "clawdis", "clawdbot"), "clawd", "clawdbot");
+    if (updatedWorkspaceRoot && updatedWorkspaceRoot !== workspaceRoot) {
+        next = {
+            ...next,
+            agent: {
+                ...next.agent,
+                sandbox: {
+                    ...next.agent?.sandbox,
+                    workspaceRoot: updatedWorkspaceRoot,
+                },
+            },
+        };
+        changes.push(`Updated agent.sandbox.workspaceRoot → ${updatedWorkspaceRoot}`);
+    }
+    const dockerImage = cfg.agent?.sandbox?.docker?.image;
+    const updatedDockerImage = replaceLegacyName(dockerImage);
+    if (updatedDockerImage && updatedDockerImage !== dockerImage) {
+        next = {
+            ...next,
+            agent: {
+                ...next.agent,
+                sandbox: {
+                    ...next.agent?.sandbox,
+                    docker: {
+                        ...next.agent?.sandbox?.docker,
+                        image: updatedDockerImage,
+                    },
+                },
+            },
+        };
+        changes.push(`Updated agent.sandbox.docker.image → ${updatedDockerImage}`);
+    }
+    const containerPrefix = cfg.agent?.sandbox?.docker?.containerPrefix;
+    const updatedContainerPrefix = replaceLegacyName(containerPrefix);
+    if (updatedContainerPrefix && updatedContainerPrefix !== containerPrefix) {
+        next = {
+            ...next,
+            agent: {
+                ...next.agent,
+                sandbox: {
+                    ...next.agent?.sandbox,
+                    docker: {
+                        ...next.agent?.sandbox?.docker,
+                        containerPrefix: updatedContainerPrefix,
+                    },
+                },
+            },
+        };
+        changes.push(`Updated agent.sandbox.docker.containerPrefix → ${updatedContainerPrefix}`);
+    }
+    return { config: next, changes };
+}
+async function maybeMigrateLegacyConfigFile(runtime) {
+    const legacyConfigPath = resolveLegacyConfigPath(process.env);
+    if (legacyConfigPath === CONFIG_PATH_CLAWDBOT)
+        return;
+    const legacyIo = createConfigIO({ configPath: legacyConfigPath });
+    const legacySnapshot = await legacyIo.readConfigFileSnapshot();
+    if (!legacySnapshot.exists)
+        return;
+    const currentSnapshot = await readConfigFileSnapshot();
+    if (currentSnapshot.exists) {
+        note(`Legacy config still exists at ${legacyConfigPath}. Current config at ${CONFIG_PATH_CLAWDBOT}.`, "Legacy config");
+        return;
+    }
+    const gatewayMode = typeof legacySnapshot.parsed?.gateway?.mode === "string"
+        ? legacySnapshot.parsed.gateway?.mode
+        : undefined;
+    const gatewayBind = typeof legacySnapshot.parsed?.gateway?.bind === "string"
+        ? legacySnapshot.parsed.gateway?.bind
+        : undefined;
+    const agentWorkspace = typeof legacySnapshot.parsed?.agent?.workspace ===
+        "string"
+        ? legacySnapshot.parsed.agent?.workspace
+        : undefined;
+    note([
+        `- File exists at ${legacyConfigPath}`,
+        gatewayMode ? `- gateway.mode: ${gatewayMode}` : undefined,
+        gatewayBind ? `- gateway.bind: ${gatewayBind}` : undefined,
+        agentWorkspace ? `- agent.workspace: ${agentWorkspace}` : undefined,
+    ]
+        .filter(Boolean)
+        .join("\n"), "Legacy Clawdis config detected");
+    let nextConfig = legacySnapshot.valid ? legacySnapshot.config : null;
+    const { config: migratedConfig, changes } = migrateLegacyConfig(legacySnapshot.parsed);
+    if (migratedConfig) {
+        nextConfig = migratedConfig;
+    }
+    else if (!nextConfig) {
+        note(`Legacy config at ${legacyConfigPath} is invalid; skipping migration.`, "Legacy config");
+        return;
+    }
+    const normalized = normalizeLegacyConfigValues(nextConfig);
+    const mergedChanges = [...changes, ...normalized.changes];
+    if (mergedChanges.length > 0) {
+        note(mergedChanges.join("\n"), "Doctor changes");
+    }
+    await writeConfigFile(normalized.config);
+    runtime.log(`Migrated legacy config to ${CONFIG_PATH_CLAWDBOT}`);
+}
+async function maybeMigrateLegacyGatewayService(cfg, runtime) {
+    const legacyServices = await findLegacyGatewayServices(process.env);
+    if (legacyServices.length === 0)
+        return;
+    note(legacyServices
+        .map((svc) => `- ${svc.label} (${svc.platform}, ${svc.detail})`)
+        .join("\n"), "Legacy Clawdis services detected");
+    const migrate = guardCancel(await confirm({
+        message: "Migrate legacy Clawdis services to Clawdbot now?",
+        initialValue: true,
+    }), runtime);
+    if (!migrate)
+        return;
+    try {
+        await uninstallLegacyGatewayServices({
+            env: process.env,
+            stdout: process.stdout,
+        });
+    }
+    catch (err) {
+        runtime.error(`Legacy service cleanup failed: ${String(err)}`);
+        return;
+    }
+    if (resolveIsNixMode(process.env)) {
+        note("Nix mode detected; skip installing services.", "Gateway");
+        return;
+    }
+    if (resolveMode(cfg) === "remote") {
+        note("Gateway mode is remote; skipped local service install.", "Gateway");
+        return;
+    }
+    const service = resolveGatewayService();
+    const loaded = await service.isLoaded({ env: process.env });
+    if (loaded) {
+        note(`Clawdbot ${service.label} already ${service.loadedText}.`, "Gateway");
+        return;
+    }
+    const install = guardCancel(await confirm({
+        message: "Install Clawdbot gateway service now?",
+        initialValue: true,
+    }), runtime);
+    if (!install)
+        return;
+    const devMode = process.argv[1]?.includes(`${path.sep}src${path.sep}`) &&
+        process.argv[1]?.endsWith(".ts");
+    const port = resolveGatewayPort(cfg, process.env);
+    const { programArguments, workingDirectory } = await resolveGatewayProgramArguments({ port, dev: devMode });
+    const environment = {
+        PATH: process.env.PATH,
+        CLAWDBOT_GATEWAY_TOKEN: cfg.gateway?.auth?.token ?? process.env.CLAWDBOT_GATEWAY_TOKEN,
+        CLAWDBOT_LAUNCHD_LABEL: process.platform === "darwin" ? GATEWAY_LAUNCH_AGENT_LABEL : undefined,
+    };
+    await service.install({
+        env: process.env,
+        stdout: process.stdout,
+        programArguments,
+        workingDirectory,
+        environment,
+    });
+}
+export async function doctorCommand(runtime = defaultRuntime) {
+    printWizardHeader(runtime);
+    intro("Clawdbot doctor");
+    await maybeMigrateLegacyConfigFile(runtime);
+    const snapshot = await readConfigFileSnapshot();
+    let cfg = snapshot.valid ? snapshot.config : {};
+    if (snapshot.exists &&
+        !snapshot.valid &&
+        snapshot.legacyIssues.length === 0) {
+        note("Config invalid; doctor will run with defaults.", "Config");
+    }
+    if (snapshot.legacyIssues.length > 0) {
+        note(snapshot.legacyIssues
+            .map((issue) => `- ${issue.path}: ${issue.message}`)
+            .join("\n"), "Legacy config keys detected");
+        const migrate = guardCancel(await confirm({
+            message: "Migrate legacy config entries now?",
+            initialValue: true,
+        }), runtime);
+        if (migrate) {
+            // Legacy migration (2026-01-02, commit: 16420e5b) — normalize per-provider allowlists; move WhatsApp gating into whatsapp.allowFrom.
+            const { config: migrated, changes } = migrateLegacyConfig(snapshot.parsed);
+            if (changes.length > 0) {
+                note(changes.join("\n"), "Doctor changes");
+            }
+            if (migrated) {
+                cfg = migrated;
+            }
+        }
+    }
+    const normalized = normalizeLegacyConfigValues(cfg);
+    if (normalized.changes.length > 0) {
+        note(normalized.changes.join("\n"), "Doctor changes");
+        cfg = normalized.config;
+    }
+    cfg = await maybeRepairSandboxImages(cfg, runtime);
+    await maybeMigrateLegacyGatewayService(cfg, runtime);
+    const workspaceDir = resolveUserPath(cfg.agent?.workspace ?? DEFAULT_WORKSPACE);
+    const skillsReport = buildWorkspaceSkillStatus(workspaceDir, { config: cfg });
+    note([
+        `Eligible: ${skillsReport.skills.filter((s) => s.eligible).length}`,
+        `Missing requirements: ${skillsReport.skills.filter((s) => !s.eligible && !s.disabled && !s.blockedByAllowlist).length}`,
+        `Blocked by allowlist: ${skillsReport.skills.filter((s) => s.blockedByAllowlist).length}`,
+    ].join("\n"), "Skills status");
+    let healthOk = false;
+    try {
+        await healthCommand({ json: false, timeoutMs: 10_000 }, runtime);
+        healthOk = true;
+    }
+    catch (err) {
+        const message = String(err);
+        if (message.includes("gateway closed")) {
+            note("Gateway not running.", "Gateway");
+        }
+        else {
+            runtime.error(`Health check failed: ${message}`);
+        }
+    }
+    if (!healthOk) {
+        const service = resolveGatewayService();
+        const loaded = await service.isLoaded({ env: process.env });
+        if (!loaded) {
+            note("Gateway daemon not installed.", "Gateway");
+        }
+        else {
+            const restart = guardCancel(await confirm({
+                message: "Restart gateway daemon now?",
+                initialValue: true,
+            }), runtime);
+            if (restart) {
+                await service.restart({ stdout: process.stdout });
+                await sleep(1500);
+                try {
+                    await healthCommand({ json: false, timeoutMs: 10_000 }, runtime);
+                }
+                catch (err) {
+                    const message = String(err);
+                    if (message.includes("gateway closed")) {
+                        note("Gateway not running.", "Gateway");
+                    }
+                    else {
+                        runtime.error(`Health check failed: ${message}`);
+                    }
+                }
+            }
+        }
+    }
+    cfg = applyWizardMetadata(cfg, { command: "doctor", mode: resolveMode(cfg) });
+    await writeConfigFile(cfg);
+    runtime.log(`Updated ${CONFIG_PATH_CLAWDBOT}`);
+    outro("Doctor complete.");
+}

package/dist/commands/health.js

@@ -0,0 +1,108 @@
+import { loadConfig } from "../config/config.js";
+import { loadSessionStore, resolveStorePath } from "../config/sessions.js";
+import { probeDiscord } from "../discord/probe.js";
+import { callGateway } from "../gateway/call.js";
+import { info } from "../globals.js";
+import { probeTelegram } from "../telegram/probe.js";
+import { resolveTelegramToken } from "../telegram/token.js";
+import { resolveHeartbeatSeconds } from "../web/reconnect.js";
+import { getWebAuthAgeMs, logWebSelfId, webAuthExists, } from "../web/session.js";
+const DEFAULT_TIMEOUT_MS = 10_000;
+export async function getHealthSnapshot(timeoutMs) {
+    const cfg = loadConfig();
+    const linked = await webAuthExists();
+    const authAgeMs = getWebAuthAgeMs();
+    const heartbeatSeconds = resolveHeartbeatSeconds(cfg, undefined);
+    const storePath = resolveStorePath(cfg.session?.store);
+    const store = loadSessionStore(storePath);
+    const sessions = Object.entries(store)
+        .filter(([key]) => key !== "global" && key !== "unknown")
+        .map(([key, entry]) => ({ key, updatedAt: entry?.updatedAt ?? 0 }))
+        .sort((a, b) => b.updatedAt - a.updatedAt);
+    const recent = sessions.slice(0, 5).map((s) => ({
+        key: s.key,
+        updatedAt: s.updatedAt || null,
+        age: s.updatedAt ? Date.now() - s.updatedAt : null,
+    }));
+    const start = Date.now();
+    const cappedTimeout = Math.max(1000, timeoutMs ?? DEFAULT_TIMEOUT_MS);
+    const { token: telegramToken } = resolveTelegramToken(cfg);
+    const telegramConfigured = telegramToken.trim().length > 0;
+    const telegramProxy = cfg.telegram?.proxy;
+    const telegramProbe = telegramConfigured
+        ? await probeTelegram(telegramToken.trim(), cappedTimeout, telegramProxy)
+        : undefined;
+    const discordToken = process.env.DISCORD_BOT_TOKEN ?? cfg.discord?.token ?? "";
+    const discordConfigured = discordToken.trim().length > 0;
+    const discordProbe = discordConfigured
+        ? await probeDiscord(discordToken.trim(), cappedTimeout)
+        : undefined;
+    const summary = {
+        ok: true,
+        ts: Date.now(),
+        durationMs: Date.now() - start,
+        web: { linked, authAgeMs },
+        telegram: { configured: telegramConfigured, probe: telegramProbe },
+        discord: { configured: discordConfigured, probe: discordProbe },
+        heartbeatSeconds,
+        sessions: {
+            path: storePath,
+            count: sessions.length,
+            recent,
+        },
+    };
+    return summary;
+}
+export async function healthCommand(opts, runtime) {
+    // Always query the running gateway; do not open a direct Baileys socket here.
+    const summary = await callGateway({
+        method: "health",
+        timeoutMs: opts.timeoutMs,
+    });
+    // Gateway reachability defines success; provider issues are reported but not fatal here.
+    const fatal = false;
+    if (opts.json) {
+        runtime.log(JSON.stringify(summary, null, 2));
+    }
+    else {
+        runtime.log(summary.web.linked
+            ? `Web: linked (auth age ${summary.web.authAgeMs ? `${Math.round(summary.web.authAgeMs / 60000)}m` : "unknown"})`
+            : "Web: not linked (run clawdbot login)");
+        if (summary.web.linked) {
+            logWebSelfId(runtime, true);
+        }
+        if (summary.web.connect) {
+            const base = summary.web.connect.ok
+                ? info(`Connect: ok (${summary.web.connect.elapsedMs}ms)`)
+                : `Connect: failed (${summary.web.connect.status ?? "unknown"})`;
+            runtime.log(base +
+                (summary.web.connect.error ? ` - ${summary.web.connect.error}` : ""));
+        }
+        const tgLabel = summary.telegram.configured
+            ? summary.telegram.probe?.ok
+                ? info(`Telegram: ok${summary.telegram.probe.bot?.username ? ` (@${summary.telegram.probe.bot.username})` : ""} (${summary.telegram.probe.elapsedMs}ms)` +
+                    (summary.telegram.probe.webhook?.url
+                        ? ` - webhook ${summary.telegram.probe.webhook.url}`
+                        : ""))
+                : `Telegram: failed (${summary.telegram.probe?.status ?? "unknown"})${summary.telegram.probe?.error ? ` - ${summary.telegram.probe.error}` : ""}`
+            : "Telegram: not configured";
+        runtime.log(tgLabel);
+        const discordLabel = summary.discord.configured
+            ? summary.discord.probe?.ok
+                ? info(`Discord: ok${summary.discord.probe.bot?.username ? ` (@${summary.discord.probe.bot.username})` : ""} (${summary.discord.probe.elapsedMs}ms)`)
+                : `Discord: failed (${summary.discord.probe?.status ?? "unknown"})${summary.discord.probe?.error ? ` - ${summary.discord.probe.error}` : ""}`
+            : "Discord: not configured";
+        runtime.log(discordLabel);
+        runtime.log(info(`Heartbeat interval: ${summary.heartbeatSeconds}s`));
+        runtime.log(info(`Session store: ${summary.sessions.path} (${summary.sessions.count} entries)`));
+        if (summary.sessions.recent.length > 0) {
+            runtime.log("Recent sessions:");
+            for (const r of summary.sessions.recent) {
+                runtime.log(`- ${r.key} (${r.updatedAt ? `${Math.round((Date.now() - r.updatedAt) / 60000)}m ago` : "no activity"})`);
+            }
+        }
+    }
+    if (fatal) {
+        runtime.exit(1);
+    }
+}

package/dist/commands/models/aliases.js

@@ -0,0 +1,64 @@
+import { CONFIG_PATH_CLAWDBOT, loadConfig } from "../../config/config.js";
+import { ensureFlagCompatibility, normalizeAlias, resolveModelTarget, updateConfig, } from "./shared.js";
+export async function modelsAliasesListCommand(opts, runtime) {
+    ensureFlagCompatibility(opts);
+    const cfg = loadConfig();
+    const aliases = cfg.agent?.modelAliases ?? {};
+    if (opts.json) {
+        runtime.log(JSON.stringify({ aliases }, null, 2));
+        return;
+    }
+    if (opts.plain) {
+        for (const [alias, target] of Object.entries(aliases)) {
+            runtime.log(`${alias} ${target}`);
+        }
+        return;
+    }
+    runtime.log(`Aliases (${Object.keys(aliases).length}):`);
+    if (Object.keys(aliases).length === 0) {
+        runtime.log("- none");
+        return;
+    }
+    for (const [alias, target] of Object.entries(aliases)) {
+        runtime.log(`- ${alias} -> ${target}`);
+    }
+}
+export async function modelsAliasesAddCommand(aliasRaw, modelRaw, runtime) {
+    const alias = normalizeAlias(aliasRaw);
+    const updated = await updateConfig((cfg) => {
+        const resolved = resolveModelTarget({ raw: modelRaw, cfg });
+        const nextAliases = { ...cfg.agent?.modelAliases };
+        nextAliases[alias] = `${resolved.provider}/${resolved.model}`;
+        return {
+            ...cfg,
+            agent: {
+                ...cfg.agent,
+                modelAliases: nextAliases,
+            },
+        };
+    });
+    runtime.log(`Updated ${CONFIG_PATH_CLAWDBOT}`);
+    runtime.log(`Alias ${alias} -> ${updated.agent?.modelAliases?.[alias]}`);
+}
+export async function modelsAliasesRemoveCommand(aliasRaw, runtime) {
+    const alias = normalizeAlias(aliasRaw);
+    const updated = await updateConfig((cfg) => {
+        const nextAliases = { ...cfg.agent?.modelAliases };
+        if (!nextAliases[alias]) {
+            throw new Error(`Alias not found: ${alias}`);
+        }
+        delete nextAliases[alias];
+        return {
+            ...cfg,
+            agent: {
+                ...cfg.agent,
+                modelAliases: nextAliases,
+            },
+        };
+    });
+    runtime.log(`Updated ${CONFIG_PATH_CLAWDBOT}`);
+    if (!updated.agent?.modelAliases ||
+        Object.keys(updated.agent.modelAliases).length === 0) {
+        runtime.log("No aliases configured.");
+    }
+}