clawdbot 2026.1.4-1

package/dist/media/constants.js

@@ -0,0 +1,33 @@
+export const MAX_IMAGE_BYTES = 6 * 1024 * 1024; // 6MB
+export const MAX_AUDIO_BYTES = 16 * 1024 * 1024; // 16MB
+export const MAX_VIDEO_BYTES = 16 * 1024 * 1024; // 16MB
+export const MAX_DOCUMENT_BYTES = 100 * 1024 * 1024; // 100MB
+export function mediaKindFromMime(mime) {
+    if (!mime)
+        return "unknown";
+    if (mime.startsWith("image/"))
+        return "image";
+    if (mime.startsWith("audio/"))
+        return "audio";
+    if (mime.startsWith("video/"))
+        return "video";
+    if (mime === "application/pdf")
+        return "document";
+    if (mime.startsWith("application/"))
+        return "document";
+    return "unknown";
+}
+export function maxBytesForKind(kind) {
+    switch (kind) {
+        case "image":
+            return MAX_IMAGE_BYTES;
+        case "audio":
+            return MAX_AUDIO_BYTES;
+        case "video":
+            return MAX_VIDEO_BYTES;
+        case "document":
+            return MAX_DOCUMENT_BYTES;
+        default:
+            return MAX_DOCUMENT_BYTES;
+    }
+}

package/dist/media/host.js

@@ -0,0 +1,42 @@
+import fs from "node:fs/promises";
+import { ensurePortAvailable, PortInUseError } from "../infra/ports.js";
+import { getTailnetHostname } from "../infra/tailscale.js";
+import { logInfo } from "../logger.js";
+import { defaultRuntime } from "../runtime.js";
+import { startMediaServer } from "./server.js";
+import { saveMediaSource } from "./store.js";
+const DEFAULT_PORT = 42873;
+const TTL_MS = 2 * 60 * 1000;
+let mediaServer = null;
+export async function ensureMediaHosted(source, opts = {}) {
+    const port = opts.port ?? DEFAULT_PORT;
+    const runtime = opts.runtime ?? defaultRuntime;
+    const saved = await saveMediaSource(source);
+    const hostname = await getTailnetHostname();
+    // Decide whether we must start a media server.
+    const needsServerStart = await isPortFree(port);
+    if (needsServerStart && !opts.startServer) {
+        await fs.rm(saved.path).catch(() => { });
+        throw new Error("Media hosting requires the webhook/Funnel server. Start `clawdbot webhook`/`clawdbot up` or re-run with --serve-media.");
+    }
+    if (needsServerStart && opts.startServer) {
+        if (!mediaServer) {
+            mediaServer = await startMediaServer(port, TTL_MS, runtime);
+            logInfo(`📡 Started temporary media host on http://localhost:${port}/media/:id (TTL ${TTL_MS / 1000}s)`, runtime);
+            mediaServer.unref?.();
+        }
+    }
+    const url = `https://${hostname}/media/${saved.id}`;
+    return { url, id: saved.id, size: saved.size };
+}
+async function isPortFree(port) {
+    try {
+        await ensurePortAvailable(port);
+        return true;
+    }
+    catch (err) {
+        if (err instanceof PortInUseError)
+            return false;
+        throw err;
+    }
+}

package/dist/media/image-ops.js

@@ -0,0 +1,121 @@
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { runExec } from "../process/exec.js";
+function isBun() {
+    return typeof process.versions.bun === "string";
+}
+function prefersSips() {
+    return (process.env.CLAWDBOT_IMAGE_BACKEND === "sips" ||
+        (process.env.CLAWDBOT_IMAGE_BACKEND !== "sharp" &&
+            isBun() &&
+            process.platform === "darwin"));
+}
+async function loadSharp() {
+    const mod = (await import("sharp"));
+    const sharp = mod.default ?? mod;
+    return (buffer) => sharp(buffer, { failOnError: false });
+}
+async function withTempDir(fn) {
+    const dir = await fs.mkdtemp(path.join(os.tmpdir(), "clawdbot-img-"));
+    try {
+        return await fn(dir);
+    }
+    finally {
+        await fs.rm(dir, { recursive: true, force: true }).catch(() => { });
+    }
+}
+async function sipsMetadataFromBuffer(buffer) {
+    return await withTempDir(async (dir) => {
+        const input = path.join(dir, "in.img");
+        await fs.writeFile(input, buffer);
+        const { stdout } = await runExec("/usr/bin/sips", ["-g", "pixelWidth", "-g", "pixelHeight", input], {
+            timeoutMs: 10_000,
+            maxBuffer: 512 * 1024,
+        });
+        const w = stdout.match(/pixelWidth:\s*([0-9]+)/);
+        const h = stdout.match(/pixelHeight:\s*([0-9]+)/);
+        if (!w?.[1] || !h?.[1])
+            return null;
+        const width = Number.parseInt(w[1], 10);
+        const height = Number.parseInt(h[1], 10);
+        if (!Number.isFinite(width) || !Number.isFinite(height))
+            return null;
+        if (width <= 0 || height <= 0)
+            return null;
+        return { width, height };
+    });
+}
+async function sipsResizeToJpeg(params) {
+    return await withTempDir(async (dir) => {
+        const input = path.join(dir, "in.img");
+        const output = path.join(dir, "out.jpg");
+        await fs.writeFile(input, params.buffer);
+        await runExec("/usr/bin/sips", [
+            "-Z",
+            String(Math.max(1, Math.round(params.maxSide))),
+            "-s",
+            "format",
+            "jpeg",
+            "-s",
+            "formatOptions",
+            String(Math.max(1, Math.min(100, Math.round(params.quality)))),
+            input,
+            "--out",
+            output,
+        ], { timeoutMs: 20_000, maxBuffer: 1024 * 1024 });
+        return await fs.readFile(output);
+    });
+}
+export async function getImageMetadata(buffer) {
+    if (prefersSips()) {
+        return await sipsMetadataFromBuffer(buffer).catch(() => null);
+    }
+    try {
+        const sharp = await loadSharp();
+        const meta = await sharp(buffer).metadata();
+        const width = Number(meta.width ?? 0);
+        const height = Number(meta.height ?? 0);
+        if (!Number.isFinite(width) || !Number.isFinite(height))
+            return null;
+        if (width <= 0 || height <= 0)
+            return null;
+        return { width, height };
+    }
+    catch {
+        return null;
+    }
+}
+export async function resizeToJpeg(params) {
+    if (prefersSips()) {
+        // Avoid enlarging by checking dimensions first (sips has no withoutEnlargement flag).
+        if (params.withoutEnlargement !== false) {
+            const meta = await getImageMetadata(params.buffer);
+            if (meta) {
+                const maxDim = Math.max(meta.width, meta.height);
+                if (maxDim > 0 && maxDim <= params.maxSide) {
+                    return await sipsResizeToJpeg({
+                        buffer: params.buffer,
+                        maxSide: maxDim,
+                        quality: params.quality,
+                    });
+                }
+            }
+        }
+        return await sipsResizeToJpeg({
+            buffer: params.buffer,
+            maxSide: params.maxSide,
+            quality: params.quality,
+        });
+    }
+    const sharp = await loadSharp();
+    return await sharp(params.buffer)
+        .resize({
+        width: params.maxSide,
+        height: params.maxSide,
+        fit: "inside",
+        withoutEnlargement: params.withoutEnlargement !== false,
+    })
+        .jpeg({ quality: params.quality, mozjpeg: true })
+        .toBuffer();
+}

package/dist/media/mime.js

@@ -0,0 +1,115 @@
+import path from "node:path";
+import { fileTypeFromBuffer } from "file-type";
+import { mediaKindFromMime } from "./constants.js";
+// Map common mimes to preferred file extensions.
+const EXT_BY_MIME = {
+    "image/jpeg": ".jpg",
+    "image/png": ".png",
+    "image/webp": ".webp",
+    "image/gif": ".gif",
+    "audio/ogg": ".ogg",
+    "audio/mpeg": ".mp3",
+    "video/mp4": ".mp4",
+    "application/pdf": ".pdf",
+    "application/json": ".json",
+    "application/zip": ".zip",
+    "application/gzip": ".gz",
+    "application/x-tar": ".tar",
+    "application/x-7z-compressed": ".7z",
+    "application/vnd.rar": ".rar",
+    "application/msword": ".doc",
+    "application/vnd.ms-excel": ".xls",
+    "application/vnd.ms-powerpoint": ".ppt",
+    "application/vnd.openxmlformats-officedocument.wordprocessingml.document": ".docx",
+    "application/vnd.openxmlformats-officedocument.spreadsheetml.sheet": ".xlsx",
+    "application/vnd.openxmlformats-officedocument.presentationml.presentation": ".pptx",
+    "text/csv": ".csv",
+    "text/plain": ".txt",
+    "text/markdown": ".md",
+};
+const MIME_BY_EXT = Object.fromEntries(Object.entries(EXT_BY_MIME).map(([mime, ext]) => [ext, mime]));
+function normalizeHeaderMime(mime) {
+    if (!mime)
+        return undefined;
+    const cleaned = mime.split(";")[0]?.trim().toLowerCase();
+    return cleaned || undefined;
+}
+async function sniffMime(buffer) {
+    if (!buffer)
+        return undefined;
+    try {
+        const type = await fileTypeFromBuffer(buffer);
+        return type?.mime ?? undefined;
+    }
+    catch {
+        return undefined;
+    }
+}
+function extFromPath(filePath) {
+    if (!filePath)
+        return undefined;
+    try {
+        if (/^https?:\/\//i.test(filePath)) {
+            const url = new URL(filePath);
+            return path.extname(url.pathname).toLowerCase() || undefined;
+        }
+    }
+    catch {
+        // fall back to plain path parsing
+    }
+    const ext = path.extname(filePath).toLowerCase();
+    return ext || undefined;
+}
+export function detectMime(opts) {
+    return detectMimeImpl(opts);
+}
+function isGenericMime(mime) {
+    if (!mime)
+        return true;
+    const m = mime.toLowerCase();
+    return m === "application/octet-stream" || m === "application/zip";
+}
+async function detectMimeImpl(opts) {
+    const ext = extFromPath(opts.filePath);
+    const extMime = ext ? MIME_BY_EXT[ext] : undefined;
+    const headerMime = normalizeHeaderMime(opts.headerMime);
+    const sniffed = await sniffMime(opts.buffer);
+    // Prefer sniffed types, but don't let generic container types override a more
+    // specific extension mapping (e.g. XLSX vs ZIP).
+    if (sniffed && (!isGenericMime(sniffed) || !extMime))
+        return sniffed;
+    if (extMime)
+        return extMime;
+    if (headerMime && !isGenericMime(headerMime))
+        return headerMime;
+    if (sniffed)
+        return sniffed;
+    if (headerMime)
+        return headerMime;
+    return undefined;
+}
+export function extensionForMime(mime) {
+    if (!mime)
+        return undefined;
+    return EXT_BY_MIME[mime.toLowerCase()];
+}
+export function imageMimeFromFormat(format) {
+    if (!format)
+        return undefined;
+    switch (format.toLowerCase()) {
+        case "jpg":
+        case "jpeg":
+            return "image/jpeg";
+        case "png":
+            return "image/png";
+        case "webp":
+            return "image/webp";
+        case "gif":
+            return "image/gif";
+        default:
+            return undefined;
+    }
+}
+export function kindFromMime(mime) {
+    return mediaKindFromMime(mime);
+}

package/dist/media/parse.js

@@ -0,0 +1,81 @@
+// Shared helpers for parsing MEDIA tokens from command/stdout text.
+// Allow optional wrapping backticks and punctuation after the token; capture the core token.
+export const MEDIA_TOKEN_RE = /\bMEDIA:\s*`?([^\n]+)`?/gi;
+export function normalizeMediaSource(src) {
+    return src.startsWith("file://") ? src.replace("file://", "") : src;
+}
+function cleanCandidate(raw) {
+    return raw.replace(/^[`"'[{(]+/, "").replace(/[`"'\\})\],]+$/, "");
+}
+function isValidMedia(candidate) {
+    if (!candidate)
+        return false;
+    if (candidate.length > 1024)
+        return false;
+    if (/\s/.test(candidate))
+        return false;
+    return (/^https?:\/\//i.test(candidate) ||
+        candidate.startsWith("/") ||
+        candidate.startsWith("./"));
+}
+export function splitMediaFromOutput(raw) {
+    const trimmedRaw = raw.trim();
+    if (!trimmedRaw)
+        return { text: "" };
+    const media = [];
+    let foundMediaToken = false;
+    // Collect tokens line by line so we can strip them cleanly.
+    const lines = trimmedRaw.split("\n");
+    const keptLines = [];
+    for (const line of lines) {
+        const matches = Array.from(line.matchAll(MEDIA_TOKEN_RE));
+        if (matches.length === 0) {
+            keptLines.push(line);
+            continue;
+        }
+        foundMediaToken = true;
+        const pieces = [];
+        let cursor = 0;
+        let hasValidMedia = false;
+        for (const match of matches) {
+            const start = match.index ?? 0;
+            pieces.push(line.slice(cursor, start));
+            const payload = match[1];
+            const parts = payload.split(/\s+/).filter(Boolean);
+            const invalidParts = [];
+            for (const part of parts) {
+                const candidate = normalizeMediaSource(cleanCandidate(part));
+                if (isValidMedia(candidate)) {
+                    media.push(candidate);
+                    hasValidMedia = true;
+                }
+                else {
+                    invalidParts.push(part);
+                }
+            }
+            if (hasValidMedia && invalidParts.length > 0) {
+                pieces.push(invalidParts.join(" "));
+            }
+            cursor = start + match[0].length;
+        }
+        pieces.push(line.slice(cursor));
+        const cleanedLine = pieces
+            .join("")
+            .replace(/[ \t]{2,}/g, " ")
+            .trim();
+        // If the line becomes empty, drop it.
+        if (cleanedLine) {
+            keptLines.push(cleanedLine);
+        }
+    }
+    const cleanedText = keptLines
+        .join("\n")
+        .replace(/[ \t]+\n/g, "\n")
+        .replace(/[ \t]{2,}/g, " ")
+        .replace(/\n{2,}/g, "\n")
+        .trim();
+    if (media.length === 0) {
+        return { text: foundMediaToken ? cleanedText : trimmedRaw };
+    }
+    return { text: cleanedText, mediaUrls: media, mediaUrl: media[0] };
+}

package/dist/media/server.js

@@ -0,0 +1,64 @@
+import fs from "node:fs/promises";
+import path from "node:path";
+import express from "express";
+import { danger } from "../globals.js";
+import { defaultRuntime } from "../runtime.js";
+import { detectMime } from "./mime.js";
+import { cleanOldMedia, getMediaDir } from "./store.js";
+const DEFAULT_TTL_MS = 2 * 60 * 1000;
+export function attachMediaRoutes(app, ttlMs = DEFAULT_TTL_MS, _runtime = defaultRuntime) {
+    const mediaDir = getMediaDir();
+    app.get("/media/:id", async (req, res) => {
+        const id = req.params.id;
+        const mediaRoot = (await fs.realpath(mediaDir)) + path.sep;
+        const file = path.resolve(mediaRoot, id);
+        try {
+            const lstat = await fs.lstat(file);
+            if (lstat.isSymbolicLink()) {
+                res.status(400).send("invalid path");
+                return;
+            }
+            const realPath = await fs.realpath(file);
+            if (!realPath.startsWith(mediaRoot)) {
+                res.status(400).send("invalid path");
+                return;
+            }
+            const stat = await fs.stat(realPath);
+            if (Date.now() - stat.mtimeMs > ttlMs) {
+                await fs.rm(realPath).catch(() => { });
+                res.status(410).send("expired");
+                return;
+            }
+            const data = await fs.readFile(realPath);
+            const mime = await detectMime({ buffer: data, filePath: realPath });
+            if (mime)
+                res.type(mime);
+            res.send(data);
+            // best-effort single-use cleanup after response ends
+            res.on("finish", () => {
+                setTimeout(() => {
+                    fs.rm(realPath).catch(() => { });
+                }, 50);
+            });
+        }
+        catch {
+            res.status(404).send("not found");
+        }
+    });
+    // periodic cleanup
+    setInterval(() => {
+        void cleanOldMedia(ttlMs);
+    }, ttlMs).unref();
+}
+export async function startMediaServer(port, ttlMs = DEFAULT_TTL_MS, runtime = defaultRuntime) {
+    const app = express();
+    attachMediaRoutes(app, ttlMs, runtime);
+    return await new Promise((resolve, reject) => {
+        const server = app.listen(port);
+        server.once("listening", () => resolve(server));
+        server.once("error", (err) => {
+            runtime.error(danger(`Media server failed: ${String(err)}`));
+            reject(err);
+        });
+    });
+}

package/dist/media/store.js

@@ -0,0 +1,139 @@
+import crypto from "node:crypto";
+import { createWriteStream } from "node:fs";
+import fs from "node:fs/promises";
+import { request } from "node:https";
+import path from "node:path";
+import { pipeline } from "node:stream/promises";
+import { CONFIG_DIR } from "../utils.js";
+import { detectMime, extensionForMime } from "./mime.js";
+const MEDIA_DIR = path.join(CONFIG_DIR, "media");
+const MAX_BYTES = 5 * 1024 * 1024; // 5MB default
+const DEFAULT_TTL_MS = 2 * 60 * 1000; // 2 minutes
+export function getMediaDir() {
+    return MEDIA_DIR;
+}
+export async function ensureMediaDir() {
+    await fs.mkdir(MEDIA_DIR, { recursive: true });
+    return MEDIA_DIR;
+}
+export async function cleanOldMedia(ttlMs = DEFAULT_TTL_MS) {
+    await ensureMediaDir();
+    const entries = await fs.readdir(MEDIA_DIR).catch(() => []);
+    const now = Date.now();
+    await Promise.all(entries.map(async (file) => {
+        const full = path.join(MEDIA_DIR, file);
+        const stat = await fs.stat(full).catch(() => null);
+        if (!stat)
+            return;
+        if (now - stat.mtimeMs > ttlMs) {
+            await fs.rm(full).catch(() => { });
+        }
+    }));
+}
+function looksLikeUrl(src) {
+    return /^https?:\/\//i.test(src);
+}
+/**
+ * Download media to disk while capturing the first few KB for mime sniffing.
+ */
+async function downloadToFile(url, dest, headers, maxRedirects = 5) {
+    return await new Promise((resolve, reject) => {
+        const req = request(url, { headers }, (res) => {
+            // Follow redirects
+            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, headers, maxRedirects - 1));
+                return;
+            }
+            if (!res.statusCode || res.statusCode >= 400) {
+                reject(new Error(`HTTP ${res.statusCode ?? "?"} downloading media`));
+                return;
+            }
+            let total = 0;
+            const sniffChunks = [];
+            let sniffLen = 0;
+            const out = createWriteStream(dest);
+            res.on("data", (chunk) => {
+                total += chunk.length;
+                if (sniffLen < 16384) {
+                    sniffChunks.push(chunk);
+                    sniffLen += chunk.length;
+                }
+                if (total > MAX_BYTES) {
+                    req.destroy(new Error("Media exceeds 5MB limit"));
+                }
+            });
+            pipeline(res, out)
+                .then(() => {
+                const sniffBuffer = Buffer.concat(sniffChunks, Math.min(sniffLen, 16384));
+                const rawHeader = res.headers["content-type"];
+                const headerMime = Array.isArray(rawHeader)
+                    ? rawHeader[0]
+                    : rawHeader;
+                resolve({
+                    headerMime,
+                    sniffBuffer,
+                    size: total,
+                });
+            })
+                .catch(reject);
+        });
+        req.on("error", reject);
+        req.end();
+    });
+}
+export async function saveMediaSource(source, headers, subdir = "") {
+    const dir = subdir ? path.join(MEDIA_DIR, subdir) : MEDIA_DIR;
+    await fs.mkdir(dir, { recursive: true });
+    await cleanOldMedia();
+    const baseId = crypto.randomUUID();
+    if (looksLikeUrl(source)) {
+        const tempDest = path.join(dir, `${baseId}.tmp`);
+        const { headerMime, sniffBuffer, size } = await downloadToFile(source, tempDest, headers);
+        const mime = await detectMime({
+            buffer: sniffBuffer,
+            headerMime,
+            filePath: source,
+        });
+        const ext = extensionForMime(mime) ?? path.extname(new URL(source).pathname);
+        const id = ext ? `${baseId}${ext}` : baseId;
+        const finalDest = path.join(dir, id);
+        await fs.rename(tempDest, finalDest);
+        return { id, path: finalDest, size, contentType: mime };
+    }
+    // local path
+    const stat = await fs.stat(source);
+    if (!stat.isFile()) {
+        throw new Error("Media path is not a file");
+    }
+    if (stat.size > MAX_BYTES) {
+        throw new Error("Media exceeds 5MB limit");
+    }
+    const buffer = await fs.readFile(source);
+    const mime = await detectMime({ buffer, filePath: source });
+    const ext = extensionForMime(mime) ?? path.extname(source);
+    const id = ext ? `${baseId}${ext}` : baseId;
+    const dest = path.join(dir, id);
+    await fs.writeFile(dest, buffer);
+    return { id, path: dest, size: stat.size, contentType: mime };
+}
+export async function saveMediaBuffer(buffer, contentType, subdir = "inbound", maxBytes = MAX_BYTES) {
+    if (buffer.byteLength > maxBytes) {
+        throw new Error(`Media exceeds ${(maxBytes / (1024 * 1024)).toFixed(0)}MB limit`);
+    }
+    const dir = path.join(MEDIA_DIR, subdir);
+    await fs.mkdir(dir, { recursive: true });
+    const baseId = crypto.randomUUID();
+    const headerExt = extensionForMime(contentType?.split(";")[0]?.trim() ?? undefined);
+    const mime = await detectMime({ buffer, headerMime: contentType });
+    const ext = headerExt ?? extensionForMime(mime);
+    const id = ext ? `${baseId}${ext}` : baseId;
+    const dest = path.join(dir, id);
+    await fs.writeFile(dest, buffer);
+    return { id, path: dest, size: buffer.byteLength, contentType: mime };
+}

package/dist/process/command-queue.js

@@ -0,0 +1,97 @@
+// Minimal in-process queue to serialize command executions.
+// Default lane ("main") preserves the existing behavior. Additional lanes allow
+// low-risk parallelism (e.g. cron jobs) without interleaving stdin / logs for
+// the main auto-reply workflow.
+const lanes = new Map();
+function getLaneState(lane) {
+    const existing = lanes.get(lane);
+    if (existing)
+        return existing;
+    const created = {
+        lane,
+        queue: [],
+        active: 0,
+        maxConcurrent: 1,
+        draining: false,
+    };
+    lanes.set(lane, created);
+    return created;
+}
+function drainLane(lane) {
+    const state = getLaneState(lane);
+    if (state.draining)
+        return;
+    state.draining = true;
+    const pump = () => {
+        while (state.active < state.maxConcurrent && state.queue.length > 0) {
+            const entry = state.queue.shift();
+            const waitedMs = Date.now() - entry.enqueuedAt;
+            if (waitedMs >= entry.warnAfterMs) {
+                entry.onWait?.(waitedMs, state.queue.length);
+            }
+            state.active += 1;
+            void (async () => {
+                try {
+                    const result = await entry.task();
+                    state.active -= 1;
+                    pump();
+                    entry.resolve(result);
+                }
+                catch (err) {
+                    state.active -= 1;
+                    pump();
+                    entry.reject(err);
+                }
+            })();
+        }
+        state.draining = false;
+    };
+    pump();
+}
+export function setCommandLaneConcurrency(lane, maxConcurrent) {
+    const cleaned = lane.trim() || "main";
+    const state = getLaneState(cleaned);
+    state.maxConcurrent = Math.max(1, Math.floor(maxConcurrent));
+    drainLane(cleaned);
+}
+export function enqueueCommandInLane(lane, task, opts) {
+    const cleaned = lane.trim() || "main";
+    const warnAfterMs = opts?.warnAfterMs ?? 2_000;
+    const state = getLaneState(cleaned);
+    return new Promise((resolve, reject) => {
+        state.queue.push({
+            task: () => task(),
+            resolve: (value) => resolve(value),
+            reject,
+            enqueuedAt: Date.now(),
+            warnAfterMs,
+            onWait: opts?.onWait,
+        });
+        drainLane(cleaned);
+    });
+}
+export function enqueueCommand(task, opts) {
+    return enqueueCommandInLane("main", task, opts);
+}
+export function getQueueSize(lane = "main") {
+    const state = lanes.get(lane);
+    if (!state)
+        return 0;
+    return state.queue.length + state.active;
+}
+export function getTotalQueueSize() {
+    let total = 0;
+    for (const s of lanes.values()) {
+        total += s.queue.length + s.active;
+    }
+    return total;
+}
+export function clearCommandLane(lane = "main") {
+    const cleaned = lane.trim() || "main";
+    const state = lanes.get(cleaned);
+    if (!state)
+        return 0;
+    const removed = state.queue.length;
+    state.queue.length = 0;
+    return removed;
+}