owpenwork 0.1.12 → 0.1.14

package/dist/bridge.js

@@ -19,6 +19,11 @@ const TOOL_LABELS = {
     task: "agent",
     webfetch: "webfetch",
 };
+const CHANNEL_LABELS = {
+    whatsapp: "WhatsApp",
+    telegram: "Telegram",
+};
+const TYPING_INTERVAL_MS = 6000;
 export async function startBridge(config, logger, reporter) {
     const reportStatus = reporter?.onStatus;
     const client = createClient(config);
@@ -43,6 +48,67 @@ export async function startBridge(config, logger, reporter) {
     }
     const sessionQueue = new Map();
     const activeRuns = new Map();
+    const sessionModels = new Map();
+    const typingLoops = new Map();
+    const formatPeer = (channel, peerId) => channel === "whatsapp" ? normalizeWhatsAppId(peerId) : peerId;
+    const formatModelLabel = (model) => model ? `${model.providerID}/${model.modelID}` : null;
+    const extractModelRef = (info) => {
+        if (!info || typeof info !== "object")
+            return null;
+        const record = info;
+        if (record.role !== "user")
+            return null;
+        if (!record.model || typeof record.model !== "object")
+            return null;
+        const model = record.model;
+        if (typeof model.providerID !== "string" || typeof model.modelID !== "string")
+            return null;
+        return { providerID: model.providerID, modelID: model.modelID };
+    };
+    const reportThinking = (run) => {
+        if (!reportStatus)
+            return;
+        const modelLabel = formatModelLabel(sessionModels.get(run.sessionID));
+        const nextLabel = modelLabel ? `Thinking (${modelLabel})` : "Thinking...";
+        if (run.thinkingLabel === nextLabel && run.thinkingActive)
+            return;
+        run.thinkingLabel = nextLabel;
+        run.thinkingActive = true;
+        reportStatus(`[${CHANNEL_LABELS[run.channel]}] ${formatPeer(run.channel, run.peerId)} ${nextLabel}`);
+    };
+    const reportDone = (run) => {
+        if (!reportStatus || !run.thinkingActive)
+            return;
+        const modelLabel = formatModelLabel(sessionModels.get(run.sessionID));
+        const suffix = modelLabel ? ` (${modelLabel})` : "";
+        reportStatus(`[${CHANNEL_LABELS[run.channel]}] ${formatPeer(run.channel, run.peerId)} Done${suffix}`);
+        run.thinkingActive = false;
+    };
+    const startTyping = (run) => {
+        const adapter = adapters.get(run.channel);
+        if (!adapter?.sendTyping)
+            return;
+        if (typingLoops.has(run.sessionID))
+            return;
+        const sendTyping = async () => {
+            try {
+                await adapter.sendTyping?.(run.peerId);
+            }
+            catch (error) {
+                logger.warn({ error, channel: run.channel }, "typing update failed");
+            }
+        };
+        void sendTyping();
+        const timer = setInterval(sendTyping, TYPING_INTERVAL_MS);
+        typingLoops.set(run.sessionID, timer);
+    };
+    const stopTyping = (sessionID) => {
+        const timer = typingLoops.get(sessionID);
+        if (!timer)
+            return;
+        clearInterval(timer);
+        typingLoops.delete(sessionID);
+    };
     let opencodeHealthy = false;
     let opencodeVersion;
     async function refreshHealth() {
@@ -80,6 +146,46 @@ export async function startBridge(config, logger, reporter) {
             const event = normalizeEvent(raw);
             if (!event)
                 continue;
+            if (event.type === "message.updated") {
+                if (event.properties && typeof event.properties === "object") {
+                    const record = event.properties;
+                    const info = record.info;
+                    const sessionID = typeof info?.sessionID === "string" ? info.sessionID : null;
+                    const model = extractModelRef(info);
+                    if (sessionID && model) {
+                        sessionModels.set(sessionID, model);
+                        const run = activeRuns.get(sessionID);
+                        if (run)
+                            reportThinking(run);
+                    }
+                }
+            }
+            if (event.type === "session.status") {
+                if (event.properties && typeof event.properties === "object") {
+                    const record = event.properties;
+                    const sessionID = typeof record.sessionID === "string" ? record.sessionID : null;
+                    const status = record.status;
+                    if (sessionID && (status?.type === "busy" || status?.type === "retry")) {
+                        const run = activeRuns.get(sessionID);
+                        if (run) {
+                            reportThinking(run);
+                            startTyping(run);
+                        }
+                    }
+                }
+            }
+            if (event.type === "session.idle") {
+                if (event.properties && typeof event.properties === "object") {
+                    const record = event.properties;
+                    const sessionID = typeof record.sessionID === "string" ? record.sessionID : null;
+                    if (sessionID) {
+                        stopTyping(sessionID);
+                        const run = activeRuns.get(sessionID);
+                        if (run)
+                            reportDone(run);
+                    }
+                }
+            }
             if (event.type === "message.part.updated") {
                 const part = event.properties?.part;
                 if (!part?.sessionID)
@@ -201,6 +307,8 @@ export async function startBridge(config, logger, reporter) {
                 seenToolStates: new Map(),
             };
             activeRuns.set(sessionID, runState);
+            reportThinking(runState);
+            startTyping(runState);
             try {
                 const response = await client.session.prompt({
                     sessionID,
@@ -228,6 +336,8 @@ export async function startBridge(config, logger, reporter) {
                 });
             }
             finally {
+                stopTyping(sessionID);
+                reportDone(runState);
                 activeRuns.delete(sessionID);
             }
         });
@@ -243,6 +353,8 @@ export async function startBridge(config, logger, reporter) {
             throw new Error("Failed to create session");
         store.upsertSession(message.channel, message.peerId, sessionID);
         logger.info({ sessionID, channel: message.channel, peerId: message.peerId }, "session created");
+        reportStatus?.(`${CHANNEL_LABELS[message.channel]} session created for ${formatPeer(message.channel, message.peerId)} (ID: ${sessionID}).`);
+        await sendText(message.channel, message.peerId, "🧭 Session started.", { kind: "system" });
         return sessionID;
     }
     function enqueue(sessionID, task) {
@@ -271,6 +383,10 @@ export async function startBridge(config, logger, reporter) {
             clearInterval(healthTimer);
             if (stopHealthServer)
                 stopHealthServer();
+            for (const timer of typingLoops.values()) {
+                clearInterval(timer);
+            }
+            typingLoops.clear();
             for (const adapter of adapters.values()) {
                 await adapter.stop();
             }

package/dist/cli.js

@@ -10,7 +10,7 @@ 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.12";
+const VERSION = "0.1.14";
 const STEP_OPTIONS = [
     {
         value: "config",

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,90 +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");
-                opts.onStatus?.("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");
-                opts.onStatus?.("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");
-                    opts.onStatus?.("WhatsApp stream error; reconnecting.");
-                    setTimeout(() => {
-                        void connect();
-                    }, 1000);
-                    return;
-                }
-                const shouldReconnect = statusCode !== DisconnectReason.loggedOut;
-                if (shouldReconnect && !stopped) {
-                    log.warn("whatsapp connection closed, reconnecting");
-                    opts.onStatus?.("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'");
-                    opts.onStatus?.("WhatsApp logged out. Run: owpenwork 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",
@@ -107,98 +156,85 @@ 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);
+        },
+        async sendTyping(peerId) {
+            if (!socket)
+                return;
+            try {
+                await socket.sendPresenceUpdate("composing", peerId);
+            }
+            catch (error) {
+                log.warn({ error, peerId }, "whatsapp typing update failed");
+            }
         },
     };
 }
 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");
-                    options.onStatus?.("Scan the QR code to connect WhatsApp.");
-                }
-                if (update.connection === "open") {
-                    options.onStatus?.("WhatsApp linked.");
-                    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");
-                            options.onStatus?.("WhatsApp login requires reconnect; completing login.");
-                            finish("connection.restart.required", "linked");
-                        }
-                        else {
-                            log.warn("whatsapp restart requested before creds registered");
-                            options.onStatus?.("WhatsApp login needs another scan.");
-                            finish("connection.restart.required", "restart");
-                        }
-                        return;
-                    }
-                    if (state.creds?.registered) {
-                        options.onStatus?.("WhatsApp linked.");
-                        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");
-            options.onStatus?.("Retrying WhatsApp login...");
-            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.12",
+  "version": "0.1.14",
   "description": "WhatsApp bridge for a running OpenCode server",
   "private": false,
   "type": "module",