clawdbot 2026.1.4

package/dist/commands/onboard-remote.js

@@ -0,0 +1,120 @@
+import { discoverGatewayBeacons } from "../infra/bonjour-discovery.js";
+import { detectBinary } from "./onboard-helpers.js";
+const DEFAULT_GATEWAY_URL = "ws://127.0.0.1:18789";
+function pickHost(beacon) {
+    return beacon.tailnetDns || beacon.lanHost || beacon.host;
+}
+function buildLabel(beacon) {
+    const host = pickHost(beacon);
+    const port = beacon.gatewayPort ?? beacon.port ?? 18789;
+    const title = beacon.displayName ?? beacon.instanceName;
+    const hint = host ? `${host}:${port}` : "host unknown";
+    return `${title} (${hint})`;
+}
+function ensureWsUrl(value) {
+    const trimmed = value.trim();
+    if (!trimmed)
+        return DEFAULT_GATEWAY_URL;
+    return trimmed;
+}
+export async function promptRemoteGatewayConfig(cfg, prompter) {
+    let selectedBeacon = null;
+    let suggestedUrl = cfg.gateway?.remote?.url ?? DEFAULT_GATEWAY_URL;
+    const hasBonjourTool = (await detectBinary("dns-sd")) || (await detectBinary("avahi-browse"));
+    const wantsDiscover = hasBonjourTool
+        ? await prompter.confirm({
+            message: "Discover gateway on LAN (Bonjour)?",
+            initialValue: true,
+        })
+        : false;
+    if (!hasBonjourTool) {
+        await prompter.note("Bonjour discovery requires dns-sd (macOS) or avahi-browse (Linux).", "Discovery");
+    }
+    if (wantsDiscover) {
+        const spin = prompter.progress("Searching for gateways…");
+        const beacons = await discoverGatewayBeacons({ timeoutMs: 2000 });
+        spin.stop(beacons.length > 0
+            ? `Found ${beacons.length} gateway(s)`
+            : "No gateways found");
+        if (beacons.length > 0) {
+            const selection = await prompter.select({
+                message: "Select gateway",
+                options: [
+                    ...beacons.map((beacon, index) => ({
+                        value: String(index),
+                        label: buildLabel(beacon),
+                    })),
+                    { value: "manual", label: "Enter URL manually" },
+                ],
+            });
+            if (selection !== "manual") {
+                const idx = Number.parseInt(String(selection), 10);
+                selectedBeacon = Number.isFinite(idx) ? (beacons[idx] ?? null) : null;
+            }
+        }
+    }
+    if (selectedBeacon) {
+        const host = pickHost(selectedBeacon);
+        const port = selectedBeacon.gatewayPort ?? 18789;
+        if (host) {
+            const mode = await prompter.select({
+                message: "Connection method",
+                options: [
+                    {
+                        value: "direct",
+                        label: `Direct gateway WS (${host}:${port})`,
+                    },
+                    { value: "ssh", label: "SSH tunnel (loopback)" },
+                ],
+            });
+            if (mode === "direct") {
+                suggestedUrl = `ws://${host}:${port}`;
+            }
+            else {
+                suggestedUrl = DEFAULT_GATEWAY_URL;
+                await prompter.note([
+                    "Start a tunnel before using the CLI:",
+                    `ssh -N -L 18789:127.0.0.1:18789 <user>@${host}${selectedBeacon.sshPort ? ` -p ${selectedBeacon.sshPort}` : ""}`,
+                ].join("\n"), "SSH tunnel");
+            }
+        }
+    }
+    const urlInput = await prompter.text({
+        message: "Gateway WebSocket URL",
+        initialValue: suggestedUrl,
+        validate: (value) => String(value).trim().startsWith("ws://") ||
+            String(value).trim().startsWith("wss://")
+            ? undefined
+            : "URL must start with ws:// or wss://",
+    });
+    const url = ensureWsUrl(String(urlInput));
+    const authChoice = (await prompter.select({
+        message: "Gateway auth",
+        options: [
+            { value: "token", label: "Token (recommended)" },
+            { value: "off", label: "No auth" },
+        ],
+    }));
+    let token = cfg.gateway?.remote?.token ?? "";
+    if (authChoice === "token") {
+        token = String(await prompter.text({
+            message: "Gateway token",
+            initialValue: token,
+            validate: (value) => (value?.trim() ? undefined : "Required"),
+        })).trim();
+    }
+    else {
+        token = "";
+    }
+    return {
+        ...cfg,
+        gateway: {
+            ...cfg.gateway,
+            mode: "remote",
+            remote: {
+                url,
+                token: token || undefined,
+            },
+        },
+    };
+}

package/dist/commands/onboard-skills.js

@@ -0,0 +1,148 @@
+import { installSkill } from "../agents/skills-install.js";
+import { buildWorkspaceSkillStatus } from "../agents/skills-status.js";
+import { detectBinary, resolveNodeManagerOptions } from "./onboard-helpers.js";
+function summarizeInstallFailure(message) {
+    const cleaned = message
+        .replace(/^Install failed(?:\s*\([^)]*\))?\s*:?\s*/i, "")
+        .trim();
+    if (!cleaned)
+        return undefined;
+    const maxLen = 140;
+    return cleaned.length > maxLen ? `${cleaned.slice(0, maxLen - 1)}…` : cleaned;
+}
+function formatSkillHint(skill) {
+    const desc = skill.description?.trim();
+    const installLabel = skill.install[0]?.label?.trim();
+    const combined = desc && installLabel ? `${desc} — ${installLabel}` : desc || installLabel;
+    if (!combined)
+        return "install";
+    const maxLen = 90;
+    return combined.length > maxLen
+        ? `${combined.slice(0, maxLen - 1)}…`
+        : combined;
+}
+function upsertSkillEntry(cfg, skillKey, patch) {
+    const entries = { ...cfg.skills?.entries };
+    const existing = entries[skillKey] ?? {};
+    entries[skillKey] = { ...existing, ...patch };
+    return {
+        ...cfg,
+        skills: {
+            ...cfg.skills,
+            entries,
+        },
+    };
+}
+export async function setupSkills(cfg, workspaceDir, runtime, prompter) {
+    const report = buildWorkspaceSkillStatus(workspaceDir, { config: cfg });
+    const eligible = report.skills.filter((s) => s.eligible);
+    const missing = report.skills.filter((s) => !s.eligible && !s.disabled && !s.blockedByAllowlist);
+    const blocked = report.skills.filter((s) => s.blockedByAllowlist);
+    const needsBrewPrompt = process.platform !== "win32" &&
+        report.skills.some((skill) => skill.install.some((option) => option.kind === "brew")) &&
+        !(await detectBinary("brew"));
+    await prompter.note([
+        `Eligible: ${eligible.length}`,
+        `Missing requirements: ${missing.length}`,
+        `Blocked by allowlist: ${blocked.length}`,
+    ].join("\n"), "Skills status");
+    const shouldConfigure = await prompter.confirm({
+        message: "Configure skills now? (recommended)",
+        initialValue: true,
+    });
+    if (!shouldConfigure)
+        return cfg;
+    if (needsBrewPrompt) {
+        await prompter.note([
+            "Many skill dependencies are shipped via Homebrew.",
+            "Without brew, you'll need to build from source or download releases manually.",
+        ].join("\n"), "Homebrew recommended");
+        const showBrewInstall = await prompter.confirm({
+            message: "Show Homebrew install command?",
+            initialValue: true,
+        });
+        if (showBrewInstall) {
+            await prompter.note([
+                "Run:",
+                '/bin/bash -c "$(curl -fsSL https://raw.githubusercontent.com/Homebrew/install/HEAD/install.sh)"',
+            ].join("\n"), "Homebrew install");
+        }
+    }
+    const nodeManager = (await prompter.select({
+        message: "Preferred node manager for skill installs",
+        options: resolveNodeManagerOptions(),
+    }));
+    let next = {
+        ...cfg,
+        skills: {
+            ...cfg.skills,
+            install: {
+                ...cfg.skills?.install,
+                nodeManager,
+            },
+        },
+    };
+    const installable = missing.filter((skill) => skill.install.length > 0 && skill.missing.bins.length > 0);
+    if (installable.length > 0) {
+        const toInstall = await prompter.multiselect({
+            message: "Install missing skill dependencies",
+            options: [
+                {
+                    value: "__skip__",
+                    label: "Skip for now",
+                    hint: "Continue without installing dependencies",
+                },
+                ...installable.map((skill) => ({
+                    value: skill.name,
+                    label: `${skill.emoji ?? "🧩"} ${skill.name}`,
+                    hint: formatSkillHint(skill),
+                })),
+            ],
+        });
+        const selected = toInstall.filter((name) => name !== "__skip__");
+        for (const name of selected) {
+            const target = installable.find((s) => s.name === name);
+            if (!target || target.install.length === 0)
+                continue;
+            const installId = target.install[0]?.id;
+            if (!installId)
+                continue;
+            const spin = prompter.progress(`Installing ${name}…`);
+            const result = await installSkill({
+                workspaceDir,
+                skillName: target.name,
+                installId,
+                config: next,
+            });
+            if (result.ok) {
+                spin.stop(`Installed ${name}`);
+            }
+            else {
+                const code = result.code == null ? "" : ` (exit ${result.code})`;
+                const detail = summarizeInstallFailure(result.message);
+                spin.stop(`Install failed: ${name}${code}${detail ? ` — ${detail}` : ""}`);
+                if (result.stderr)
+                    runtime.log(result.stderr.trim());
+                else if (result.stdout)
+                    runtime.log(result.stdout.trim());
+                runtime.log("Tip: run `clawdbot doctor` to review skills + requirements.");
+            }
+        }
+    }
+    for (const skill of missing) {
+        if (!skill.primaryEnv || skill.missing.env.length === 0)
+            continue;
+        const wantsKey = await prompter.confirm({
+            message: `Set ${skill.primaryEnv} for ${skill.name}?`,
+            initialValue: false,
+        });
+        if (!wantsKey)
+            continue;
+        const apiKey = String(await prompter.text({
+            message: `Enter ${skill.primaryEnv}`,
+            validate: (value) => (value?.trim() ? undefined : "Required"),
+        }));
+        next = upsertSkillEntry(next, skill.skillKey, { apiKey: apiKey.trim() });
+    }
+    return next;
+}

package/dist/commands/onboard-types.js

@@ -0,0 +1 @@
+export {};

package/dist/commands/onboard.js

@@ -0,0 +1,12 @@
+import { assertSupportedRuntime } from "../infra/runtime-guard.js";
+import { defaultRuntime } from "../runtime.js";
+import { runInteractiveOnboarding } from "./onboard-interactive.js";
+import { runNonInteractiveOnboarding } from "./onboard-non-interactive.js";
+export async function onboardCommand(opts, runtime = defaultRuntime) {
+    assertSupportedRuntime(runtime);
+    if (opts.nonInteractive) {
+        await runNonInteractiveOnboarding(opts, runtime);
+        return;
+    }
+    await runInteractiveOnboarding(opts, runtime);
+}

package/dist/commands/send.js

@@ -0,0 +1,124 @@
+import { loadConfig } from "../config/config.js";
+import { callGateway, randomIdempotencyKey } from "../gateway/call.js";
+import { success } from "../globals.js";
+import { resolveTelegramToken } from "../telegram/token.js";
+export async function sendCommand(opts, deps, runtime) {
+    const provider = (opts.provider ?? "whatsapp").toLowerCase();
+    if (opts.dryRun) {
+        runtime.log(`[dry-run] would send via ${provider} -> ${opts.to}: ${opts.message}${opts.media ? ` (media ${opts.media})` : ""}`);
+        return;
+    }
+    if (provider === "telegram") {
+        const { token } = resolveTelegramToken(loadConfig());
+        const result = await deps.sendMessageTelegram(opts.to, opts.message, {
+            token: token || undefined,
+            mediaUrl: opts.media,
+        });
+        runtime.log(success(`✅ Sent via telegram. Message ID: ${result.messageId} (chat ${result.chatId})`));
+        if (opts.json) {
+            runtime.log(JSON.stringify({
+                provider: "telegram",
+                via: "direct",
+                to: opts.to,
+                chatId: result.chatId,
+                messageId: result.messageId,
+                mediaUrl: opts.media ?? null,
+            }, null, 2));
+        }
+        return;
+    }
+    if (provider === "discord") {
+        const result = await deps.sendMessageDiscord(opts.to, opts.message, {
+            token: process.env.DISCORD_BOT_TOKEN,
+            mediaUrl: opts.media,
+        });
+        runtime.log(success(`✅ Sent via discord. Message ID: ${result.messageId} (channel ${result.channelId})`));
+        if (opts.json) {
+            runtime.log(JSON.stringify({
+                provider: "discord",
+                via: "direct",
+                to: opts.to,
+                channelId: result.channelId,
+                messageId: result.messageId,
+                mediaUrl: opts.media ?? null,
+            }, null, 2));
+        }
+        return;
+    }
+    if (provider === "slack") {
+        const result = await deps.sendMessageSlack(opts.to, opts.message, {
+            mediaUrl: opts.media,
+        });
+        runtime.log(success(`✅ Sent via slack. Message ID: ${result.messageId} (channel ${result.channelId})`));
+        if (opts.json) {
+            runtime.log(JSON.stringify({
+                provider: "slack",
+                via: "direct",
+                to: opts.to,
+                channelId: result.channelId,
+                messageId: result.messageId,
+                mediaUrl: opts.media ?? null,
+            }, null, 2));
+        }
+        return;
+    }
+    if (provider === "signal") {
+        const result = await deps.sendMessageSignal(opts.to, opts.message, {
+            mediaUrl: opts.media,
+        });
+        runtime.log(success(`✅ Sent via signal. Message ID: ${result.messageId}`));
+        if (opts.json) {
+            runtime.log(JSON.stringify({
+                provider: "signal",
+                via: "direct",
+                to: opts.to,
+                messageId: result.messageId,
+                mediaUrl: opts.media ?? null,
+            }, null, 2));
+        }
+        return;
+    }
+    if (provider === "imessage" || provider === "imsg") {
+        const result = await deps.sendMessageIMessage(opts.to, opts.message, {
+            mediaUrl: opts.media,
+        });
+        runtime.log(success(`✅ Sent via iMessage. Message ID: ${result.messageId}`));
+        if (opts.json) {
+            runtime.log(JSON.stringify({
+                provider: "imessage",
+                via: "direct",
+                to: opts.to,
+                messageId: result.messageId,
+                mediaUrl: opts.media ?? null,
+            }, null, 2));
+        }
+        return;
+    }
+    // Always send via gateway over WS to avoid multi-session corruption.
+    const sendViaGateway = async () => callGateway({
+        url: "ws://127.0.0.1:18789",
+        method: "send",
+        params: {
+            to: opts.to,
+            message: opts.message,
+            mediaUrl: opts.media,
+            gifPlayback: opts.gifPlayback,
+            provider,
+            idempotencyKey: randomIdempotencyKey(),
+        },
+        timeoutMs: 10_000,
+        clientName: "cli",
+        mode: "cli",
+    });
+    const result = await sendViaGateway();
+    runtime.log(success(`✅ Sent via gateway. Message ID: ${result.messageId ?? "unknown"}`));
+    if (opts.json) {
+        runtime.log(JSON.stringify({
+            provider: "web",
+            via: "gateway",
+            to: opts.to,
+            messageId: result.messageId,
+            mediaUrl: opts.media ?? null,
+        }, null, 2));
+    }
+}

package/dist/commands/sessions.js

@@ -0,0 +1,212 @@
+import chalk from "chalk";
+import { lookupContextTokens } from "../agents/context.js";
+import { DEFAULT_CONTEXT_TOKENS, DEFAULT_MODEL, DEFAULT_PROVIDER, } from "../agents/defaults.js";
+import { resolveConfiguredModelRef } from "../agents/model-selection.js";
+import { loadConfig } from "../config/config.js";
+import { loadSessionStore, resolveStorePath, } from "../config/sessions.js";
+import { info } from "../globals.js";
+const KIND_PAD = 6;
+const KEY_PAD = 26;
+const AGE_PAD = 9;
+const MODEL_PAD = 14;
+const TOKENS_PAD = 20;
+const isRich = () => Boolean(process.stdout.isTTY && chalk.level > 0);
+const formatKTokens = (value) => `${(value / 1000).toFixed(value >= 10_000 ? 0 : 1)}k`;
+const truncateKey = (key) => {
+    if (key.length <= KEY_PAD)
+        return key;
+    const head = Math.max(4, KEY_PAD - 10);
+    return `${key.slice(0, head)}...${key.slice(-6)}`;
+};
+const colorByPct = (label, pct, rich) => {
+    if (!rich || pct === null)
+        return label;
+    if (pct >= 95)
+        return chalk.red(label);
+    if (pct >= 80)
+        return chalk.yellow(label);
+    if (pct >= 60)
+        return chalk.green(label);
+    return chalk.gray(label);
+};
+const formatTokensCell = (total, contextTokens, rich) => {
+    if (!total)
+        return "-".padEnd(TOKENS_PAD);
+    const totalLabel = formatKTokens(total);
+    const ctxLabel = contextTokens ? formatKTokens(contextTokens) : "?";
+    const pct = contextTokens
+        ? Math.min(999, Math.round((total / contextTokens) * 100))
+        : null;
+    const label = `${totalLabel}/${ctxLabel} (${pct ?? "?"}%)`;
+    const padded = label.padEnd(TOKENS_PAD);
+    return colorByPct(padded, pct, rich);
+};
+const formatKindCell = (kind, rich) => {
+    const label = kind.padEnd(KIND_PAD);
+    if (!rich)
+        return label;
+    if (kind === "group")
+        return chalk.magenta(label);
+    if (kind === "global")
+        return chalk.yellow(label);
+    if (kind === "direct")
+        return chalk.cyan(label);
+    return chalk.gray(label);
+};
+const formatAgeCell = (updatedAt, rich) => {
+    const ageLabel = updatedAt ? formatAge(Date.now() - updatedAt) : "unknown";
+    const padded = ageLabel.padEnd(AGE_PAD);
+    return rich ? chalk.gray(padded) : padded;
+};
+const formatModelCell = (model, rich) => {
+    const label = (model ?? "unknown").padEnd(MODEL_PAD);
+    return rich ? chalk.white(label) : label;
+};
+const formatFlagsCell = (row, rich) => {
+    const flags = [
+        row.thinkingLevel ? `think:${row.thinkingLevel}` : null,
+        row.verboseLevel ? `verbose:${row.verboseLevel}` : null,
+        row.groupActivation ? `activation:${row.groupActivation}` : null,
+        row.systemSent ? "system" : null,
+        row.abortedLastRun ? "aborted" : null,
+        row.sessionId ? `id:${row.sessionId}` : null,
+    ].filter(Boolean);
+    const label = flags.join(" ");
+    return label.length === 0 ? "" : rich ? chalk.gray(label) : label;
+};
+const formatAge = (ms) => {
+    if (!ms || ms < 0)
+        return "unknown";
+    const minutes = Math.round(ms / 60_000);
+    if (minutes < 1)
+        return "just now";
+    if (minutes < 60)
+        return `${minutes}m ago`;
+    const hours = Math.round(minutes / 60);
+    if (hours < 48)
+        return `${hours}h ago`;
+    const days = Math.round(hours / 24);
+    return `${days}d ago`;
+};
+function classifyKey(key, entry) {
+    if (key === "global")
+        return "global";
+    if (key === "unknown")
+        return "unknown";
+    if (entry?.chatType === "group" || entry?.chatType === "room")
+        return "group";
+    if (key.startsWith("group:") ||
+        key.includes(":group:") ||
+        key.includes(":channel:")) {
+        return "group";
+    }
+    return "direct";
+}
+function toRows(store) {
+    return Object.entries(store)
+        .map(([key, entry]) => {
+        const updatedAt = entry?.updatedAt ?? null;
+        return {
+            key,
+            kind: classifyKey(key, entry),
+            updatedAt,
+            ageMs: updatedAt ? Date.now() - updatedAt : null,
+            sessionId: entry?.sessionId,
+            systemSent: entry?.systemSent,
+            abortedLastRun: entry?.abortedLastRun,
+            thinkingLevel: entry?.thinkingLevel,
+            verboseLevel: entry?.verboseLevel,
+            groupActivation: entry?.groupActivation,
+            inputTokens: entry?.inputTokens,
+            outputTokens: entry?.outputTokens,
+            totalTokens: entry?.totalTokens,
+            model: entry?.model,
+            contextTokens: entry?.contextTokens,
+        };
+    })
+        .sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+}
+export async function sessionsCommand(opts, runtime) {
+    const cfg = loadConfig();
+    const resolved = resolveConfiguredModelRef({
+        cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+        defaultModel: DEFAULT_MODEL,
+    });
+    const configContextTokens = cfg.agent?.contextTokens ??
+        lookupContextTokens(resolved.model) ??
+        DEFAULT_CONTEXT_TOKENS;
+    const configModel = resolved.model ?? DEFAULT_MODEL;
+    const storePath = resolveStorePath(opts.store ?? cfg.session?.store);
+    const store = loadSessionStore(storePath);
+    let activeMinutes;
+    if (opts.active !== undefined) {
+        const parsed = Number.parseInt(String(opts.active), 10);
+        if (Number.isNaN(parsed) || parsed <= 0) {
+            runtime.error("--active must be a positive integer (minutes)");
+            runtime.exit(1);
+            return;
+        }
+        activeMinutes = parsed;
+    }
+    const rows = toRows(store).filter((row) => {
+        if (activeMinutes === undefined)
+            return true;
+        if (!row.updatedAt)
+            return false;
+        return Date.now() - row.updatedAt <= activeMinutes * 60_000;
+    });
+    if (opts.json) {
+        runtime.log(JSON.stringify({
+            path: storePath,
+            count: rows.length,
+            activeMinutes: activeMinutes ?? null,
+            sessions: rows.map((r) => ({
+                ...r,
+                contextTokens: r.contextTokens ??
+                    lookupContextTokens(r.model) ??
+                    configContextTokens ??
+                    null,
+                model: r.model ?? configModel ?? null,
+            })),
+        }, null, 2));
+        return;
+    }
+    runtime.log(info(`Session store: ${storePath}`));
+    runtime.log(info(`Sessions listed: ${rows.length}`));
+    if (activeMinutes) {
+        runtime.log(info(`Filtered to last ${activeMinutes} minute(s)`));
+    }
+    if (rows.length === 0) {
+        runtime.log("No sessions found.");
+        return;
+    }
+    const rich = isRich();
+    const header = [
+        "Kind".padEnd(KIND_PAD),
+        "Key".padEnd(KEY_PAD),
+        "Age".padEnd(AGE_PAD),
+        "Model".padEnd(MODEL_PAD),
+        "Tokens (ctx %)".padEnd(TOKENS_PAD),
+        "Flags",
+    ].join(" ");
+    runtime.log(rich ? chalk.bold(header) : header);
+    for (const row of rows) {
+        const model = row.model ?? configModel;
+        const contextTokens = row.contextTokens ?? lookupContextTokens(model) ?? configContextTokens;
+        const input = row.inputTokens ?? 0;
+        const output = row.outputTokens ?? 0;
+        const total = row.totalTokens ?? input + output;
+        const keyLabel = truncateKey(row.key).padEnd(KEY_PAD);
+        const keyCell = rich ? chalk.cyan(keyLabel) : keyLabel;
+        const line = [
+            formatKindCell(row.kind, rich),
+            keyCell,
+            formatAgeCell(row.updatedAt, rich),
+            formatModelCell(model, rich),
+            formatTokensCell(total, contextTokens ?? null, rich),
+            formatFlagsCell(row, rich),
+        ].join(" ");
+        runtime.log(line.trimEnd());
+    }
+}

package/dist/commands/setup.js

@@ -0,0 +1,58 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import JSON5 from "json5";
+import { DEFAULT_AGENT_WORKSPACE_DIR, ensureAgentWorkspace, } from "../agents/workspace.js";
+import { CONFIG_PATH_CLAWDBOT } from "../config/config.js";
+import { resolveSessionTranscriptsDir } from "../config/sessions.js";
+import { defaultRuntime } from "../runtime.js";
+async function readConfigFileRaw() {
+    try {
+        const raw = await fs.readFile(CONFIG_PATH_CLAWDBOT, "utf-8");
+        const parsed = JSON5.parse(raw);
+        if (parsed && typeof parsed === "object") {
+            return { exists: true, parsed: parsed };
+        }
+        return { exists: true, parsed: {} };
+    }
+    catch {
+        return { exists: false, parsed: {} };
+    }
+}
+async function writeConfigFile(cfg) {
+    await fs.mkdir(path.dirname(CONFIG_PATH_CLAWDBOT), { recursive: true });
+    const json = JSON.stringify(cfg, null, 2).trimEnd().concat("\n");
+    await fs.writeFile(CONFIG_PATH_CLAWDBOT, json, "utf-8");
+}
+export async function setupCommand(opts, runtime = defaultRuntime) {
+    const desiredWorkspace = typeof opts?.workspace === "string" && opts.workspace.trim()
+        ? opts.workspace.trim()
+        : undefined;
+    const existingRaw = await readConfigFileRaw();
+    const cfg = existingRaw.parsed;
+    const agent = cfg.agent ?? {};
+    const workspace = desiredWorkspace ?? agent.workspace ?? DEFAULT_AGENT_WORKSPACE_DIR;
+    const next = {
+        ...cfg,
+        agent: {
+            ...agent,
+            workspace,
+        },
+    };
+    if (!existingRaw.exists || agent.workspace !== workspace) {
+        await writeConfigFile(next);
+        runtime.log(!existingRaw.exists
+            ? `Wrote ${CONFIG_PATH_CLAWDBOT}`
+            : `Updated ${CONFIG_PATH_CLAWDBOT} (set agent.workspace)`);
+    }
+    else {
+        runtime.log(`Config OK: ${CONFIG_PATH_CLAWDBOT}`);
+    }
+    const ws = await ensureAgentWorkspace({
+        dir: workspace,
+        ensureBootstrapFiles: true,
+    });
+    runtime.log(`Workspace OK: ${ws.dir}`);
+    const sessionsDir = resolveSessionTranscriptsDir();
+    await fs.mkdir(sessionsDir, { recursive: true });
+    runtime.log(`Sessions OK: ${sessionsDir}`);
+}