owpenwork 0.1.11 → 0.1.13

package/dist/bridge.js

@@ -19,7 +19,8 @@ const TOOL_LABELS = {
     task: "agent",
     webfetch: "webfetch",
 };
-export async function startBridge(config, logger) {
+export async function startBridge(config, logger, reporter) {
+    const reportStatus = reporter?.onStatus;
     const client = createClient(config);
     const store = new BridgeStore(config.dbPath);
     store.seedAllowlist("telegram", config.allowlist.telegram);
@@ -31,12 +32,14 @@ export async function startBridge(config, logger) {
     }
     else {
         logger.info("telegram adapter disabled");
+        reportStatus?.("Telegram adapter disabled.");
     }
     if (config.whatsappEnabled) {
-        adapters.set("whatsapp", createWhatsAppAdapter(config, logger, handleInbound, { printQr: true }));
+        adapters.set("whatsapp", createWhatsAppAdapter(config, logger, handleInbound, { printQr: true, onStatus: reportStatus }));
     }
     else {
         logger.info("whatsapp adapter disabled");
+        reportStatus?.("WhatsApp adapter disabled.");
     }
     const sessionQueue = new Map();
     const activeRuns = new Map();
@@ -102,7 +105,7 @@ export async function startBridge(config, logger) {
                     if (output)
                         message += `\n${output}`;
                 }
-                await sendText(run.channel, run.peerId, message);
+                await sendText(run.channel, run.peerId, message, { kind: "tool" });
             }
             if (event.type === "permission.asked") {
                 const permission = event.properties;
@@ -117,7 +120,9 @@ export async function startBridge(config, logger) {
                 if (response === "reject") {
                     const run = activeRuns.get(permission.sessionID);
                     if (run) {
-                        await sendText(run.channel, run.peerId, "Permission denied. Update configuration to allow tools.");
+                        await sendText(run.channel, run.peerId, "Permission denied. Update configuration to allow tools.", {
+                            kind: "system",
+                        });
                     }
                 }
             }
@@ -125,10 +130,14 @@ export async function startBridge(config, logger) {
     })().catch((error) => {
         logger.error({ error }, "event stream closed");
     });
-    async function sendText(channel, peerId, text) {
+    async function sendText(channel, peerId, text, options = {}) {
         const adapter = adapters.get(channel);
         if (!adapter)
             return;
+        const kind = options.kind ?? "system";
+        if (options.display !== false) {
+            reporter?.onOutbound?.({ channel, peerId, text, kind });
+        }
         const chunks = chunkText(text, adapter.maxTextLength);
         for (const chunk of chunks) {
             logger.info({ channel, peerId, length: chunk.length }, "sending message");
@@ -151,30 +160,36 @@ export async function startBridge(config, logger) {
             const allowed = allowAll || isSelf || store.isAllowed("whatsapp", peerKey);
             if (!allowed) {
                 if (config.whatsappDmPolicy === "allowlist") {
-                    await sendText(inbound.channel, inbound.peerId, "Access denied. Ask the owner to allowlist your number.");
+                    await sendText(inbound.channel, inbound.peerId, "Access denied. Ask the owner to allowlist your number.", { kind: "system" });
                     return;
                 }
                 store.prunePairingRequests();
                 const active = store.getPairingRequest("whatsapp", peerKey);
                 const pending = store.listPairingRequests("whatsapp");
                 if (!active && pending.length >= 3) {
-                    await sendText(inbound.channel, inbound.peerId, "Pairing queue full. Ask the owner to approve pending requests.");
+                    await sendText(inbound.channel, inbound.peerId, "Pairing queue full. Ask the owner to approve pending requests.", { kind: "system" });
                     return;
                 }
                 const code = active?.code ?? String(Math.floor(100000 + Math.random() * 900000));
                 if (!active) {
                     store.createPairingRequest("whatsapp", peerKey, code, 60 * 60_000);
                 }
-                await sendText(inbound.channel, inbound.peerId, `Pairing required. Ask the owner to approve code: ${code}`);
+                await sendText(inbound.channel, inbound.peerId, `Pairing required. Ask the owner to approve code: ${code}`, { kind: "system" });
                 return;
             }
         }
         else if (config.allowlist[inbound.channel].size > 0) {
             if (!store.isAllowed(inbound.channel, peerKey)) {
-                await sendText(inbound.channel, inbound.peerId, "Access denied.");
+                await sendText(inbound.channel, inbound.peerId, "Access denied.", { kind: "system" });
                 return;
             }
         }
+        reporter?.onInbound?.({
+            channel: inbound.channel,
+            peerId: inbound.peerId,
+            text: inbound.text,
+            fromMe: inbound.fromMe,
+        });
         const session = store.getSession(inbound.channel, peerKey);
         const sessionID = session?.session_id ?? (await createSession({ ...inbound, peerId: peerKey }));
         enqueue(sessionID, async () => {
@@ -198,15 +213,19 @@ export async function startBridge(config, logger) {
                     .join("\n")
                     .trim();
                 if (reply) {
-                    await sendText(inbound.channel, inbound.peerId, reply);
+                    await sendText(inbound.channel, inbound.peerId, reply, { kind: "reply" });
                 }
                 else {
-                    await sendText(inbound.channel, inbound.peerId, "No response generated. Try again.");
+                    await sendText(inbound.channel, inbound.peerId, "No response generated. Try again.", {
+                        kind: "system",
+                    });
                 }
             }
             catch (error) {
                 logger.error({ error }, "prompt failed");
-                await sendText(inbound.channel, inbound.peerId, "Error: failed to reach OpenCode.");
+                await sendText(inbound.channel, inbound.peerId, "Error: failed to reach OpenCode.", {
+                    kind: "system",
+                });
             }
             finally {
                 activeRuns.delete(sessionID);
@@ -242,8 +261,10 @@ export async function startBridge(config, logger) {
     }
     for (const adapter of adapters.values()) {
         await adapter.start();
+        reportStatus?.(`${adapter.name === "whatsapp" ? "WhatsApp" : "Telegram"} adapter started.`);
     }
     logger.info({ channels: Array.from(adapters.keys()) }, "bridge started");
+    reportStatus?.(`Bridge running. Logs: ${config.logFile}`);
     return {
         async stop() {
             eventAbort.abort();

package/dist/cli.js

@@ -8,8 +8,9 @@ import { loadConfig, normalizeWhatsAppId, readConfigFile, writeConfigFile, } fro
 import { BridgeStore } from "./db.js";
 import { createLogger } from "./logger.js";
 import { createClient } from "./opencode.js";
+import { truncateText } from "./text.js";
 import { loginWhatsApp, unpairWhatsApp } from "./whatsapp.js";
-const VERSION = "0.1.11";
+const VERSION = "0.1.13";
 const STEP_OPTIONS = [
     {
         value: "config",
@@ -62,6 +63,38 @@ function defaultSelections(configExists, whatsappLinked) {
     selections.push("start");
     return selections;
 }
+function createAppLogger(config) {
+    return createLogger(config.logLevel, { logFile: config.logFile });
+}
+function createConsoleReporter() {
+    const formatChannel = (channel) => (channel === "whatsapp" ? "WhatsApp" : "Telegram");
+    const formatPeer = (channel, peerId, fromMe) => {
+        const base = channel === "whatsapp" ? normalizeWhatsAppId(peerId) : peerId;
+        return fromMe ? `${base} (me)` : base;
+    };
+    const printBlock = (prefix, text) => {
+        const lines = text.split(/\r?\n/).map((line) => truncateText(line.trim(), 240));
+        const [first, ...rest] = lines.length ? lines : ["(empty)"];
+        console.log(`${prefix} ${first}`);
+        for (const line of rest) {
+            console.log(`${" ".repeat(prefix.length)} ${line}`);
+        }
+    };
+    return {
+        onStatus(message) {
+            console.log(message);
+        },
+        onInbound({ channel, peerId, text, fromMe }) {
+            const prefix = `[${formatChannel(channel)}] ${formatPeer(channel, peerId, fromMe)} >`;
+            printBlock(prefix, text);
+        },
+        onOutbound({ channel, peerId, text, kind }) {
+            const marker = kind === "reply" ? "<" : kind === "tool" ? "*" : "!";
+            const prefix = `[${formatChannel(channel)}] ${formatPeer(channel, peerId)} ${marker}`;
+            printBlock(prefix, text);
+        },
+    };
+}
 function updateConfig(configPath, updater) {
     const { config } = readConfigFile(configPath);
     const base = config ?? { version: 1 };
@@ -195,12 +228,13 @@ async function runStart(pathOverride) {
         process.env.OPENCODE_DIRECTORY = pathOverride.trim();
     }
     const config = loadConfig();
-    const logger = createLogger(config.logLevel);
+    const logger = createAppLogger(config);
+    const reporter = createConsoleReporter();
     if (!process.env.OPENCODE_DIRECTORY) {
         process.env.OPENCODE_DIRECTORY = config.opencodeDirectory;
     }
-    const bridge = await startBridge(config, logger);
-    logger.info("Commands: owpenwork whatsapp login, owpenwork pairing list, owpenwork status");
+    const bridge = await startBridge(config, logger, reporter);
+    reporter.onStatus?.("Commands: owpenwork whatsapp login, owpenwork pairing list, owpenwork status");
     const shutdown = async () => {
         logger.info("shutting down");
         await bridge.stop();
@@ -277,7 +311,7 @@ async function runGuidedFlow(pathArg, opts) {
                     if (!relink)
                         return;
                 }
-                await loginWhatsApp(config, createLogger(config.logLevel));
+                await loginWhatsApp(config, createAppLogger(config), { onStatus: console.log });
             });
             continue;
         }
@@ -338,7 +372,7 @@ login
     .description("Login to WhatsApp via QR code")
     .action(async () => {
     const config = loadConfig(process.env, { requireOpencode: false });
-    await loginWhatsApp(config, createLogger(config.logLevel));
+    await loginWhatsApp(config, createAppLogger(config), { onStatus: console.log });
 });
 login
     .command("telegram")
@@ -372,28 +406,28 @@ whatsapp
     .description("Login to WhatsApp via QR code")
     .action(async () => {
     const config = loadConfig(process.env, { requireOpencode: false });
-    await loginWhatsApp(config, createLogger(config.logLevel));
+    await loginWhatsApp(config, createAppLogger(config), { onStatus: console.log });
 });
 whatsapp
     .command("logout")
     .description("Logout of WhatsApp and clear auth state")
     .action(() => {
     const config = loadConfig(process.env, { requireOpencode: false });
-    unpairWhatsApp(config, createLogger(config.logLevel));
+    unpairWhatsApp(config, createAppLogger(config));
 });
 program
     .command("qr")
     .description("Print a WhatsApp QR code to pair")
     .action(async () => {
     const config = loadConfig(process.env, { requireOpencode: false });
-    await loginWhatsApp(config, createLogger(config.logLevel));
+    await loginWhatsApp(config, createAppLogger(config), { onStatus: console.log });
 });
 program
     .command("unpair")
     .description("Clear WhatsApp pairing data")
     .action(() => {
     const config = loadConfig(process.env, { requireOpencode: false });
-    unpairWhatsApp(config, createLogger(config.logLevel));
+    unpairWhatsApp(config, createAppLogger(config));
 });
 const pairing = program.command("pairing").description("Pairing requests");
 pairing

package/dist/config.js

@@ -125,6 +125,7 @@ export function loadConfig(env = process.env, options = {}) {
     const resolvedDirectory = opencodeDirectory || process.cwd();
     const dataDir = expandHome(env.OWPENBOT_DATA_DIR ?? "~/.owpenbot");
     const dbPath = expandHome(env.OWPENBOT_DB_PATH ?? path.join(dataDir, "owpenbot.db"));
+    const logFile = expandHome(env.OWPENBOT_LOG_FILE ?? path.join(dataDir, "logs", "owpenbot.log"));
     const configPath = resolveConfigPath(dataDir, env);
     const { config: configFile } = readConfigFile(configPath);
     const whatsappFile = configFile.channels?.whatsapp ?? {};
@@ -159,6 +160,7 @@ export function loadConfig(env = process.env, options = {}) {
         whatsappEnabled: parseBoolean(env.WHATSAPP_ENABLED, true),
         dataDir,
         dbPath,
+        logFile,
         allowlist: envAllowlist,
         toolUpdatesEnabled: parseBoolean(env.TOOL_UPDATES_ENABLED, false),
         groupsEnabled: parseBoolean(env.GROUPS_ENABLED, false),

package/dist/logger.js

@@ -1,5 +1,12 @@
+import fs from "node:fs";
+import path from "node:path";
 import pino from "pino";
-export function createLogger(level) {
+export function createLogger(level, options) {
+    if (options?.logFile) {
+        fs.mkdirSync(path.dirname(options.logFile), { recursive: true });
+        const destination = pino.destination({ dest: options.logFile, sync: false });
+        return pino({ level, base: undefined }, destination);
+    }
     return pino({
         level,
         base: undefined,

package/dist/telegram.js

@@ -20,12 +20,17 @@ export function createTelegramAdapter(config, logger, onMessage) {
         const text = msg.text ?? msg.caption ?? "";
         if (!text.trim())
             return;
-        await onMessage({
-            channel: "telegram",
-            peerId: String(msg.chat.id),
-            text,
-            raw: msg,
-        });
+        try {
+            await onMessage({
+                channel: "telegram",
+                peerId: String(msg.chat.id),
+                text,
+                raw: msg,
+            });
+        }
+        catch (error) {
+            logger.error({ error, peerId: msg.chat.id }, "telegram inbound handler failed");
+        }
     });
     return {
         name: "telegram",

package/dist/whatsapp-session.js

@@ -0,0 +1,166 @@
+import fs from "node:fs";
+import path from "node:path";
+import { fetchLatestBaileysVersion, makeCacheableSignalKeyStore, makeWASocket, useMultiFileAuthState, } from "@whiskeysockets/baileys";
+import qrcode from "qrcode-terminal";
+const CREDS_FILE = "creds.json";
+const CREDS_BACKUP = "creds.json.bak";
+const DEFAULT_TIMEOUT_MS = 120_000;
+let credsSaveQueue = Promise.resolve();
+function readCredsRaw(filePath) {
+    try {
+        if (!fs.existsSync(filePath))
+            return null;
+        const stats = fs.statSync(filePath);
+        if (!stats.isFile() || stats.size <= 1)
+            return null;
+        return fs.readFileSync(filePath, "utf-8");
+    }
+    catch {
+        return null;
+    }
+}
+function isValidJson(raw) {
+    try {
+        JSON.parse(raw);
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+function ensureDir(dir) {
+    fs.mkdirSync(dir, { recursive: true });
+}
+function backupCreds(authDir, logger) {
+    try {
+        const credsPath = path.join(authDir, CREDS_FILE);
+        const backupPath = path.join(authDir, CREDS_BACKUP);
+        const raw = readCredsRaw(credsPath);
+        if (!raw || !isValidJson(raw))
+            return;
+        fs.copyFileSync(credsPath, backupPath);
+    }
+    catch (error) {
+        logger.warn({ error }, "whatsapp creds backup failed");
+    }
+}
+function maybeRestoreCreds(authDir, logger) {
+    try {
+        const credsPath = path.join(authDir, CREDS_FILE);
+        const backupPath = path.join(authDir, CREDS_BACKUP);
+        const raw = readCredsRaw(credsPath);
+        if (raw && isValidJson(raw))
+            return;
+        const backupRaw = readCredsRaw(backupPath);
+        if (!backupRaw || !isValidJson(backupRaw))
+            return;
+        fs.copyFileSync(backupPath, credsPath);
+        logger.warn({ credsPath }, "restored whatsapp creds from backup");
+    }
+    catch (error) {
+        logger.warn({ error }, "whatsapp creds restore failed");
+    }
+}
+function enqueueSaveCreds(authDir, saveCreds, logger) {
+    credsSaveQueue = credsSaveQueue
+        .then(async () => {
+        backupCreds(authDir, logger);
+        await Promise.resolve(saveCreds());
+    })
+        .catch((error) => {
+        logger.warn({ error }, "whatsapp creds save failed");
+    });
+}
+export function hasWhatsAppCreds(authDir) {
+    const raw = readCredsRaw(path.join(authDir, CREDS_FILE));
+    if (!raw)
+        return false;
+    return isValidJson(raw);
+}
+export function getStatusCode(error) {
+    return (error?.output?.statusCode ??
+        error?.error?.output?.statusCode ??
+        error?.status);
+}
+export async function createWhatsAppSocket(options) {
+    const { authDir, logger, printQr, onStatus, onQr } = options;
+    ensureDir(authDir);
+    maybeRestoreCreds(authDir, logger);
+    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,
+        syncFullHistory: false,
+        markOnlineOnConnect: false,
+        browser: ["owpenbot", "cli", "0.1.0"],
+    });
+    sock.ev.on("creds.update", () => enqueueSaveCreds(authDir, saveCreds, logger));
+    sock.ev.on("connection.update", (update) => {
+        if (update.qr) {
+            onQr?.(update.qr);
+            if (printQr) {
+                qrcode.generate(update.qr, { small: true });
+                onStatus?.("Scan the QR code to connect WhatsApp.");
+            }
+        }
+        if (update.connection === "open") {
+            onStatus?.("WhatsApp connected.");
+        }
+    });
+    sock.ws?.on?.("error", (error) => {
+        logger.error({ error }, "whatsapp websocket error");
+    });
+    return sock;
+}
+export function closeWhatsAppSocket(sock) {
+    try {
+        sock.ws?.close();
+    }
+    catch {
+        // ignore
+    }
+    try {
+        sock.end?.(undefined);
+    }
+    catch {
+        // ignore
+    }
+}
+export function waitForWhatsAppConnection(sock, options = {}) {
+    const timeoutMs = options.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+    return new Promise((resolve, reject) => {
+        const ev = sock.ev;
+        let timer = null;
+        const cleanup = () => {
+            ev.off?.("connection.update", handler);
+            ev.removeListener?.("connection.update", handler);
+            if (timer)
+                clearTimeout(timer);
+        };
+        const handler = (...args) => {
+            const update = (args[0] ?? {});
+            if (update.connection === "open") {
+                cleanup();
+                resolve();
+                return;
+            }
+            if (update.connection === "close") {
+                cleanup();
+                reject(update.lastDisconnect ?? new Error("Connection closed"));
+            }
+        };
+        if (timeoutMs > 0) {
+            timer = setTimeout(() => {
+                cleanup();
+                reject(new Error("Timed out waiting for WhatsApp connection"));
+            }, timeoutMs);
+        }
+        sock.ev.on("connection.update", handler);
+    });
+}

package/dist/whatsapp.js

@@ -1,8 +1,9 @@
 import fs from "node:fs";
 import path from "node:path";
-import { DisconnectReason, fetchLatestBaileysVersion, isJidGroup, makeCacheableSignalKeyStore, makeWASocket, useMultiFileAuthState, } from "@whiskeysockets/baileys";
-import qrcode from "qrcode-terminal";
+import { DisconnectReason, isJidGroup } from "@whiskeysockets/baileys";
+import { closeWhatsAppSocket, createWhatsAppSocket, getStatusCode, hasWhatsAppCreds, waitForWhatsAppConnection, } from "./whatsapp-session.js";
 const MAX_TEXT_LENGTH = 3800;
+const SENT_MESSAGE_TTL_MS = 10 * 60_000;
 function extractText(message) {
     const content = message.message;
     if (!content)
@@ -14,85 +15,138 @@ function extractText(message) {
         content.documentMessage?.caption ||
         "");
 }
-function ensureDir(dir) {
-    fs.mkdirSync(dir, { recursive: true });
-}
 export function createWhatsAppAdapter(config, logger, onMessage, opts = {}) {
     let socket = null;
     let stopped = false;
+    let connecting = false;
+    let reconnectAttempts = 0;
+    let reconnectTimer = null;
+    const sentMessageIds = new Map();
     const log = logger.child({ channel: "whatsapp" });
     const authDir = path.resolve(config.whatsappAuthDir);
-    ensureDir(authDir);
-    async function connect() {
-        const { state, saveCreds } = await useMultiFileAuthState(authDir);
-        const { version } = await fetchLatestBaileysVersion();
-        const sock = makeWASocket({
-            auth: {
-                creds: state.creds,
-                keys: makeCacheableSignalKeyStore(state.keys, log),
-            },
-            version,
-            logger: log,
-            printQRInTerminal: false,
-            syncFullHistory: false,
-            markOnlineOnConnect: false,
-            browser: ["owpenbot", "cli", "0.1.0"],
-        });
-        sock.ev.on("creds.update", saveCreds);
-        sock.ev.on("connection.update", (update) => {
-            if (update.qr && opts.printQr) {
-                qrcode.generate(update.qr, { small: true });
-                log.info("scan the QR code to connect WhatsApp");
+    const reconnectPolicy = {
+        initialMs: 1500,
+        maxMs: 30_000,
+        factor: 1.6,
+        jitter: 0.25,
+        maxAttempts: 10,
+    };
+    const computeDelay = (attempt) => {
+        const base = reconnectPolicy.initialMs * Math.pow(reconnectPolicy.factor, Math.max(0, attempt - 1));
+        const capped = Math.min(base, reconnectPolicy.maxMs);
+        const jitter = capped * reconnectPolicy.jitter * (Math.random() * 2 - 1);
+        return Math.max(250, Math.round(capped + jitter));
+    };
+    const resetReconnect = () => {
+        reconnectAttempts = 0;
+        if (reconnectTimer) {
+            clearTimeout(reconnectTimer);
+            reconnectTimer = null;
+        }
+    };
+    const scheduleReconnect = (statusCode) => {
+        if (stopped || reconnectTimer)
+            return;
+        reconnectAttempts += 1;
+        if (reconnectAttempts > reconnectPolicy.maxAttempts) {
+            log.warn({ attempts: reconnectAttempts }, "whatsapp reconnect attempts exhausted");
+            opts.onStatus?.("WhatsApp reconnect attempts exhausted. Run: owpenwork whatsapp login.");
+            return;
+        }
+        const delayMs = statusCode === 515 ? 1000 : computeDelay(reconnectAttempts);
+        log.warn({ delayMs, statusCode }, "whatsapp reconnect scheduled");
+        opts.onStatus?.(`WhatsApp reconnecting in ${Math.round(delayMs / 1000)}s...`);
+        reconnectTimer = setTimeout(() => {
+            reconnectTimer = null;
+            void connect({ printQr: false });
+        }, delayMs);
+    };
+    const recordSentMessage = (messageId) => {
+        if (!messageId)
+            return;
+        sentMessageIds.set(messageId, Date.now());
+    };
+    const pruneSentMessages = () => {
+        const now = Date.now();
+        for (const [id, timestamp] of sentMessageIds) {
+            if (now - timestamp > SENT_MESSAGE_TTL_MS) {
+                sentMessageIds.delete(id);
             }
-            if (update.connection === "open") {
-                log.info("whatsapp connected");
+        }
+    };
+    async function connect(options = {}) {
+        if (stopped || connecting)
+            return;
+        connecting = true;
+        try {
+            if (socket) {
+                closeWhatsAppSocket(socket);
+                socket = null;
             }
-            if (update.connection === "close") {
-                const lastDisconnect = update.lastDisconnect;
-                const statusCode = lastDisconnect?.error?.output?.statusCode;
-                if (statusCode === 515 && !stopped) {
-                    log.warn("whatsapp stream error; restarting connection");
-                    setTimeout(() => {
-                        void connect();
-                    }, 1000);
-                    return;
-                }
-                const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
-                if (shouldReconnect && !stopped) {
-                    log.warn("whatsapp connection closed, reconnecting");
-                    void connect();
+            const sock = await createWhatsAppSocket({
+                authDir,
+                logger: log,
+                printQr: options.printQr ?? opts.printQr,
+                onStatus: opts.onStatus,
+            });
+            sock.ev.on("connection.update", (update) => {
+                if (update.connection === "open") {
+                    resetReconnect();
                 }
-                else if (!shouldReconnect) {
-                    log.warn("whatsapp logged out, run 'owpenbot whatsapp login'");
+                if (update.connection === "close") {
+                    const statusCode = getStatusCode(update.lastDisconnect?.error ?? update.lastDisconnect);
+                    if (statusCode === DisconnectReason.loggedOut) {
+                        log.warn("whatsapp logged out, run 'owpenbot whatsapp login'");
+                        opts.onStatus?.("WhatsApp logged out. Run: owpenwork whatsapp login.");
+                        return;
+                    }
+                    if (statusCode === 515) {
+                        opts.onStatus?.("WhatsApp asked for a restart; reconnecting.");
+                    }
+                    scheduleReconnect(statusCode);
                 }
-            }
-        });
-        sock.ev.on("messages.upsert", async ({ messages }) => {
-            for (const msg of messages) {
-                if (!msg.message)
-                    continue;
-                const fromMe = Boolean(msg.key.fromMe);
-                if (fromMe && !config.whatsappSelfChatMode)
-                    continue;
-                const peerId = msg.key.remoteJid;
-                if (!peerId)
-                    continue;
-                if (isJidGroup(peerId) && !config.groupsEnabled) {
-                    continue;
+            });
+            sock.ev.on("messages.upsert", async ({ messages }) => {
+                pruneSentMessages();
+                for (const msg of messages) {
+                    if (!msg.message)
+                        continue;
+                    const fromMe = Boolean(msg.key.fromMe);
+                    const messageId = msg.key.id;
+                    if (fromMe && messageId && sentMessageIds.has(messageId)) {
+                        sentMessageIds.delete(messageId);
+                        continue;
+                    }
+                    if (fromMe && !config.whatsappSelfChatMode)
+                        continue;
+                    const peerId = msg.key.remoteJid;
+                    if (!peerId)
+                        continue;
+                    if (isJidGroup(peerId) && !config.groupsEnabled) {
+                        continue;
+                    }
+                    const text = extractText(msg);
+                    if (!text.trim())
+                        continue;
+                    try {
+                        await onMessage({
+                            channel: "whatsapp",
+                            peerId,
+                            text,
+                            raw: msg,
+                            fromMe,
+                        });
+                    }
+                    catch (error) {
+                        log.error({ error, peerId }, "whatsapp inbound handler failed");
+                    }
                 }
-                const text = extractText(msg);
-                if (!text.trim())
-                    continue;
-                await onMessage({
-                    channel: "whatsapp",
-                    peerId,
-                    text,
-                    raw: msg,
-                    fromMe,
-                });
-            }
-        });
-        socket = sock;
+            });
+            socket = sock;
+        }
+        finally {
+            connecting = false;
+        }
     }
     return {
         name: "whatsapp",
@@ -102,92 +156,75 @@ export function createWhatsAppAdapter(config, logger, onMessage, opts = {}) {
         },
         async stop() {
             stopped = true;
+            if (reconnectTimer) {
+                clearTimeout(reconnectTimer);
+                reconnectTimer = null;
+            }
             if (socket) {
-                socket.end(undefined);
+                closeWhatsAppSocket(socket);
                 socket = null;
             }
         },
         async sendText(peerId, text) {
             if (!socket)
                 throw new Error("WhatsApp socket not initialized");
-            await socket.sendMessage(peerId, { text });
+            const sent = await socket.sendMessage(peerId, { text });
+            recordSentMessage(sent?.key?.id);
         },
     };
 }
-export async function loginWhatsApp(config, logger) {
+export async function loginWhatsApp(config, logger, options = {}) {
     const authDir = path.resolve(config.whatsappAuthDir);
-    ensureDir(authDir);
     const log = logger.child({ channel: "whatsapp" });
-    const { state, saveCreds } = await useMultiFileAuthState(authDir);
-    const { version } = await fetchLatestBaileysVersion();
-    const credsPath = path.join(authDir, "creds.json");
-    const maxAttempts = 2;
-    for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
-        const result = await new Promise((resolve) => {
-            let finished = false;
-            const sock = makeWASocket({
-                auth: {
-                    creds: state.creds,
-                    keys: makeCacheableSignalKeyStore(state.keys, log),
-                },
-                version,
-                logger: log,
-                printQRInTerminal: false,
-                syncFullHistory: false,
-                markOnlineOnConnect: false,
-                browser: ["owpenbot", "cli", "0.1.0"],
-            });
-            const finish = (reason, status) => {
-                if (finished)
-                    return;
-                finished = true;
-                log.info({ reason }, "whatsapp login finished");
-                sock.end(undefined);
-                resolve(status);
-            };
-            sock.ev.on("creds.update", async () => {
-                await saveCreds();
-                if (state.creds?.registered) {
-                    finish("creds.registered", "linked");
-                }
-            });
-            sock.ev.on("connection.update", (update) => {
-                if (update.qr) {
-                    qrcode.generate(update.qr, { small: true });
-                    log.info("scan the QR code to connect WhatsApp");
-                }
-                if (update.connection === "open") {
-                    finish("connection.open", "linked");
-                }
-                if (update.connection === "close") {
-                    const lastDisconnect = update.lastDisconnect;
-                    const statusCode = lastDisconnect?.error?.output?.statusCode;
-                    if (statusCode === 515) {
-                        if (state.creds?.registered || fs.existsSync(credsPath)) {
-                            log.info("whatsapp login requires reconnect; completing login");
-                            finish("connection.restart.required", "linked");
-                        }
-                        else {
-                            log.warn("whatsapp restart requested before creds registered");
-                            finish("connection.restart.required", "restart");
-                        }
-                        return;
-                    }
-                    if (state.creds?.registered) {
-                        finish("connection.close.registered", "linked");
-                    }
-                }
-            });
+    const timeoutMs = options.timeoutMs ?? 120_000;
+    const attemptLogin = async (phase, printQr) => {
+        const sock = await createWhatsAppSocket({
+            authDir,
+            logger: log,
+            printQr,
+            onStatus: options.onStatus,
         });
-        if (result === "linked") {
-            return;
+        try {
+            if (phase === "initial") {
+                options.onStatus?.("Waiting for WhatsApp scan...");
+            }
+            else {
+                options.onStatus?.("Reconnecting WhatsApp session...");
+            }
+            await waitForWhatsAppConnection(sock, { timeoutMs });
+            options.onStatus?.("WhatsApp linked.");
+            return { ok: true };
+        }
+        catch (error) {
+            const statusCode = getStatusCode(error);
+            return { ok: false, error, statusCode };
         }
-        if (attempt < maxAttempts) {
-            log.warn("retrying whatsapp login after restart");
-            await new Promise((resolve) => setTimeout(resolve, 1500));
+        finally {
+            setTimeout(() => closeWhatsAppSocket(sock), 500);
+        }
+    };
+    const initial = await attemptLogin("initial", true);
+    if (initial.ok)
+        return;
+    if (initial.statusCode === DisconnectReason.loggedOut) {
+        options.onStatus?.("WhatsApp logged out. Run: owpenwork whatsapp login.");
+        throw new Error("WhatsApp logged out");
+    }
+    const shouldRetry = initial.statusCode === 515 || (initial.statusCode === undefined && hasWhatsAppCreds(authDir));
+    if (shouldRetry) {
+        options.onStatus?.("WhatsApp asked for a restart; retrying connection...");
+        const retry = await attemptLogin("restart", false);
+        if (retry.ok)
+            return;
+        if (retry.statusCode === DisconnectReason.loggedOut) {
+            options.onStatus?.("WhatsApp logged out. Run: owpenwork whatsapp login.");
         }
+        throw new Error(`WhatsApp login failed after restart: ${String(retry.error)}`);
+    }
+    if (!initial.statusCode && !hasWhatsAppCreds(authDir)) {
+        options.onStatus?.("Timed out waiting for QR scan. Run login again for a fresh QR.");
     }
-    throw new Error("WhatsApp login failed after restart");
+    throw new Error(`WhatsApp login failed: ${String(initial.error)}`);
 }
 export function unpairWhatsApp(config, logger) {
     const authDir = path.resolve(config.whatsappAuthDir);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "owpenwork",
-  "version": "0.1.11",
+  "version": "0.1.13",
   "description": "WhatsApp bridge for a running OpenCode server",
   "private": false,
   "type": "module",