clawdbot 2026.1.4-1

package/dist/gateway/session-utils.js

@@ -0,0 +1,216 @@
+import fs from "node:fs";
+import os from "node:os";
+import path from "node:path";
+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 { buildGroupDisplayName, loadSessionStore, resolveStorePath, } from "../config/sessions.js";
+export function readSessionMessages(sessionId, storePath) {
+    const candidates = resolveSessionTranscriptCandidates(sessionId, storePath);
+    const filePath = candidates.find((p) => fs.existsSync(p));
+    if (!filePath)
+        return [];
+    const lines = fs.readFileSync(filePath, "utf-8").split(/\r?\n/);
+    const messages = [];
+    for (const line of lines) {
+        if (!line.trim())
+            continue;
+        try {
+            const parsed = JSON.parse(line);
+            if (parsed?.message) {
+                messages.push(parsed.message);
+            }
+        }
+        catch {
+            // ignore bad lines
+        }
+    }
+    return messages;
+}
+export function resolveSessionTranscriptCandidates(sessionId, storePath) {
+    const candidates = [];
+    if (storePath) {
+        const dir = path.dirname(storePath);
+        candidates.push(path.join(dir, `${sessionId}.jsonl`));
+    }
+    candidates.push(path.join(os.homedir(), ".clawdbot", "sessions", `${sessionId}.jsonl`));
+    return candidates;
+}
+export function archiveFileOnDisk(filePath, reason) {
+    const ts = new Date().toISOString().replaceAll(":", "-");
+    const archived = `${filePath}.${reason}.${ts}`;
+    fs.renameSync(filePath, archived);
+    return archived;
+}
+function jsonUtf8Bytes(value) {
+    try {
+        return Buffer.byteLength(JSON.stringify(value), "utf8");
+    }
+    catch {
+        return Buffer.byteLength(String(value), "utf8");
+    }
+}
+export function capArrayByJsonBytes(items, maxBytes) {
+    if (items.length === 0)
+        return { items, bytes: 2 };
+    const parts = items.map((item) => jsonUtf8Bytes(item));
+    let bytes = 2 + parts.reduce((a, b) => a + b, 0) + (items.length - 1);
+    let start = 0;
+    while (bytes > maxBytes && start < items.length - 1) {
+        bytes -= parts[start] + 1;
+        start += 1;
+    }
+    const next = start > 0 ? items.slice(start) : items;
+    return { items: next, bytes };
+}
+export function loadSessionEntry(sessionKey) {
+    const cfg = loadConfig();
+    const sessionCfg = cfg.session;
+    const storePath = sessionCfg?.store
+        ? resolveStorePath(sessionCfg.store)
+        : resolveStorePath(undefined);
+    const store = loadSessionStore(storePath);
+    const entry = store[sessionKey];
+    return { cfg, storePath, store, entry };
+}
+export function classifySessionKey(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";
+}
+export function parseGroupKey(key) {
+    if (key.startsWith("group:")) {
+        const raw = key.slice("group:".length);
+        return raw ? { id: raw } : null;
+    }
+    const parts = key.split(":").filter(Boolean);
+    if (parts.length >= 3) {
+        const [surface, kind, ...rest] = parts;
+        if (kind === "group" || kind === "channel") {
+            const id = rest.join(":");
+            return { surface, kind, id };
+        }
+    }
+    return null;
+}
+export function getSessionDefaults(cfg) {
+    const resolved = resolveConfiguredModelRef({
+        cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+        defaultModel: DEFAULT_MODEL,
+    });
+    const contextTokens = cfg.agent?.contextTokens ??
+        lookupContextTokens(resolved.model) ??
+        DEFAULT_CONTEXT_TOKENS;
+    return {
+        model: resolved.model ?? null,
+        contextTokens: contextTokens ?? null,
+    };
+}
+export function resolveSessionModelRef(cfg, entry) {
+    const resolved = resolveConfiguredModelRef({
+        cfg,
+        defaultProvider: DEFAULT_PROVIDER,
+        defaultModel: DEFAULT_MODEL,
+    });
+    let provider = resolved.provider;
+    let model = resolved.model;
+    const storedModelOverride = entry?.modelOverride?.trim();
+    if (storedModelOverride) {
+        provider = entry?.providerOverride?.trim() || provider;
+        model = storedModelOverride;
+    }
+    return { provider, model };
+}
+export function listSessionsFromStore(params) {
+    const { cfg, storePath, store, opts } = params;
+    const now = Date.now();
+    const includeGlobal = opts.includeGlobal === true;
+    const includeUnknown = opts.includeUnknown === true;
+    const activeMinutes = typeof opts.activeMinutes === "number" &&
+        Number.isFinite(opts.activeMinutes)
+        ? Math.max(1, Math.floor(opts.activeMinutes))
+        : undefined;
+    let sessions = Object.entries(store)
+        .filter(([key]) => {
+        if (!includeGlobal && key === "global")
+            return false;
+        if (!includeUnknown && key === "unknown")
+            return false;
+        return true;
+    })
+        .map(([key, entry]) => {
+        const updatedAt = entry?.updatedAt ?? null;
+        const input = entry?.inputTokens ?? 0;
+        const output = entry?.outputTokens ?? 0;
+        const total = entry?.totalTokens ?? input + output;
+        const parsed = parseGroupKey(key);
+        const surface = entry?.surface ?? parsed?.surface;
+        const subject = entry?.subject;
+        const room = entry?.room;
+        const space = entry?.space;
+        const id = parsed?.id;
+        const displayName = entry?.displayName ??
+            (surface
+                ? buildGroupDisplayName({
+                    surface,
+                    subject,
+                    room,
+                    space,
+                    id,
+                    key,
+                })
+                : undefined);
+        return {
+            key,
+            kind: classifySessionKey(key, entry),
+            displayName,
+            surface,
+            subject,
+            room,
+            space,
+            chatType: entry?.chatType,
+            updatedAt,
+            sessionId: entry?.sessionId,
+            systemSent: entry?.systemSent,
+            abortedLastRun: entry?.abortedLastRun,
+            thinkingLevel: entry?.thinkingLevel,
+            verboseLevel: entry?.verboseLevel,
+            elevatedLevel: entry?.elevatedLevel,
+            sendPolicy: entry?.sendPolicy,
+            inputTokens: entry?.inputTokens,
+            outputTokens: entry?.outputTokens,
+            totalTokens: total,
+            model: entry?.model,
+            contextTokens: entry?.contextTokens,
+            lastChannel: entry?.lastChannel,
+            lastTo: entry?.lastTo,
+        };
+    })
+        .sort((a, b) => (b.updatedAt ?? 0) - (a.updatedAt ?? 0));
+    if (activeMinutes !== undefined) {
+        const cutoff = now - activeMinutes * 60_000;
+        sessions = sessions.filter((s) => (s.updatedAt ?? 0) >= cutoff);
+    }
+    if (typeof opts.limit === "number" && Number.isFinite(opts.limit)) {
+        const limit = Math.max(1, Math.floor(opts.limit));
+        sessions = sessions.slice(0, limit);
+    }
+    return {
+        ts: now,
+        path: storePath,
+        count: sessions.length,
+        defaults: getSessionDefaults(cfg),
+        sessions,
+    };
+}

package/dist/gateway/ws-log.js

@@ -0,0 +1,349 @@
+import chalk from "chalk";
+import { isVerbose } from "../globals.js";
+import { DEFAULT_WS_SLOW_MS, getGatewayWsLogStyle } from "./ws-logging.js";
+const LOG_VALUE_LIMIT = 240;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const wsInflightCompact = new Map();
+let wsLastCompactConnId;
+const wsInflightOptimized = new Map();
+const wsInflightSince = new Map();
+export function shortId(value) {
+    const s = value.trim();
+    if (UUID_RE.test(s))
+        return `${s.slice(0, 8)}…${s.slice(-4)}`;
+    if (s.length <= 24)
+        return s;
+    return `${s.slice(0, 12)}…${s.slice(-4)}`;
+}
+export function formatForLog(value) {
+    try {
+        if (value instanceof Error) {
+            const parts = [];
+            if (value.name)
+                parts.push(value.name);
+            if (value.message)
+                parts.push(value.message);
+            const code = "code" in value &&
+                (typeof value.code === "string" || typeof value.code === "number")
+                ? String(value.code)
+                : "";
+            if (code)
+                parts.push(`code=${code}`);
+            const combined = parts.filter(Boolean).join(": ").trim();
+            if (combined) {
+                return combined.length > LOG_VALUE_LIMIT
+                    ? `${combined.slice(0, LOG_VALUE_LIMIT)}...`
+                    : combined;
+            }
+        }
+        if (value && typeof value === "object") {
+            const rec = value;
+            if (typeof rec.message === "string" && rec.message.trim()) {
+                const name = typeof rec.name === "string" ? rec.name.trim() : "";
+                const code = typeof rec.code === "string" || typeof rec.code === "number"
+                    ? String(rec.code)
+                    : "";
+                const parts = [name, rec.message.trim()].filter(Boolean);
+                if (code)
+                    parts.push(`code=${code}`);
+                const combined = parts.join(": ").trim();
+                return combined.length > LOG_VALUE_LIMIT
+                    ? `${combined.slice(0, LOG_VALUE_LIMIT)}...`
+                    : combined;
+            }
+        }
+        const str = typeof value === "string" || typeof value === "number"
+            ? String(value)
+            : JSON.stringify(value);
+        if (!str)
+            return "";
+        return str.length > LOG_VALUE_LIMIT
+            ? `${str.slice(0, LOG_VALUE_LIMIT)}...`
+            : str;
+    }
+    catch {
+        return String(value);
+    }
+}
+function compactPreview(input, maxLen = 160) {
+    const oneLine = input.replace(/\s+/g, " ").trim();
+    if (oneLine.length <= maxLen)
+        return oneLine;
+    return `${oneLine.slice(0, Math.max(0, maxLen - 1))}…`;
+}
+export function summarizeAgentEventForWsLog(payload) {
+    if (!payload || typeof payload !== "object")
+        return {};
+    const rec = payload;
+    const runId = typeof rec.runId === "string" ? rec.runId : undefined;
+    const stream = typeof rec.stream === "string" ? rec.stream : undefined;
+    const seq = typeof rec.seq === "number" ? rec.seq : undefined;
+    const data = rec.data && typeof rec.data === "object"
+        ? rec.data
+        : undefined;
+    const extra = {};
+    if (runId)
+        extra.run = shortId(runId);
+    if (stream)
+        extra.stream = stream;
+    if (seq !== undefined)
+        extra.aseq = seq;
+    if (!data)
+        return extra;
+    if (stream === "assistant") {
+        const text = typeof data.text === "string" ? data.text : undefined;
+        if (text?.trim())
+            extra.text = compactPreview(text);
+        const mediaUrls = Array.isArray(data.mediaUrls)
+            ? data.mediaUrls
+            : undefined;
+        if (mediaUrls && mediaUrls.length > 0)
+            extra.media = mediaUrls.length;
+        return extra;
+    }
+    if (stream === "tool") {
+        const phase = typeof data.phase === "string" ? data.phase : undefined;
+        const name = typeof data.name === "string" ? data.name : undefined;
+        if (phase || name)
+            extra.tool = `${phase ?? "?"}:${name ?? "?"}`;
+        const toolCallId = typeof data.toolCallId === "string" ? data.toolCallId : undefined;
+        if (toolCallId)
+            extra.call = shortId(toolCallId);
+        const meta = typeof data.meta === "string" ? data.meta : undefined;
+        if (meta?.trim())
+            extra.meta = meta;
+        if (typeof data.isError === "boolean")
+            extra.err = data.isError;
+        return extra;
+    }
+    if (stream === "job") {
+        const state = typeof data.state === "string" ? data.state : undefined;
+        if (state)
+            extra.state = state;
+        if (data.to === null)
+            extra.to = null;
+        else if (typeof data.to === "string")
+            extra.to = data.to;
+        if (typeof data.durationMs === "number")
+            extra.ms = Math.round(data.durationMs);
+        if (typeof data.aborted === "boolean")
+            extra.aborted = data.aborted;
+        const error = typeof data.error === "string" ? data.error : undefined;
+        if (error?.trim())
+            extra.error = compactPreview(error, 120);
+        return extra;
+    }
+    const reason = typeof data.reason === "string" ? data.reason : undefined;
+    if (reason?.trim())
+        extra.reason = reason;
+    return extra;
+}
+export function logWs(direction, kind, meta) {
+    const style = getGatewayWsLogStyle();
+    if (!isVerbose()) {
+        logWsOptimized(direction, kind, meta);
+        return;
+    }
+    if (style === "compact" || style === "auto") {
+        logWsCompact(direction, kind, meta);
+        return;
+    }
+    const now = Date.now();
+    const connId = typeof meta?.connId === "string" ? meta.connId : undefined;
+    const id = typeof meta?.id === "string" ? meta.id : undefined;
+    const method = typeof meta?.method === "string" ? meta.method : undefined;
+    const ok = typeof meta?.ok === "boolean" ? meta.ok : undefined;
+    const event = typeof meta?.event === "string" ? meta.event : undefined;
+    const inflightKey = connId && id ? `${connId}:${id}` : undefined;
+    if (direction === "in" && kind === "req" && inflightKey) {
+        wsInflightSince.set(inflightKey, now);
+    }
+    const durationMs = direction === "out" && kind === "res" && inflightKey
+        ? (() => {
+            const startedAt = wsInflightSince.get(inflightKey);
+            if (startedAt === undefined)
+                return undefined;
+            wsInflightSince.delete(inflightKey);
+            return now - startedAt;
+        })()
+        : undefined;
+    const dirArrow = direction === "in" ? "←" : "→";
+    const dirColor = direction === "in" ? chalk.greenBright : chalk.cyanBright;
+    const prefix = `${chalk.gray("[gws]")} ${dirColor(dirArrow)} ${chalk.bold(kind)}`;
+    const headline = (kind === "req" || kind === "res") && method
+        ? chalk.bold(method)
+        : kind === "event" && event
+            ? chalk.bold(event)
+            : undefined;
+    const statusToken = kind === "res" && ok !== undefined
+        ? ok
+            ? chalk.greenBright("✓")
+            : chalk.redBright("✗")
+        : undefined;
+    const durationToken = typeof durationMs === "number" ? chalk.dim(`${durationMs}ms`) : undefined;
+    const restMeta = [];
+    if (meta) {
+        for (const [key, value] of Object.entries(meta)) {
+            if (value === undefined)
+                continue;
+            if (key === "connId" || key === "id")
+                continue;
+            if (key === "method" || key === "ok")
+                continue;
+            if (key === "event")
+                continue;
+            restMeta.push(`${chalk.dim(key)}=${formatForLog(value)}`);
+        }
+    }
+    const trailing = [];
+    if (connId) {
+        trailing.push(`${chalk.dim("conn")}=${chalk.gray(shortId(connId))}`);
+    }
+    if (id)
+        trailing.push(`${chalk.dim("id")}=${chalk.gray(shortId(id))}`);
+    const tokens = [
+        prefix,
+        statusToken,
+        headline,
+        durationToken,
+        ...restMeta,
+        ...trailing,
+    ].filter((t) => Boolean(t));
+    console.log(tokens.join(" "));
+}
+function logWsOptimized(direction, kind, meta) {
+    const connId = typeof meta?.connId === "string" ? meta.connId : undefined;
+    const id = typeof meta?.id === "string" ? meta.id : undefined;
+    const ok = typeof meta?.ok === "boolean" ? meta.ok : undefined;
+    const method = typeof meta?.method === "string" ? meta.method : undefined;
+    const inflightKey = connId && id ? `${connId}:${id}` : undefined;
+    if (direction === "in" && kind === "req" && inflightKey) {
+        wsInflightOptimized.set(inflightKey, Date.now());
+        if (wsInflightOptimized.size > 2000)
+            wsInflightOptimized.clear();
+        return;
+    }
+    if (kind === "parse-error") {
+        const errorMsg = typeof meta?.error === "string" ? formatForLog(meta.error) : undefined;
+        console.log([
+            `${chalk.gray("[gws]")} ${chalk.redBright("✗")} ${chalk.bold("parse-error")}`,
+            errorMsg ? `${chalk.dim("error")}=${errorMsg}` : undefined,
+            `${chalk.dim("conn")}=${chalk.gray(shortId(connId ?? "?"))}`,
+        ]
+            .filter((t) => Boolean(t))
+            .join(" "));
+        return;
+    }
+    if (direction !== "out" || kind !== "res")
+        return;
+    const startedAt = inflightKey
+        ? wsInflightOptimized.get(inflightKey)
+        : undefined;
+    if (inflightKey)
+        wsInflightOptimized.delete(inflightKey);
+    const durationMs = typeof startedAt === "number" ? Date.now() - startedAt : undefined;
+    const shouldLog = ok === false ||
+        (typeof durationMs === "number" && durationMs >= DEFAULT_WS_SLOW_MS);
+    if (!shouldLog)
+        return;
+    const statusToken = ok === undefined
+        ? undefined
+        : ok
+            ? chalk.greenBright("✓")
+            : chalk.redBright("✗");
+    const durationToken = typeof durationMs === "number" ? chalk.dim(`${durationMs}ms`) : undefined;
+    const restMeta = [];
+    if (meta) {
+        for (const [key, value] of Object.entries(meta)) {
+            if (value === undefined)
+                continue;
+            if (key === "connId" || key === "id")
+                continue;
+            if (key === "method" || key === "ok")
+                continue;
+            restMeta.push(`${chalk.dim(key)}=${formatForLog(value)}`);
+        }
+    }
+    const tokens = [
+        `${chalk.gray("[gws]")} ${chalk.yellowBright("⇄")} ${chalk.bold("res")}`,
+        statusToken,
+        method ? chalk.bold(method) : undefined,
+        durationToken,
+        ...restMeta,
+        connId ? `${chalk.dim("conn")}=${chalk.gray(shortId(connId))}` : undefined,
+        id ? `${chalk.dim("id")}=${chalk.gray(shortId(id))}` : undefined,
+    ].filter((t) => Boolean(t));
+    console.log(tokens.join(" "));
+}
+function logWsCompact(direction, kind, meta) {
+    const now = Date.now();
+    const connId = typeof meta?.connId === "string" ? meta.connId : undefined;
+    const id = typeof meta?.id === "string" ? meta.id : undefined;
+    const method = typeof meta?.method === "string" ? meta.method : undefined;
+    const ok = typeof meta?.ok === "boolean" ? meta.ok : undefined;
+    const inflightKey = connId && id ? `${connId}:${id}` : undefined;
+    if (kind === "req" && direction === "in" && inflightKey) {
+        wsInflightCompact.set(inflightKey, { ts: now, method, meta });
+        return;
+    }
+    const compactArrow = (() => {
+        if (kind === "req" || kind === "res")
+            return "⇄";
+        return direction === "in" ? "←" : "→";
+    })();
+    const arrowColor = kind === "req" || kind === "res"
+        ? chalk.yellowBright
+        : direction === "in"
+            ? chalk.greenBright
+            : chalk.cyanBright;
+    const prefix = `${chalk.gray("[gws]")} ${arrowColor(compactArrow)} ${chalk.bold(kind)}`;
+    const statusToken = kind === "res" && ok !== undefined
+        ? ok
+            ? chalk.greenBright("✓")
+            : chalk.redBright("✗")
+        : undefined;
+    const startedAt = kind === "res" && direction === "out" && inflightKey
+        ? wsInflightCompact.get(inflightKey)?.ts
+        : undefined;
+    if (kind === "res" && direction === "out" && inflightKey) {
+        wsInflightCompact.delete(inflightKey);
+    }
+    const durationToken = typeof startedAt === "number"
+        ? chalk.dim(`${now - startedAt}ms`)
+        : undefined;
+    const headline = (kind === "req" || kind === "res") && method
+        ? chalk.bold(method)
+        : kind === "event" && typeof meta?.event === "string"
+            ? chalk.bold(meta.event)
+            : undefined;
+    const restMeta = [];
+    if (meta) {
+        for (const [key, value] of Object.entries(meta)) {
+            if (value === undefined)
+                continue;
+            if (key === "connId" || key === "id")
+                continue;
+            if (key === "method" || key === "ok")
+                continue;
+            if (key === "event")
+                continue;
+            restMeta.push(`${chalk.dim(key)}=${formatForLog(value)}`);
+        }
+    }
+    const trailing = [];
+    if (connId && connId !== wsLastCompactConnId) {
+        trailing.push(`${chalk.dim("conn")}=${chalk.gray(shortId(connId))}`);
+        wsLastCompactConnId = connId;
+    }
+    if (id)
+        trailing.push(`${chalk.dim("id")}=${chalk.gray(shortId(id))}`);
+    const tokens = [
+        prefix,
+        statusToken,
+        headline,
+        durationToken,
+        ...restMeta,
+        ...trailing,
+    ].filter((t) => Boolean(t));
+    console.log(tokens.join(" "));
+}

package/dist/gateway/ws-logging.js

@@ -0,0 +1,8 @@
+let gatewayWsLogStyle = "auto";
+export function setGatewayWsLogStyle(style) {
+    gatewayWsLogStyle = style;
+}
+export function getGatewayWsLogStyle() {
+    return gatewayWsLogStyle;
+}
+export const DEFAULT_WS_SLOW_MS = 50;

package/dist/globals.js

@@ -0,0 +1,41 @@
+import chalk from "chalk";
+import { getLogger, isFileLogLevelEnabled } from "./logging.js";
+let globalVerbose = false;
+let globalYes = false;
+export function setVerbose(v) {
+    globalVerbose = v;
+}
+export function isVerbose() {
+    return globalVerbose;
+}
+export function shouldLogVerbose() {
+    return globalVerbose || isFileLogLevelEnabled("debug");
+}
+export function logVerbose(message) {
+    if (!shouldLogVerbose())
+        return;
+    try {
+        getLogger().debug({ message }, "verbose");
+    }
+    catch {
+        // ignore logger failures to avoid breaking verbose printing
+    }
+    if (!globalVerbose)
+        return;
+    console.log(chalk.gray(message));
+}
+export function logVerboseConsole(message) {
+    if (!globalVerbose)
+        return;
+    console.log(chalk.gray(message));
+}
+export function setYes(v) {
+    globalYes = v;
+}
+export function isYes() {
+    return globalYes;
+}
+export const success = chalk.green;
+export const warn = chalk.yellow;
+export const info = chalk.cyan;
+export const danger = chalk.red;