clawdbot 2026.1.4-1

package/dist/auto-reply/status.js

@@ -0,0 +1,158 @@
+import fs from "node:fs";
+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 { derivePromptTokens, normalizeUsage, } from "../agents/usage.js";
+import { resolveSessionTranscriptPath, } from "../config/sessions.js";
+import { shortenHomePath } from "../utils.js";
+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 formatKTokens = (value) => `${(value / 1000).toFixed(value >= 10_000 ? 0 : 1)}k`;
+const formatTokens = (total, contextTokens) => {
+    const ctx = contextTokens ?? null;
+    if (total == null) {
+        const ctxLabel = ctx ? formatKTokens(ctx) : "?";
+        return `unknown/${ctxLabel}`;
+    }
+    const pct = ctx ? Math.min(999, Math.round((total / ctx) * 100)) : null;
+    const totalLabel = formatKTokens(total);
+    const ctxLabel = ctx ? formatKTokens(ctx) : "?";
+    return `${totalLabel}/${ctxLabel}${pct !== null ? ` (${pct}%)` : ""}`;
+};
+const readUsageFromSessionLog = (sessionId) => {
+    // Transcripts always live at: ~/.clawdbot/sessions/<SessionId>.jsonl
+    if (!sessionId)
+        return undefined;
+    const logPath = resolveSessionTranscriptPath(sessionId);
+    if (!fs.existsSync(logPath))
+        return undefined;
+    try {
+        const lines = fs.readFileSync(logPath, "utf-8").split(/\n+/);
+        let input = 0;
+        let output = 0;
+        let promptTokens = 0;
+        let model;
+        let lastUsage;
+        for (const line of lines) {
+            if (!line.trim())
+                continue;
+            try {
+                const parsed = JSON.parse(line);
+                const usageRaw = parsed.message?.usage ?? parsed.usage;
+                const usage = normalizeUsage(usageRaw);
+                if (usage)
+                    lastUsage = usage;
+                model = parsed.message?.model ?? parsed.model ?? model;
+            }
+            catch {
+                // ignore bad lines
+            }
+        }
+        if (!lastUsage)
+            return undefined;
+        input = lastUsage.input ?? 0;
+        output = lastUsage.output ?? 0;
+        promptTokens =
+            derivePromptTokens(lastUsage) ?? lastUsage.total ?? input + output;
+        const total = lastUsage.total ?? promptTokens + output;
+        if (promptTokens === 0 && total === 0)
+            return undefined;
+        return { input, output, promptTokens, total, model };
+    }
+    catch {
+        return undefined;
+    }
+};
+export function buildStatusMessage(args) {
+    const now = args.now ?? Date.now();
+    const entry = args.sessionEntry;
+    const resolved = resolveConfiguredModelRef({
+        cfg: { agent: args.agent ?? {} },
+        defaultProvider: DEFAULT_PROVIDER,
+        defaultModel: DEFAULT_MODEL,
+    });
+    const provider = entry?.modelProvider ?? resolved.provider ?? DEFAULT_PROVIDER;
+    let model = entry?.model ?? resolved.model ?? DEFAULT_MODEL;
+    let contextTokens = entry?.contextTokens ??
+        args.agent?.contextTokens ??
+        lookupContextTokens(model) ??
+        DEFAULT_CONTEXT_TOKENS;
+    let totalTokens = entry?.totalTokens ??
+        (entry?.inputTokens ?? 0) + (entry?.outputTokens ?? 0);
+    // Prefer prompt-size tokens from the session transcript when it looks larger
+    // (cached prompt tokens are often missing from agent meta/store).
+    const logUsage = readUsageFromSessionLog(entry?.sessionId);
+    if (logUsage) {
+        const candidate = logUsage.promptTokens || logUsage.total;
+        if (!totalTokens || totalTokens === 0 || candidate > totalTokens) {
+            totalTokens = candidate;
+        }
+        if (!model)
+            model = logUsage.model ?? model;
+        if (!contextTokens && logUsage.model) {
+            contextTokens = lookupContextTokens(logUsage.model) ?? contextTokens;
+        }
+    }
+    const thinkLevel = args.resolvedThink ?? args.agent?.thinkingDefault ?? "off";
+    const verboseLevel = args.resolvedVerbose ?? args.agent?.verboseDefault ?? "off";
+    const elevatedLevel = args.sessionEntry?.elevatedLevel ?? args.agent?.elevatedDefault ?? "on";
+    const webLine = (() => {
+        if (args.webLinked === false) {
+            return "Web: not linked — run `clawdbot login` to scan the QR.";
+        }
+        const authAge = formatAge(args.webAuthAgeMs);
+        const heartbeat = typeof args.heartbeatSeconds === "number"
+            ? ` • heartbeat ${args.heartbeatSeconds}s`
+            : "";
+        return `Web: linked • auth refreshed ${authAge}${heartbeat}`;
+    })();
+    const sessionLine = [
+        `Session: ${args.sessionKey ?? "unknown"}`,
+        `scope ${args.sessionScope ?? "per-sender"}`,
+        entry?.updatedAt
+            ? `updated ${formatAge(now - entry.updatedAt)}`
+            : "no activity",
+        args.storePath ? `store ${shortenHomePath(args.storePath)}` : undefined,
+    ]
+        .filter(Boolean)
+        .join(" • ");
+    const isGroupSession = entry?.chatType === "group" ||
+        entry?.chatType === "room" ||
+        Boolean(args.sessionKey?.includes(":group:")) ||
+        Boolean(args.sessionKey?.includes(":channel:")) ||
+        Boolean(args.sessionKey?.startsWith("group:"));
+    const groupActivationLine = isGroupSession
+        ? `Group activation: ${args.groupActivation ?? entry?.groupActivation ?? "mention"}`
+        : undefined;
+    const contextLine = `Context: ${formatTokens(totalTokens, contextTokens ?? null)}${entry?.abortedLastRun ? " • last run aborted" : ""}`;
+    const optionsLine = `Options: thinking=${thinkLevel} | verbose=${verboseLevel} | elevated=${elevatedLevel} (set with /think <level>, /verbose on|off, /elevated on|off, /model <id>)`;
+    const modelLabel = model ? `${provider}/${model}` : "unknown";
+    const agentLine = `Agent: embedded pi • ${modelLabel}`;
+    const workspaceLine = args.workspaceDir
+        ? `Workspace: ${shortenHomePath(args.workspaceDir)}`
+        : undefined;
+    const helpersLine = "Shortcuts: /new reset | /restart relink";
+    return [
+        "⚙️ Status",
+        webLine,
+        agentLine,
+        workspaceLine,
+        contextLine,
+        sessionLine,
+        groupActivationLine,
+        optionsLine,
+        helpersLine,
+    ].join("\n");
+}

package/dist/auto-reply/templating.js

@@ -0,0 +1,9 @@
+// Simple {{Placeholder}} interpolation using inbound message context.
+export function applyTemplate(str, ctx) {
+    if (!str)
+        return "";
+    return str.replace(/{{\s*(\w+)\s*}}/g, (_, key) => {
+        const value = ctx[key];
+        return value == null ? "" : String(value);
+    });
+}

package/dist/auto-reply/thinking.js

@@ -0,0 +1,49 @@
+// Normalize user-provided thinking level strings to the canonical enum.
+export function normalizeThinkLevel(raw) {
+    if (!raw)
+        return undefined;
+    const key = raw.toLowerCase();
+    if (["off"].includes(key))
+        return "off";
+    if (["min", "minimal"].includes(key))
+        return "minimal";
+    if (["low", "thinkhard", "think-hard", "think_hard"].includes(key))
+        return "low";
+    if (["med", "medium", "thinkharder", "think-harder", "harder"].includes(key))
+        return "medium";
+    if ([
+        "high",
+        "ultra",
+        "ultrathink",
+        "think-hard",
+        "thinkhardest",
+        "highest",
+        "max",
+    ].includes(key))
+        return "high";
+    if (["think"].includes(key))
+        return "minimal";
+    return undefined;
+}
+// Normalize verbose flags used to toggle agent verbosity.
+export function normalizeVerboseLevel(raw) {
+    if (!raw)
+        return undefined;
+    const key = raw.toLowerCase();
+    if (["off", "false", "no", "0"].includes(key))
+        return "off";
+    if (["on", "full", "true", "yes", "1"].includes(key))
+        return "on";
+    return undefined;
+}
+// Normalize elevated flags used to toggle elevated bash permissions.
+export function normalizeElevatedLevel(raw) {
+    if (!raw)
+        return undefined;
+    const key = raw.toLowerCase();
+    if (["off", "false", "no", "0"].includes(key))
+        return "off";
+    if (["on", "true", "yes", "1"].includes(key))
+        return "on";
+    return undefined;
+}

package/dist/auto-reply/tokens.js

@@ -0,0 +1,2 @@
+export const HEARTBEAT_TOKEN = "HEARTBEAT_OK";
+export const SILENT_REPLY_TOKEN = "NO_REPLY";

package/dist/auto-reply/tool-meta.js

@@ -0,0 +1,74 @@
+import { formatToolSummary, resolveToolDisplay, } from "../agents/tool-display.js";
+import { shortenHomeInString, shortenHomePath } from "../utils.js";
+export function shortenPath(p) {
+    return shortenHomePath(p);
+}
+export function shortenMeta(meta) {
+    if (!meta)
+        return meta;
+    const colonIdx = meta.indexOf(":");
+    if (colonIdx === -1)
+        return shortenHomeInString(meta);
+    const base = meta.slice(0, colonIdx);
+    const rest = meta.slice(colonIdx);
+    return `${shortenHomeInString(base)}${rest}`;
+}
+export function formatToolAggregate(toolName, metas) {
+    const filtered = (metas ?? []).filter(Boolean).map(shortenMeta);
+    const display = resolveToolDisplay({ name: toolName });
+    const prefix = `${display.emoji} ${display.label}`;
+    if (!filtered.length)
+        return prefix;
+    const rawSegments = [];
+    // Group by directory and brace-collapse filenames
+    const grouped = {};
+    for (const m of filtered) {
+        if (!isPathLike(m)) {
+            rawSegments.push(m);
+            continue;
+        }
+        if (m.includes("→")) {
+            rawSegments.push(m);
+            continue;
+        }
+        const parts = m.split("/");
+        if (parts.length > 1) {
+            const dir = parts.slice(0, -1).join("/");
+            const base = parts.at(-1) ?? m;
+            if (!grouped[dir])
+                grouped[dir] = [];
+            grouped[dir].push(base);
+        }
+        else {
+            if (!grouped["."])
+                grouped["."] = [];
+            grouped["."].push(m);
+        }
+    }
+    const segments = Object.entries(grouped).map(([dir, files]) => {
+        const brace = files.length > 1 ? `{${files.join(", ")}}` : files[0];
+        if (dir === ".")
+            return brace;
+        return `${dir}/${brace}`;
+    });
+    const allSegments = [...rawSegments, ...segments];
+    return `${prefix}: ${allSegments.join("; ")}`;
+}
+export function formatToolPrefix(toolName, meta) {
+    const extra = meta?.trim() ? shortenMeta(meta) : undefined;
+    const display = resolveToolDisplay({ name: toolName, meta: extra });
+    return formatToolSummary(display);
+}
+function isPathLike(value) {
+    if (!value)
+        return false;
+    if (value.includes(" "))
+        return false;
+    if (value.includes("://"))
+        return false;
+    if (value.includes("·"))
+        return false;
+    if (value.includes("&&") || value.includes("||"))
+        return false;
+    return /^~?(\/[^\s]+)+$/.test(value);
+}

package/dist/auto-reply/transcription.js

@@ -0,0 +1,57 @@
+import crypto from "node:crypto";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { logVerbose, shouldLogVerbose } from "../globals.js";
+import { runExec } from "../process/exec.js";
+import { applyTemplate } from "./templating.js";
+export function isAudio(mediaType) {
+    return Boolean(mediaType?.startsWith("audio"));
+}
+export async function transcribeInboundAudio(cfg, ctx, runtime) {
+    const transcriber = cfg.routing?.transcribeAudio;
+    if (!transcriber?.command?.length)
+        return undefined;
+    const timeoutMs = Math.max((transcriber.timeoutSeconds ?? 45) * 1000, 1_000);
+    let tmpPath;
+    let mediaPath = ctx.MediaPath;
+    try {
+        if (!mediaPath && ctx.MediaUrl) {
+            const res = await fetch(ctx.MediaUrl);
+            if (!res.ok)
+                throw new Error(`HTTP ${res.status}`);
+            const arrayBuf = await res.arrayBuffer();
+            const buffer = Buffer.from(arrayBuf);
+            tmpPath = path.join(os.tmpdir(), `clawdbot-audio-${crypto.randomUUID()}.ogg`);
+            await fs.writeFile(tmpPath, buffer);
+            mediaPath = tmpPath;
+            if (shouldLogVerbose()) {
+                logVerbose(`Downloaded audio for transcription (${(buffer.length / (1024 * 1024)).toFixed(2)}MB) -> ${tmpPath}`);
+            }
+        }
+        if (!mediaPath)
+            return undefined;
+        const templCtx = { ...ctx, MediaPath: mediaPath };
+        const argv = transcriber.command.map((part) => applyTemplate(part, templCtx));
+        if (shouldLogVerbose()) {
+            logVerbose(`Transcribing audio via command: ${argv.join(" ")}`);
+        }
+        const { stdout } = await runExec(argv[0], argv.slice(1), {
+            timeoutMs,
+            maxBuffer: 5 * 1024 * 1024,
+        });
+        const text = stdout.trim();
+        if (!text)
+            return undefined;
+        return { text };
+    }
+    catch (err) {
+        runtime.error?.(`Audio transcription failed: ${String(err)}`);
+        return undefined;
+    }
+    finally {
+        if (tmpPath) {
+            void fs.unlink(tmpPath).catch(() => { });
+        }
+    }
+}

package/dist/auto-reply/types.js

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

package/dist/browser/bridge-server.js

@@ -0,0 +1,37 @@
+import express from "express";
+import { registerBrowserRoutes } from "./routes/index.js";
+import { createBrowserRouteContext, } from "./server-context.js";
+export async function startBrowserBridgeServer(params) {
+    const host = params.host ?? "127.0.0.1";
+    const port = params.port ?? 0;
+    const app = express();
+    app.use(express.json({ limit: "1mb" }));
+    const state = {
+        server: null,
+        port,
+        resolved: params.resolved,
+        profiles: new Map(),
+    };
+    const ctx = createBrowserRouteContext({
+        getState: () => state,
+    });
+    registerBrowserRoutes(app, ctx);
+    const server = await new Promise((resolve, reject) => {
+        const s = app.listen(port, host, () => resolve(s));
+        s.once("error", reject);
+    });
+    const address = server.address();
+    const resolvedPort = address?.port ?? port;
+    state.server = server;
+    state.port = resolvedPort;
+    state.resolved.controlHost = host;
+    state.resolved.controlPort = resolvedPort;
+    state.resolved.controlUrl = `http://${host}:${resolvedPort}`;
+    const baseUrl = state.resolved.controlUrl;
+    return { server, port: resolvedPort, baseUrl, state };
+}
+export async function stopBrowserBridgeServer(server) {
+    await new Promise((resolve) => {
+        server.close(() => resolve());
+    });
+}