clawdbot 2026.1.4-1

package/dist/commands/signal-install.js

@@ -0,0 +1,135 @@
+import { createWriteStream } from "node:fs";
+import fs from "node:fs/promises";
+import { request } from "node:https";
+import os from "node:os";
+import path from "node:path";
+import { pipeline } from "node:stream/promises";
+import { runCommandWithTimeout } from "../process/exec.js";
+import { CONFIG_DIR } from "../utils.js";
+function looksLikeArchive(name) {
+    return (name.endsWith(".tar.gz") || name.endsWith(".tgz") || name.endsWith(".zip"));
+}
+function pickAsset(assets, platform) {
+    const withName = assets.filter((asset) => Boolean(asset.name && asset.browser_download_url));
+    const byName = (pattern) => withName.find((asset) => pattern.test(asset.name.toLowerCase()));
+    if (platform === "linux") {
+        return (byName(/linux-native/) ||
+            byName(/linux/) ||
+            withName.find((asset) => looksLikeArchive(asset.name.toLowerCase())));
+    }
+    if (platform === "darwin") {
+        return (byName(/macos|osx|darwin/) ||
+            withName.find((asset) => looksLikeArchive(asset.name.toLowerCase())));
+    }
+    if (platform === "win32") {
+        return (byName(/windows|win/) ||
+            withName.find((asset) => looksLikeArchive(asset.name.toLowerCase())));
+    }
+    return withName.find((asset) => looksLikeArchive(asset.name.toLowerCase()));
+}
+async function downloadToFile(url, dest, maxRedirects = 5) {
+    await new Promise((resolve, reject) => {
+        const req = request(url, (res) => {
+            if (res.statusCode && res.statusCode >= 300 && res.statusCode < 400) {
+                const location = res.headers.location;
+                if (!location || maxRedirects <= 0) {
+                    reject(new Error("Redirect loop or missing Location header"));
+                    return;
+                }
+                const redirectUrl = new URL(location, url).href;
+                resolve(downloadToFile(redirectUrl, dest, maxRedirects - 1));
+                return;
+            }
+            if (!res.statusCode || res.statusCode >= 400) {
+                reject(new Error(`HTTP ${res.statusCode ?? "?"} downloading file`));
+                return;
+            }
+            const out = createWriteStream(dest);
+            pipeline(res, out).then(resolve).catch(reject);
+        });
+        req.on("error", reject);
+        req.end();
+    });
+}
+async function findSignalCliBinary(root) {
+    const candidates = [];
+    const enqueue = async (dir, depth) => {
+        if (depth > 3)
+            return;
+        const entries = await fs
+            .readdir(dir, { withFileTypes: true })
+            .catch(() => []);
+        for (const entry of entries) {
+            const full = path.join(dir, entry.name);
+            if (entry.isDirectory()) {
+                await enqueue(full, depth + 1);
+            }
+            else if (entry.isFile() && entry.name === "signal-cli") {
+                candidates.push(full);
+            }
+        }
+    };
+    await enqueue(root, 0);
+    return candidates[0] ?? null;
+}
+export async function installSignalCli(runtime) {
+    if (process.platform === "win32") {
+        return {
+            ok: false,
+            error: "Signal CLI auto-install is not supported on Windows yet.",
+        };
+    }
+    const apiUrl = "https://api.github.com/repos/AsamK/signal-cli/releases/latest";
+    const response = await fetch(apiUrl, {
+        headers: {
+            "User-Agent": "clawdbot",
+            Accept: "application/vnd.github+json",
+        },
+    });
+    if (!response.ok) {
+        return {
+            ok: false,
+            error: `Failed to fetch release info (${response.status})`,
+        };
+    }
+    const payload = (await response.json());
+    const version = payload.tag_name?.replace(/^v/, "") ?? "unknown";
+    const assets = payload.assets ?? [];
+    const asset = pickAsset(assets, process.platform);
+    const assetName = asset?.name ?? "";
+    const assetUrl = asset?.browser_download_url ?? "";
+    if (!assetName || !assetUrl) {
+        return {
+            ok: false,
+            error: "No compatible release asset found for this platform.",
+        };
+    }
+    const tmpDir = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-signal-"));
+    const archivePath = path.join(tmpDir, assetName);
+    runtime.log(`Downloading signal-cli ${version} (${assetName})…`);
+    await downloadToFile(assetUrl, archivePath);
+    const installRoot = path.join(CONFIG_DIR, "tools", "signal-cli", version);
+    await fs.mkdir(installRoot, { recursive: true });
+    if (assetName.endsWith(".zip")) {
+        await runCommandWithTimeout(["unzip", "-q", archivePath, "-d", installRoot], {
+            timeoutMs: 60_000,
+        });
+    }
+    else if (assetName.endsWith(".tar.gz") || assetName.endsWith(".tgz")) {
+        await runCommandWithTimeout(["tar", "-xzf", archivePath, "-C", installRoot], {
+            timeoutMs: 60_000,
+        });
+    }
+    else {
+        return { ok: false, error: `Unsupported archive type: ${assetName}` };
+    }
+    const cliPath = await findSignalCliBinary(installRoot);
+    if (!cliPath) {
+        return {
+            ok: false,
+            error: `signal-cli binary not found after extracting ${assetName}`,
+        };
+    }
+    await fs.chmod(cliPath, 0o755).catch(() => { });
+    return { ok: true, cliPath, version };
+}

package/dist/commands/status.js

@@ -0,0 +1,207 @@
+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 { callGateway } from "../gateway/call.js";
+import { info } from "../globals.js";
+import { buildProviderSummary } from "../infra/provider-summary.js";
+import { peekSystemEvents } from "../infra/system-events.js";
+import { resolveHeartbeatSeconds } from "../web/reconnect.js";
+import { getWebAuthAgeMs, logWebSelfId, webAuthExists, } from "../web/session.js";
+export async function getStatusSummary() {
+    const cfg = loadConfig();
+    const linked = await webAuthExists();
+    const authAgeMs = getWebAuthAgeMs();
+    const heartbeatSeconds = resolveHeartbeatSeconds(cfg, undefined);
+    const providerSummary = await buildProviderSummary(cfg);
+    const queuedSystemEvents = peekSystemEvents();
+    const resolved = resolveConfiguredModelRef({
+        cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+        defaultModel: DEFAULT_MODEL,
+    });
+    const configModel = resolved.model ?? DEFAULT_MODEL;
+    const configContextTokens = cfg.agent?.contextTokens ??
+        lookupContextTokens(configModel) ??
+        DEFAULT_CONTEXT_TOKENS;
+    const storePath = resolveStorePath(cfg.session?.store);
+    const store = loadSessionStore(storePath);
+    const now = Date.now();
+    const sessions = Object.entries(store)
+        .filter(([key]) => key !== "global" && key !== "unknown")
+        .map(([key, entry]) => {
+        const updatedAt = entry?.updatedAt ?? null;
+        const age = updatedAt ? now - updatedAt : null;
+        const model = entry?.model ?? configModel ?? null;
+        const contextTokens = entry?.contextTokens ??
+            lookupContextTokens(model) ??
+            configContextTokens ??
+            null;
+        const input = entry?.inputTokens ?? 0;
+        const output = entry?.outputTokens ?? 0;
+        const total = entry?.totalTokens ?? input + output;
+        const remaining = contextTokens != null ? Math.max(0, contextTokens - total) : null;
+        const pct = contextTokens && contextTokens > 0
+            ? Math.min(999, Math.round((total / contextTokens) * 100))
+            : null;
+        return {
+            key,
+            kind: classifyKey(key, entry),
+            sessionId: entry?.sessionId,
+            updatedAt,
+            age,
+            thinkingLevel: entry?.thinkingLevel,
+            verboseLevel: entry?.verboseLevel,
+            elevatedLevel: entry?.elevatedLevel,
+            systemSent: entry?.systemSent,
+            abortedLastRun: entry?.abortedLastRun,
+            inputTokens: entry?.inputTokens,
+            outputTokens: entry?.outputTokens,
+            totalTokens: total ?? null,
+            remainingTokens: remaining,
+            percentUsed: pct,
+            model,
+            contextTokens,
+            flags: buildFlags(entry),
+        };
+    })
+        .sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+    const recent = sessions.slice(0, 5);
+    return {
+        web: { linked, authAgeMs },
+        heartbeatSeconds,
+        providerSummary,
+        queuedSystemEvents,
+        sessions: {
+            path: storePath,
+            count: sessions.length,
+            defaults: {
+                model: configModel ?? null,
+                contextTokens: configContextTokens ?? null,
+            },
+            recent,
+        },
+    };
+}
+const formatKTokens = (value) => `${(value / 1000).toFixed(value >= 10_000 ? 0 : 1)}k`;
+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`;
+};
+const formatContextUsage = (total, contextTokens, remaining, pct) => {
+    const used = total ?? 0;
+    if (!contextTokens) {
+        return `tokens: ${formatKTokens(used)} used (ctx unknown)`;
+    }
+    const left = remaining ?? Math.max(0, contextTokens - used);
+    const pctLabel = pct != null ? `${pct}%` : "?%";
+    return `tokens: ${formatKTokens(used)} used, ${formatKTokens(left)} left of ${formatKTokens(contextTokens)} (${pctLabel})`;
+};
+const 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";
+};
+const buildFlags = (entry) => {
+    const flags = [];
+    const think = entry?.thinkingLevel;
+    if (typeof think === "string" && think.length > 0)
+        flags.push(`think:${think}`);
+    const verbose = entry?.verboseLevel;
+    if (typeof verbose === "string" && verbose.length > 0)
+        flags.push(`verbose:${verbose}`);
+    const elevated = entry?.elevatedLevel;
+    if (typeof elevated === "string" && elevated.length > 0)
+        flags.push(`elevated:${elevated}`);
+    if (entry?.systemSent)
+        flags.push("system");
+    if (entry?.abortedLastRun)
+        flags.push("aborted");
+    const sessionId = entry?.sessionId;
+    if (typeof sessionId === "string" && sessionId.length > 0)
+        flags.push(`id:${sessionId}`);
+    return flags;
+};
+export async function statusCommand(opts, runtime) {
+    const summary = await getStatusSummary();
+    const health = opts.deep
+        ? await callGateway({
+            method: "health",
+            timeoutMs: opts.timeoutMs,
+        })
+        : undefined;
+    if (opts.json) {
+        runtime.log(JSON.stringify(health ? { ...summary, health } : summary, null, 2));
+        return;
+    }
+    runtime.log(`Web session: ${summary.web.linked ? "linked" : "not linked"}${summary.web.linked ? ` (last refreshed ${formatAge(summary.web.authAgeMs)})` : ""}`);
+    if (summary.web.linked) {
+        logWebSelfId(runtime, true);
+    }
+    runtime.log(info("System:"));
+    for (const line of summary.providerSummary) {
+        runtime.log(`  ${line}`);
+    }
+    if (health) {
+        runtime.log(info("Gateway health: reachable"));
+        const tgLine = health.telegram.configured
+            ? health.telegram.probe?.ok
+                ? info(`Telegram: ok${health.telegram.probe.bot?.username ? ` (@${health.telegram.probe.bot.username})` : ""} (${health.telegram.probe.elapsedMs}ms)` +
+                    (health.telegram.probe.webhook?.url
+                        ? ` - webhook ${health.telegram.probe.webhook.url}`
+                        : ""))
+                : `Telegram: failed (${health.telegram.probe?.status ?? "unknown"})${health.telegram.probe?.error ? ` - ${health.telegram.probe.error}` : ""}`
+            : info("Telegram: not configured");
+        runtime.log(tgLine);
+        const discordLine = health.discord.configured
+            ? health.discord.probe?.ok
+                ? info(`Discord: ok${health.discord.probe.bot?.username ? ` (@${health.discord.probe.bot.username})` : ""} (${health.discord.probe.elapsedMs}ms)`)
+                : `Discord: failed (${health.discord.probe?.status ?? "unknown"})${health.discord.probe?.error ? ` - ${health.discord.probe.error}` : ""}`
+            : info("Discord: not configured");
+        runtime.log(discordLine);
+    }
+    else {
+        runtime.log(info("Provider probes: skipped (use --deep)"));
+    }
+    if (summary.queuedSystemEvents.length > 0) {
+        const preview = summary.queuedSystemEvents.slice(0, 3).join(" | ");
+        runtime.log(info(`Queued system events (${summary.queuedSystemEvents.length}): ${preview}`));
+    }
+    runtime.log(info(`Heartbeat: ${summary.heartbeatSeconds}s`));
+    runtime.log(info(`Session store: ${summary.sessions.path}`));
+    const defaults = summary.sessions.defaults;
+    const defaultCtx = defaults.contextTokens
+        ? ` (${formatKTokens(defaults.contextTokens)} ctx)`
+        : "";
+    runtime.log(info(`Default model: ${defaults.model ?? "unknown"}${defaultCtx}`));
+    runtime.log(info(`Active sessions: ${summary.sessions.count}`));
+    if (summary.sessions.recent.length > 0) {
+        runtime.log("Recent sessions:");
+        for (const r of summary.sessions.recent) {
+            runtime.log(`- ${r.key} [${r.kind}] | ${r.updatedAt ? formatAge(r.age) : "no activity"} | model ${r.model ?? "unknown"} | ${formatContextUsage(r.totalTokens, r.contextTokens, r.remainingTokens, r.percentUsed)}${r.flags.length ? ` | flags: ${r.flags.join(", ")}` : ""}`);
+        }
+    }
+    else {
+        runtime.log("No session activity yet.");
+    }
+}

package/dist/commands/update.js

@@ -0,0 +1,16 @@
+import { defaultRuntime } from "../runtime.js";
+import { runConfigureWizard } from "./configure.js";
+export async function updateCommand(runtime = defaultRuntime) {
+    await runConfigureWizard({
+        command: "update",
+        sections: [
+            "workspace",
+            "model",
+            "gateway",
+            "daemon",
+            "providers",
+            "skills",
+            "health",
+        ],
+    }, runtime);
+}

package/dist/config/config.js

@@ -0,0 +1,6 @@
+export { createConfigIO, loadConfig, parseConfigJson5, readConfigFileSnapshot, writeConfigFile, } from "./io.js";
+export { migrateLegacyConfig } from "./legacy-migrate.js";
+export * from "./paths.js";
+export * from "./types.js";
+export { validateConfigObject } from "./validation.js";
+export { ClawdbotSchema } from "./zod-schema.js";

package/dist/config/defaults.js

@@ -0,0 +1,61 @@
+import { resolveTalkApiKey } from "./talk.js";
+let defaultWarnState = { warned: false };
+function escapeRegExp(text) {
+    return text.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+}
+export function applyIdentityDefaults(cfg) {
+    const identity = cfg.identity;
+    if (!identity)
+        return cfg;
+    const name = identity.name?.trim();
+    const routing = cfg.routing ?? {};
+    const groupChat = routing.groupChat ?? {};
+    let mutated = false;
+    const next = { ...cfg };
+    if (name && !groupChat.mentionPatterns) {
+        const parts = name.split(/\s+/).filter(Boolean).map(escapeRegExp);
+        const re = parts.length ? parts.join("\\s+") : escapeRegExp(name);
+        const pattern = `\\b@?${re}\\b`;
+        next.routing = {
+            ...(next.routing ?? routing),
+            groupChat: { ...groupChat, mentionPatterns: [pattern] },
+        };
+        mutated = true;
+    }
+    return mutated ? next : cfg;
+}
+export function applySessionDefaults(cfg, options = {}) {
+    const session = cfg.session;
+    if (!session || session.mainKey === undefined)
+        return cfg;
+    const trimmed = session.mainKey.trim();
+    const warn = options.warn ?? console.warn;
+    const warnState = options.warnState ?? defaultWarnState;
+    const next = {
+        ...cfg,
+        session: { ...session, mainKey: "main" },
+    };
+    if (trimmed && trimmed !== "main" && !warnState.warned) {
+        warnState.warned = true;
+        warn('session.mainKey is ignored; main session is always "main".');
+    }
+    return next;
+}
+export function applyTalkApiKey(config) {
+    const resolved = resolveTalkApiKey();
+    if (!resolved)
+        return config;
+    const existing = config.talk?.apiKey?.trim();
+    if (existing)
+        return config;
+    return {
+        ...config,
+        talk: {
+            ...config.talk,
+            apiKey: resolved,
+        },
+    };
+}
+export function resetSessionDefaultsWarningForTests() {
+    defaultWarnState = { warned: false };
+}

package/dist/config/io.js

@@ -0,0 +1,147 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+import JSON5 from "json5";
+import { applyIdentityDefaults, applySessionDefaults, applyTalkApiKey, } from "./defaults.js";
+import { findLegacyConfigIssues } from "./legacy.js";
+import { CONFIG_PATH_CLAWDBOT, resolveConfigPath, resolveStateDir, } from "./paths.js";
+import { validateConfigObject } from "./validation.js";
+import { ClawdbotSchema } from "./zod-schema.js";
+function resolveConfigPathForDeps(deps) {
+    if (deps.configPath)
+        return deps.configPath;
+    return resolveConfigPath(deps.env, resolveStateDir(deps.env, deps.homedir));
+}
+function normalizeDeps(overrides = {}) {
+    return {
+        fs: overrides.fs ?? fs,
+        json5: overrides.json5 ?? JSON5,
+        env: overrides.env ?? process.env,
+        homedir: overrides.homedir ?? os.homedir,
+        configPath: overrides.configPath ?? "",
+        logger: overrides.logger ?? console,
+    };
+}
+export function parseConfigJson5(raw, json5 = JSON5) {
+    try {
+        return { ok: true, parsed: json5.parse(raw) };
+    }
+    catch (err) {
+        return { ok: false, error: String(err) };
+    }
+}
+export function createConfigIO(overrides = {}) {
+    const deps = normalizeDeps(overrides);
+    const configPath = resolveConfigPathForDeps(deps);
+    function loadConfig() {
+        try {
+            if (!deps.fs.existsSync(configPath))
+                return {};
+            const raw = deps.fs.readFileSync(configPath, "utf-8");
+            const parsed = deps.json5.parse(raw);
+            if (typeof parsed !== "object" || parsed === null)
+                return {};
+            const validated = ClawdbotSchema.safeParse(parsed);
+            if (!validated.success) {
+                deps.logger.error("Invalid config:");
+                for (const iss of validated.error.issues) {
+                    deps.logger.error(`- ${iss.path.join(".")}: ${iss.message}`);
+                }
+                return {};
+            }
+            return applySessionDefaults(applyIdentityDefaults(validated.data));
+        }
+        catch (err) {
+            deps.logger.error(`Failed to read config at ${configPath}`, err);
+            return {};
+        }
+    }
+    async function readConfigFileSnapshot() {
+        const exists = deps.fs.existsSync(configPath);
+        if (!exists) {
+            const config = applyTalkApiKey(applySessionDefaults({}));
+            const legacyIssues = [];
+            return {
+                path: configPath,
+                exists: false,
+                raw: null,
+                parsed: {},
+                valid: true,
+                config,
+                issues: [],
+                legacyIssues,
+            };
+        }
+        try {
+            const raw = deps.fs.readFileSync(configPath, "utf-8");
+            const parsedRes = parseConfigJson5(raw, deps.json5);
+            if (!parsedRes.ok) {
+                return {
+                    path: configPath,
+                    exists: true,
+                    raw,
+                    parsed: {},
+                    valid: false,
+                    config: {},
+                    issues: [
+                        { path: "", message: `JSON5 parse failed: ${parsedRes.error}` },
+                    ],
+                    legacyIssues: [],
+                };
+            }
+            const legacyIssues = findLegacyConfigIssues(parsedRes.parsed);
+            const validated = validateConfigObject(parsedRes.parsed);
+            if (!validated.ok) {
+                return {
+                    path: configPath,
+                    exists: true,
+                    raw,
+                    parsed: parsedRes.parsed,
+                    valid: false,
+                    config: {},
+                    issues: validated.issues,
+                    legacyIssues,
+                };
+            }
+            return {
+                path: configPath,
+                exists: true,
+                raw,
+                parsed: parsedRes.parsed,
+                valid: true,
+                config: applyTalkApiKey(applySessionDefaults(validated.config)),
+                issues: [],
+                legacyIssues,
+            };
+        }
+        catch (err) {
+            return {
+                path: configPath,
+                exists: true,
+                raw: null,
+                parsed: {},
+                valid: false,
+                config: {},
+                issues: [{ path: "", message: `read failed: ${String(err)}` }],
+                legacyIssues: [],
+            };
+        }
+    }
+    async function writeConfigFile(cfg) {
+        await deps.fs.promises.mkdir(path.dirname(configPath), {
+            recursive: true,
+        });
+        const json = JSON.stringify(cfg, null, 2).trimEnd().concat("\n");
+        await deps.fs.promises.writeFile(configPath, json, "utf-8");
+    }
+    return {
+        configPath,
+        loadConfig,
+        readConfigFileSnapshot,
+        writeConfigFile,
+    };
+}
+const defaultIO = createConfigIO({ configPath: CONFIG_PATH_CLAWDBOT });
+export const loadConfig = defaultIO.loadConfig;
+export const readConfigFileSnapshot = defaultIO.readConfigFileSnapshot;
+export const writeConfigFile = defaultIO.writeConfigFile;

package/dist/config/legacy-migrate.js

@@ -0,0 +1,13 @@
+import { applyLegacyMigrations } from "./legacy.js";
+import { validateConfigObject } from "./validation.js";
+export function migrateLegacyConfig(raw) {
+    const { next, changes } = applyLegacyMigrations(raw);
+    if (!next)
+        return { config: null, changes: [] };
+    const validated = validateConfigObject(next);
+    if (!validated.ok) {
+        changes.push("Migration applied, but config still invalid; fix remaining issues manually.");
+        return { config: null, changes };
+    }
+    return { config: validated.config, changes };
+}