clawdbot 2026.1.4-1

package/dist/web/session.js

@@ -0,0 +1,346 @@
+import { randomUUID } from "node:crypto";
+import fsSync from "node:fs";
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { DisconnectReason, fetchLatestBaileysVersion, makeCacheableSignalKeyStore, makeWASocket, useMultiFileAuthState, } from "@whiskeysockets/baileys";
+import qrcode from "qrcode-terminal";
+import { resolveDefaultSessionStorePath } from "../config/sessions.js";
+import { danger, info, success } from "../globals.js";
+import { getChildLogger, toPinoLikeLogger } from "../logging.js";
+import { defaultRuntime } from "../runtime.js";
+import { CONFIG_DIR, ensureDir, jidToE164 } from "../utils.js";
+import { VERSION } from "../version.js";
+export function resolveWebAuthDir() {
+    return path.join(os.homedir(), ".clawdbot", "credentials");
+}
+function resolveWebCredsPath() {
+    return path.join(resolveWebAuthDir(), "creds.json");
+}
+function resolveWebCredsBackupPath() {
+    return path.join(resolveWebAuthDir(), "creds.json.bak");
+}
+export const WA_WEB_AUTH_DIR = path.join(CONFIG_DIR, "credentials");
+let credsSaveQueue = Promise.resolve();
+function enqueueSaveCreds(saveCreds, logger) {
+    credsSaveQueue = credsSaveQueue
+        .then(() => safeSaveCreds(saveCreds, logger))
+        .catch((err) => {
+        logger.warn({ error: String(err) }, "WhatsApp creds save queue error");
+    });
+}
+function readCredsJsonRaw(filePath) {
+    try {
+        if (!fsSync.existsSync(filePath))
+            return null;
+        const stats = fsSync.statSync(filePath);
+        if (!stats.isFile() || stats.size <= 1)
+            return null;
+        return fsSync.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function maybeRestoreCredsFromBackup(logger) {
+    try {
+        const credsPath = resolveWebCredsPath();
+        const backupPath = resolveWebCredsBackupPath();
+        const raw = readCredsJsonRaw(credsPath);
+        if (raw) {
+            // Validate that creds.json is parseable.
+            JSON.parse(raw);
+            return;
+        }
+        const backupRaw = readCredsJsonRaw(backupPath);
+        if (!backupRaw)
+            return;
+        // Ensure backup is parseable before restoring.
+        JSON.parse(backupRaw);
+        fsSync.copyFileSync(backupPath, credsPath);
+        logger.warn({ credsPath }, "restored corrupted WhatsApp creds.json from backup");
+    }
+    catch {
+        // ignore
+    }
+}
+async function safeSaveCreds(saveCreds, logger) {
+    try {
+        // Best-effort backup so we can recover after abrupt restarts.
+        // Important: don't clobber a good backup with a corrupted/truncated creds.json.
+        const credsPath = resolveWebCredsPath();
+        const backupPath = resolveWebCredsBackupPath();
+        const raw = readCredsJsonRaw(credsPath);
+        if (raw) {
+            try {
+                JSON.parse(raw);
+                fsSync.copyFileSync(credsPath, backupPath);
+            }
+            catch {
+                // keep existing backup
+            }
+        }
+    }
+    catch {
+        // ignore backup failures
+    }
+    try {
+        await Promise.resolve(saveCreds());
+    }
+    catch (err) {
+        logger.warn({ error: String(err) }, "failed saving WhatsApp creds");
+    }
+}
+/**
+ * Create a Baileys socket backed by the multi-file auth store we keep on disk.
+ * Consumers can opt into QR printing for interactive login flows.
+ */
+export async function createWaSocket(printQr, verbose, opts = {}) {
+    const baseLogger = getChildLogger({ module: "baileys" }, {
+        level: verbose ? "info" : "silent",
+    });
+    const logger = toPinoLikeLogger(baseLogger, verbose ? "info" : "silent");
+    const authDir = resolveWebAuthDir();
+    await ensureDir(authDir);
+    const sessionLogger = getChildLogger({ module: "web-session" });
+    maybeRestoreCredsFromBackup(sessionLogger);
+    const { state, saveCreds } = await useMultiFileAuthState(authDir);
+    const { version } = await fetchLatestBaileysVersion();
+    const sock = makeWASocket({
+        auth: {
+            creds: state.creds,
+            keys: makeCacheableSignalKeyStore(state.keys, logger),
+        },
+        version,
+        logger,
+        printQRInTerminal: false,
+        browser: ["clawdbot", "cli", VERSION],
+        syncFullHistory: false,
+        markOnlineOnConnect: false,
+    });
+    sock.ev.on("creds.update", () => enqueueSaveCreds(saveCreds, sessionLogger));
+    sock.ev.on("connection.update", (update) => {
+        try {
+            const { connection, lastDisconnect, qr } = update;
+            if (qr) {
+                opts.onQr?.(qr);
+                if (printQr) {
+                    console.log("Scan this QR in WhatsApp (Linked Devices):");
+                    qrcode.generate(qr, { small: true });
+                }
+            }
+            if (connection === "close") {
+                const status = getStatusCode(lastDisconnect?.error);
+                if (status === DisconnectReason.loggedOut) {
+                    console.error(danger("WhatsApp session logged out. Run: clawdbot login"));
+                }
+            }
+            if (connection === "open" && verbose) {
+                console.log(success("WhatsApp Web connected."));
+            }
+        }
+        catch (err) {
+            sessionLogger.error({ error: String(err) }, "connection.update handler error");
+        }
+    });
+    // Handle WebSocket-level errors to prevent unhandled exceptions from crashing the process
+    if (sock.ws &&
+        typeof sock.ws.on === "function") {
+        sock.ws.on("error", (err) => {
+            sessionLogger.error({ error: String(err) }, "WebSocket error");
+        });
+    }
+    return sock;
+}
+export async function waitForWaConnection(sock) {
+    return new Promise((resolve, reject) => {
+        const evWithOff = sock.ev;
+        const handler = (...args) => {
+            const update = (args[0] ?? {});
+            if (update.connection === "open") {
+                evWithOff.off?.("connection.update", handler);
+                resolve();
+            }
+            if (update.connection === "close") {
+                evWithOff.off?.("connection.update", handler);
+                reject(update.lastDisconnect ?? new Error("Connection closed"));
+            }
+        };
+        sock.ev.on("connection.update", handler);
+    });
+}
+export function getStatusCode(err) {
+    return (err?.output?.statusCode ??
+        err?.status);
+}
+function safeStringify(value, limit = 800) {
+    try {
+        const seen = new WeakSet();
+        const raw = JSON.stringify(value, (_key, v) => {
+            if (typeof v === "bigint")
+                return v.toString();
+            if (typeof v === "function") {
+                const maybeName = v.name;
+                const name = typeof maybeName === "string" && maybeName.length > 0
+                    ? maybeName
+                    : "anonymous";
+                return `[Function ${name}]`;
+            }
+            if (typeof v === "object" && v) {
+                if (seen.has(v))
+                    return "[Circular]";
+                seen.add(v);
+            }
+            return v;
+        }, 2);
+        if (!raw)
+            return String(value);
+        return raw.length > limit ? `${raw.slice(0, limit)}…` : raw;
+    }
+    catch {
+        return String(value);
+    }
+}
+function extractBoomDetails(err) {
+    if (!err || typeof err !== "object")
+        return null;
+    const output = err?.output;
+    if (!output || typeof output !== "object")
+        return null;
+    const payload = output.payload;
+    const statusCode = typeof output.statusCode === "number"
+        ? output.statusCode
+        : typeof payload?.statusCode === "number"
+            ? payload.statusCode
+            : undefined;
+    const error = typeof payload?.error === "string" ? payload.error : undefined;
+    const message = typeof payload?.message === "string" ? payload.message : undefined;
+    if (!statusCode && !error && !message)
+        return null;
+    return { statusCode, error, message };
+}
+export function formatError(err) {
+    if (err instanceof Error)
+        return err.message;
+    if (typeof err === "string")
+        return err;
+    if (!err || typeof err !== "object")
+        return String(err);
+    // Baileys frequently wraps errors under `error` with a Boom-like shape.
+    const boom = extractBoomDetails(err) ??
+        extractBoomDetails(err?.error) ??
+        extractBoomDetails(err?.lastDisconnect?.error);
+    const status = boom?.statusCode ?? getStatusCode(err);
+    const code = err?.code;
+    const codeText = typeof code === "string" || typeof code === "number"
+        ? String(code)
+        : undefined;
+    const messageCandidates = [
+        boom?.message,
+        typeof err?.message === "string"
+            ? err.message
+            : undefined,
+        typeof err?.error?.message ===
+            "string"
+            ? err.error?.message
+            : undefined,
+    ].filter((v) => Boolean(v && v.trim().length > 0));
+    const message = messageCandidates[0];
+    const pieces = [];
+    if (typeof status === "number")
+        pieces.push(`status=${status}`);
+    if (boom?.error)
+        pieces.push(boom.error);
+    if (message)
+        pieces.push(message);
+    if (codeText)
+        pieces.push(`code=${codeText}`);
+    if (pieces.length > 0)
+        return pieces.join(" ");
+    return safeStringify(err);
+}
+export async function webAuthExists() {
+    const sessionLogger = getChildLogger({ module: "web-session" });
+    maybeRestoreCredsFromBackup(sessionLogger);
+    const authDir = resolveWebAuthDir();
+    const credsPath = resolveWebCredsPath();
+    try {
+        await fs.access(authDir);
+    }
+    catch {
+        return false;
+    }
+    try {
+        const stats = await fs.stat(credsPath);
+        if (!stats.isFile() || stats.size <= 1)
+            return false;
+        const raw = await fs.readFile(credsPath, "utf-8");
+        JSON.parse(raw);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+export async function logoutWeb(runtime = defaultRuntime) {
+    const exists = await webAuthExists();
+    if (!exists) {
+        runtime.log(info("No WhatsApp Web session found; nothing to delete."));
+        return false;
+    }
+    await fs.rm(resolveWebAuthDir(), { recursive: true, force: true });
+    // Also drop session store to clear lingering per-sender state after logout.
+    await fs.rm(resolveDefaultSessionStorePath(), { force: true });
+    runtime.log(success("Cleared WhatsApp Web credentials."));
+    return true;
+}
+export function readWebSelfId() {
+    // Read the cached WhatsApp Web identity (jid + E.164) from disk if present.
+    try {
+        const credsPath = resolveWebCredsPath();
+        if (!fsSync.existsSync(credsPath)) {
+            return { e164: null, jid: null };
+        }
+        const raw = fsSync.readFileSync(credsPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        const jid = parsed?.me?.id ?? null;
+        const e164 = jid ? jidToE164(jid) : null;
+        return { e164, jid };
+    }
+    catch {
+        return { e164: null, jid: null };
+    }
+}
+/**
+ * Return the age (in milliseconds) of the cached WhatsApp web auth state, or null when missing.
+ * Helpful for heartbeats/observability to spot stale credentials.
+ */
+export function getWebAuthAgeMs() {
+    try {
+        const stats = fsSync.statSync(resolveWebCredsPath());
+        return Date.now() - stats.mtimeMs;
+    }
+    catch {
+        return null;
+    }
+}
+export function newConnectionId() {
+    return randomUUID();
+}
+export function logWebSelfId(runtime = defaultRuntime, includeProviderPrefix = false) {
+    // Human-friendly log of the currently linked personal web session.
+    const { e164, jid } = readWebSelfId();
+    const details = e164 || jid
+        ? `${e164 ?? "unknown"}${jid ? ` (jid ${jid})` : ""}`
+        : "unknown";
+    const prefix = includeProviderPrefix ? "Web Provider: " : "";
+    runtime.log(info(`${prefix}${details}`));
+}
+export async function pickProvider(pref) {
+    const choice = pref === "auto" ? "web" : pref;
+    const hasWeb = await webAuthExists();
+    if (!hasWeb) {
+        throw new Error("No WhatsApp Web session found. Run `clawdbot login --verbose` to link.");
+    }
+    return choice;
+}

package/dist/wizard/clack-prompter.js

@@ -0,0 +1,56 @@
+import { cancel, confirm, intro, isCancel, multiselect, note, outro, select, spinner, text, } from "@clack/prompts";
+import { WizardCancelledError } from "./prompts.js";
+function guardCancel(value) {
+    if (isCancel(value)) {
+        cancel("Setup cancelled.");
+        throw new WizardCancelledError();
+    }
+    return value;
+}
+export function createClackPrompter() {
+    return {
+        intro: async (title) => {
+            intro(title);
+        },
+        outro: async (message) => {
+            outro(message);
+        },
+        note: async (message, title) => {
+            note(message, title);
+        },
+        select: async (params) => guardCancel(await select({
+            message: params.message,
+            options: params.options.map((opt) => {
+                const base = { value: opt.value, label: opt.label };
+                return opt.hint === undefined ? base : { ...base, hint: opt.hint };
+            }),
+            initialValue: params.initialValue,
+        })),
+        multiselect: async (params) => guardCancel(await multiselect({
+            message: params.message,
+            options: params.options.map((opt) => {
+                const base = { value: opt.value, label: opt.label };
+                return opt.hint === undefined ? base : { ...base, hint: opt.hint };
+            }),
+            initialValues: params.initialValues,
+        })),
+        text: async (params) => guardCancel(await text({
+            message: params.message,
+            initialValue: params.initialValue,
+            placeholder: params.placeholder,
+            validate: params.validate,
+        })),
+        confirm: async (params) => guardCancel(await confirm({
+            message: params.message,
+            initialValue: params.initialValue,
+        })),
+        progress: (label) => {
+            const spin = spinner();
+            spin.start(label);
+            return {
+                update: (message) => spin.message(message),
+                stop: (message) => spin.stop(message),
+            };
+        },
+    };
+}