clawdbot 2026.1.4-1

package/dist/imessage/send.js

@@ -0,0 +1,83 @@
+import { loadConfig } from "../config/config.js";
+import { mediaKindFromMime } from "../media/constants.js";
+import { saveMediaBuffer } from "../media/store.js";
+import { loadWebMedia } from "../web/media.js";
+import { createIMessageRpcClient } from "./client.js";
+import { formatIMessageChatTarget, parseIMessageTarget, } from "./targets.js";
+function resolveCliPath(explicit) {
+    const cfg = loadConfig();
+    return explicit?.trim() || cfg.imessage?.cliPath?.trim() || "imsg";
+}
+function resolveDbPath(explicit) {
+    const cfg = loadConfig();
+    return explicit?.trim() || cfg.imessage?.dbPath?.trim() || undefined;
+}
+function resolveService(explicit) {
+    const cfg = loadConfig();
+    return (explicit || cfg.imessage?.service || "auto");
+}
+function resolveRegion(explicit) {
+    const cfg = loadConfig();
+    return explicit?.trim() || cfg.imessage?.region?.trim() || "US";
+}
+async function resolveAttachment(mediaUrl, maxBytes) {
+    const media = await loadWebMedia(mediaUrl, maxBytes);
+    const saved = await saveMediaBuffer(media.buffer, media.contentType ?? undefined, "outbound", maxBytes);
+    return { path: saved.path, contentType: saved.contentType };
+}
+export async function sendMessageIMessage(to, text, opts = {}) {
+    const cliPath = resolveCliPath(opts.cliPath);
+    const dbPath = resolveDbPath(opts.dbPath);
+    const target = parseIMessageTarget(opts.chatId ? formatIMessageChatTarget(opts.chatId) : to);
+    const service = opts.service ?? (target.kind === "handle" ? target.service : undefined);
+    const region = resolveRegion(opts.region);
+    const maxBytes = opts.maxBytes ?? 16 * 1024 * 1024;
+    let message = text ?? "";
+    let filePath;
+    if (opts.mediaUrl?.trim()) {
+        const resolved = await resolveAttachment(opts.mediaUrl.trim(), maxBytes);
+        filePath = resolved.path;
+        if (!message.trim()) {
+            const kind = mediaKindFromMime(resolved.contentType ?? undefined);
+            if (kind)
+                message = kind === "image" ? "<media:image>" : `<media:${kind}>`;
+        }
+    }
+    if (!message.trim() && !filePath) {
+        throw new Error("iMessage send requires text or media");
+    }
+    const params = {
+        text: message,
+        service: resolveService(service),
+        region,
+    };
+    if (filePath)
+        params.file = filePath;
+    if (target.kind === "chat_id") {
+        params.chat_id = target.chatId;
+    }
+    else if (target.kind === "chat_guid") {
+        params.chat_guid = target.chatGuid;
+    }
+    else if (target.kind === "chat_identifier") {
+        params.chat_identifier = target.chatIdentifier;
+    }
+    else {
+        params.to = target.to;
+    }
+    const client = opts.client ?? (await createIMessageRpcClient({ cliPath, dbPath }));
+    const shouldClose = !opts.client;
+    try {
+        const result = await client.request("send", params, {
+            timeoutMs: opts.timeoutMs,
+        });
+        return {
+            messageId: result?.ok ? "ok" : "unknown",
+        };
+    }
+    finally {
+        if (shouldClose) {
+            await client.stop();
+        }
+    }
+}

package/dist/imessage/targets.js

@@ -0,0 +1,176 @@
+import { normalizeE164 } from "../utils.js";
+const CHAT_ID_PREFIXES = ["chat_id:", "chatid:", "chat:"];
+const CHAT_GUID_PREFIXES = ["chat_guid:", "chatguid:", "guid:"];
+const CHAT_IDENTIFIER_PREFIXES = [
+    "chat_identifier:",
+    "chatidentifier:",
+    "chatident:",
+];
+const SERVICE_PREFIXES = [
+    { prefix: "imessage:", service: "imessage" },
+    { prefix: "sms:", service: "sms" },
+    { prefix: "auto:", service: "auto" },
+];
+function stripPrefix(value, prefix) {
+    return value.slice(prefix.length).trim();
+}
+export function normalizeIMessageHandle(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return "";
+    const lowered = trimmed.toLowerCase();
+    if (lowered.startsWith("imessage:"))
+        return normalizeIMessageHandle(trimmed.slice(9));
+    if (lowered.startsWith("sms:"))
+        return normalizeIMessageHandle(trimmed.slice(4));
+    if (lowered.startsWith("auto:"))
+        return normalizeIMessageHandle(trimmed.slice(5));
+    if (trimmed.includes("@"))
+        return trimmed.toLowerCase();
+    const normalized = normalizeE164(trimmed);
+    if (normalized)
+        return normalized;
+    return trimmed.replace(/\s+/g, "");
+}
+export function parseIMessageTarget(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        throw new Error("iMessage target is required");
+    const lower = trimmed.toLowerCase();
+    for (const { prefix, service } of SERVICE_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const remainder = stripPrefix(trimmed, prefix);
+            if (!remainder)
+                throw new Error(`${prefix} target is required`);
+            const remainderLower = remainder.toLowerCase();
+            const isChatTarget = CHAT_ID_PREFIXES.some((p) => remainderLower.startsWith(p)) ||
+                CHAT_GUID_PREFIXES.some((p) => remainderLower.startsWith(p)) ||
+                CHAT_IDENTIFIER_PREFIXES.some((p) => remainderLower.startsWith(p)) ||
+                remainderLower.startsWith("group:");
+            if (isChatTarget) {
+                return parseIMessageTarget(remainder);
+            }
+            return { kind: "handle", to: remainder, service };
+        }
+    }
+    for (const prefix of CHAT_ID_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const value = stripPrefix(trimmed, prefix);
+            const chatId = Number.parseInt(value, 10);
+            if (!Number.isFinite(chatId)) {
+                throw new Error(`Invalid chat_id: ${value}`);
+            }
+            return { kind: "chat_id", chatId };
+        }
+    }
+    for (const prefix of CHAT_GUID_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const value = stripPrefix(trimmed, prefix);
+            if (!value)
+                throw new Error("chat_guid is required");
+            return { kind: "chat_guid", chatGuid: value };
+        }
+    }
+    for (const prefix of CHAT_IDENTIFIER_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const value = stripPrefix(trimmed, prefix);
+            if (!value)
+                throw new Error("chat_identifier is required");
+            return { kind: "chat_identifier", chatIdentifier: value };
+        }
+    }
+    if (lower.startsWith("group:")) {
+        const value = stripPrefix(trimmed, "group:");
+        const chatId = Number.parseInt(value, 10);
+        if (Number.isFinite(chatId)) {
+            return { kind: "chat_id", chatId };
+        }
+        if (!value)
+            throw new Error("group target is required");
+        return { kind: "chat_guid", chatGuid: value };
+    }
+    return { kind: "handle", to: trimmed, service: "auto" };
+}
+export function parseIMessageAllowTarget(raw) {
+    const trimmed = raw.trim();
+    if (!trimmed)
+        return { kind: "handle", handle: "" };
+    const lower = trimmed.toLowerCase();
+    for (const { prefix } of SERVICE_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const remainder = stripPrefix(trimmed, prefix);
+            if (!remainder)
+                return { kind: "handle", handle: "" };
+            return parseIMessageAllowTarget(remainder);
+        }
+    }
+    for (const prefix of CHAT_ID_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const value = stripPrefix(trimmed, prefix);
+            const chatId = Number.parseInt(value, 10);
+            if (Number.isFinite(chatId))
+                return { kind: "chat_id", chatId };
+        }
+    }
+    for (const prefix of CHAT_GUID_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const value = stripPrefix(trimmed, prefix);
+            if (value)
+                return { kind: "chat_guid", chatGuid: value };
+        }
+    }
+    for (const prefix of CHAT_IDENTIFIER_PREFIXES) {
+        if (lower.startsWith(prefix)) {
+            const value = stripPrefix(trimmed, prefix);
+            if (value)
+                return { kind: "chat_identifier", chatIdentifier: value };
+        }
+    }
+    if (lower.startsWith("group:")) {
+        const value = stripPrefix(trimmed, "group:");
+        const chatId = Number.parseInt(value, 10);
+        if (Number.isFinite(chatId))
+            return { kind: "chat_id", chatId };
+        if (value)
+            return { kind: "chat_guid", chatGuid: value };
+    }
+    return { kind: "handle", handle: normalizeIMessageHandle(trimmed) };
+}
+export function isAllowedIMessageSender(params) {
+    const allowFrom = params.allowFrom.map((entry) => String(entry).trim());
+    if (allowFrom.length === 0)
+        return true;
+    if (allowFrom.includes("*"))
+        return true;
+    const senderNormalized = normalizeIMessageHandle(params.sender);
+    const chatId = params.chatId ?? undefined;
+    const chatGuid = params.chatGuid?.trim();
+    const chatIdentifier = params.chatIdentifier?.trim();
+    for (const entry of allowFrom) {
+        if (!entry)
+            continue;
+        const parsed = parseIMessageAllowTarget(entry);
+        if (parsed.kind === "chat_id" && chatId !== undefined) {
+            if (parsed.chatId === chatId)
+                return true;
+        }
+        else if (parsed.kind === "chat_guid" && chatGuid) {
+            if (parsed.chatGuid === chatGuid)
+                return true;
+        }
+        else if (parsed.kind === "chat_identifier" && chatIdentifier) {
+            if (parsed.chatIdentifier === chatIdentifier)
+                return true;
+        }
+        else if (parsed.kind === "handle" && senderNormalized) {
+            if (parsed.handle === senderNormalized)
+                return true;
+        }
+    }
+    return false;
+}
+export function formatIMessageChatTarget(chatId) {
+    if (!chatId || !Number.isFinite(chatId))
+        return "";
+    return `chat_id:${chatId}`;
+}

package/dist/index.js

@@ -0,0 +1,50 @@
+#!/usr/bin/env node
+import process from "node:process";
+import { fileURLToPath } from "node:url";
+import dotenv from "dotenv";
+import { getReplyFromConfig } from "./auto-reply/reply.js";
+import { applyTemplate } from "./auto-reply/templating.js";
+import { createDefaultDeps } from "./cli/deps.js";
+import { promptYesNo } from "./cli/prompt.js";
+import { waitForever } from "./cli/wait.js";
+import { loadConfig } from "./config/config.js";
+import { deriveSessionKey, loadSessionStore, resolveSessionKey, resolveStorePath, saveSessionStore, } from "./config/sessions.js";
+import { ensureBinary } from "./infra/binaries.js";
+import { normalizeEnv } from "./infra/env.js";
+import { isMainModule } from "./infra/is-main.js";
+import { ensureClawdbotCliOnPath } from "./infra/path-env.js";
+import { describePortOwner, ensurePortAvailable, handlePortError, PortInUseError, } from "./infra/ports.js";
+import { assertSupportedRuntime } from "./infra/runtime-guard.js";
+import { enableConsoleCapture } from "./logging.js";
+import { runCommandWithTimeout, runExec } from "./process/exec.js";
+import { monitorWebProvider } from "./provider-web.js";
+import { assertProvider, normalizeE164, toWhatsappJid } from "./utils.js";
+dotenv.config({ quiet: true });
+normalizeEnv();
+ensureClawdbotCliOnPath();
+// Capture all console output into structured logs while keeping stdout/stderr behavior.
+enableConsoleCapture();
+// Enforce the minimum supported runtime before doing any work.
+assertSupportedRuntime();
+import { buildProgram } from "./cli/program.js";
+const program = buildProgram();
+export { assertProvider, applyTemplate, createDefaultDeps, deriveSessionKey, describePortOwner, ensureBinary, ensurePortAvailable, getReplyFromConfig, handlePortError, loadConfig, loadSessionStore, monitorWebProvider, normalizeE164, PortInUseError, promptYesNo, resolveSessionKey, resolveStorePath, runCommandWithTimeout, runExec, saveSessionStore, toWhatsappJid, waitForever, };
+const isMain = isMainModule({
+    currentFile: fileURLToPath(import.meta.url),
+});
+if (isMain) {
+    // Global error handlers to prevent silent crashes from unhandled rejections/exceptions.
+    // These log the error and exit gracefully instead of crashing without trace.
+    process.on("unhandledRejection", (reason, _promise) => {
+        console.error("[clawdbot] Unhandled promise rejection:", reason instanceof Error ? (reason.stack ?? reason.message) : reason);
+        process.exit(1);
+    });
+    process.on("uncaughtException", (error) => {
+        console.error("[clawdbot] Uncaught exception:", error.stack ?? error.message);
+        process.exit(1);
+    });
+    void program.parseAsync(process.argv).catch((err) => {
+        console.error("[clawdbot] CLI failed:", err instanceof Error ? (err.stack ?? err.message) : err);
+        process.exit(1);
+    });
+}

package/dist/infra/agent-events.js

@@ -0,0 +1,46 @@
+// Keep per-run counters so streams stay strictly monotonic per runId.
+const seqByRun = new Map();
+const listeners = new Set();
+const runContextById = new Map();
+export function registerAgentRunContext(runId, context) {
+    if (!runId)
+        return;
+    const existing = runContextById.get(runId);
+    if (!existing) {
+        runContextById.set(runId, { ...context });
+        return;
+    }
+    if (context.sessionKey && existing.sessionKey !== context.sessionKey) {
+        existing.sessionKey = context.sessionKey;
+    }
+}
+export function getAgentRunContext(runId) {
+    return runContextById.get(runId);
+}
+export function clearAgentRunContext(runId) {
+    runContextById.delete(runId);
+}
+export function resetAgentRunContextForTest() {
+    runContextById.clear();
+}
+export function emitAgentEvent(event) {
+    const nextSeq = (seqByRun.get(event.runId) ?? 0) + 1;
+    seqByRun.set(event.runId, nextSeq);
+    const enriched = {
+        ...event,
+        seq: nextSeq,
+        ts: Date.now(),
+    };
+    for (const listener of listeners) {
+        try {
+            listener(enriched);
+        }
+        catch {
+            /* ignore */
+        }
+    }
+}
+export function onAgentEvent(listener) {
+    listeners.add(listener);
+    return () => listeners.delete(listener);
+}

package/dist/infra/binaries.js

@@ -0,0 +1,9 @@
+import { runExec } from "../process/exec.js";
+import { defaultRuntime } from "../runtime.js";
+export async function ensureBinary(name, exec = runExec, runtime = defaultRuntime) {
+    // Abort early if a required CLI tool is missing.
+    await exec("which", [name]).catch(() => {
+        runtime.error(`Missing required binary: ${name}. Please install it.`);
+        runtime.exit(1);
+    });
+}

package/dist/infra/bonjour-discovery.js

@@ -0,0 +1,163 @@
+import { runCommandWithTimeout } from "../process/exec.js";
+const DEFAULT_TIMEOUT_MS = 2000;
+function parseIntOrNull(value) {
+    if (!value)
+        return undefined;
+    const parsed = Number.parseInt(value, 10);
+    return Number.isFinite(parsed) ? parsed : undefined;
+}
+function parseTxtTokens(tokens) {
+    const txt = {};
+    for (const token of tokens) {
+        const idx = token.indexOf("=");
+        if (idx <= 0)
+            continue;
+        const key = token.slice(0, idx).trim();
+        const value = token.slice(idx + 1).trim();
+        if (!key)
+            continue;
+        txt[key] = value;
+    }
+    return txt;
+}
+function parseDnsSdBrowse(stdout) {
+    const instances = new Set();
+    for (const raw of stdout.split("\n")) {
+        const line = raw.trim();
+        if (!line || !line.includes("_clawdbot-bridge._tcp"))
+            continue;
+        if (!line.includes("Add"))
+            continue;
+        const match = line.match(/_clawdbot-bridge\._tcp\.?\s+(.+)$/);
+        if (match?.[1]) {
+            instances.add(match[1].trim());
+        }
+    }
+    return Array.from(instances.values());
+}
+function parseDnsSdResolve(stdout, instanceName) {
+    const beacon = { instanceName };
+    let txt = {};
+    for (const raw of stdout.split("\n")) {
+        const line = raw.trim();
+        if (!line)
+            continue;
+        if (line.includes("can be reached at")) {
+            const match = line.match(/can be reached at\s+([^\s:]+):(\d+)/i);
+            if (match?.[1]) {
+                beacon.host = match[1].replace(/\.$/, "");
+            }
+            if (match?.[2]) {
+                beacon.port = parseIntOrNull(match[2]);
+            }
+            continue;
+        }
+        if (line.startsWith("txt") || line.includes("txtvers=")) {
+            const tokens = line.split(/\s+/).filter(Boolean);
+            txt = parseTxtTokens(tokens);
+        }
+    }
+    beacon.txt = Object.keys(txt).length ? txt : undefined;
+    if (txt.displayName)
+        beacon.displayName = txt.displayName;
+    if (txt.lanHost)
+        beacon.lanHost = txt.lanHost;
+    if (txt.tailnetDns)
+        beacon.tailnetDns = txt.tailnetDns;
+    if (txt.cliPath)
+        beacon.cliPath = txt.cliPath;
+    beacon.bridgePort = parseIntOrNull(txt.bridgePort);
+    beacon.gatewayPort = parseIntOrNull(txt.gatewayPort);
+    beacon.sshPort = parseIntOrNull(txt.sshPort);
+    if (!beacon.displayName)
+        beacon.displayName = instanceName;
+    return beacon;
+}
+async function discoverViaDnsSd(timeoutMs) {
+    const browse = await runCommandWithTimeout(["dns-sd", "-B", "_clawdbot-bridge._tcp", "local."], { timeoutMs });
+    const instances = parseDnsSdBrowse(browse.stdout);
+    const results = [];
+    for (const instance of instances) {
+        const resolved = await runCommandWithTimeout(["dns-sd", "-L", instance, "_clawdbot-bridge._tcp", "local."], { timeoutMs });
+        const parsed = parseDnsSdResolve(resolved.stdout, instance);
+        if (parsed)
+            results.push(parsed);
+    }
+    return results;
+}
+function parseAvahiBrowse(stdout) {
+    const results = [];
+    let current = null;
+    for (const raw of stdout.split("\n")) {
+        const line = raw.trimEnd();
+        if (!line)
+            continue;
+        if (line.startsWith("=") && line.includes("_clawdbot-bridge._tcp")) {
+            if (current)
+                results.push(current);
+            const marker = " _clawdbot-bridge._tcp";
+            const idx = line.indexOf(marker);
+            const left = idx >= 0 ? line.slice(0, idx).trim() : line;
+            const parts = left.split(/\s+/);
+            const instanceName = parts.length > 3 ? parts.slice(3).join(" ") : left;
+            current = {
+                instanceName,
+                displayName: instanceName,
+            };
+            continue;
+        }
+        if (!current)
+            continue;
+        const trimmed = line.trim();
+        if (trimmed.startsWith("hostname =")) {
+            const match = trimmed.match(/hostname\s*=\s*\[([^\]]+)\]/);
+            if (match?.[1])
+                current.host = match[1];
+            continue;
+        }
+        if (trimmed.startsWith("port =")) {
+            const match = trimmed.match(/port\s*=\s*\[(\d+)\]/);
+            if (match?.[1])
+                current.port = parseIntOrNull(match[1]);
+            continue;
+        }
+        if (trimmed.startsWith("txt =")) {
+            const tokens = Array.from(trimmed.matchAll(/"([^"]*)"/g), (m) => m[1]);
+            const txt = parseTxtTokens(tokens);
+            current.txt = Object.keys(txt).length ? txt : undefined;
+            if (txt.displayName)
+                current.displayName = txt.displayName;
+            if (txt.lanHost)
+                current.lanHost = txt.lanHost;
+            if (txt.tailnetDns)
+                current.tailnetDns = txt.tailnetDns;
+            if (txt.cliPath)
+                current.cliPath = txt.cliPath;
+            current.bridgePort = parseIntOrNull(txt.bridgePort);
+            current.gatewayPort = parseIntOrNull(txt.gatewayPort);
+            current.sshPort = parseIntOrNull(txt.sshPort);
+        }
+    }
+    if (current)
+        results.push(current);
+    return results;
+}
+async function discoverViaAvahi(timeoutMs) {
+    const browse = await runCommandWithTimeout(["avahi-browse", "-rt", "_clawdbot-bridge._tcp"], { timeoutMs });
+    return parseAvahiBrowse(browse.stdout);
+}
+export async function discoverGatewayBeacons(opts = {}) {
+    const timeoutMs = opts.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    try {
+        if (process.platform === "darwin") {
+            return await discoverViaDnsSd(timeoutMs);
+        }
+        if (process.platform === "linux") {
+            return await discoverViaAvahi(timeoutMs);
+        }
+    }
+    catch {
+        return [];
+    }
+    return [];
+}