@heylemon/lemonade 2026.2.25 → 2026.2.27

package/dist/build-info.json

@@ -1,5 +1,5 @@
 {
-  "version": "2026.2.25",
-  "commit": "c541a48e05b68c3a4d189a35f48649c388f57fa1",
-  "builtAt": "2026-02-19T17:46:07.135Z"
+  "version": "2026.2.27",
+  "commit": "2909f76416b6b24d6d692f9273ba5f452283248d",
+  "builtAt": "2026-02-20T04:00:13.136Z"
 }

package/dist/canvas-host/a2ui/.bundle.hash

@@ -1 +1 @@
-140b3b7c47510604aa1c59436ecf4b03ac92f2762d85a0c50581d82725391c66
+97f5c46c50948d0e879a973bf28450f752b5c3beda881fe18db3cdebcb14f395

package/dist/gateway/server-channels.js

@@ -110,6 +110,7 @@ export function createChannelManager(opts) {
                 log.error?.(`[${id}] channel exited: ${message}`);
             })
                 .finally(() => {
+                const wasAborted = abort.signal.aborted;
                 store.aborts.delete(id);
                 store.tasks.delete(id);
                 setRuntime(channelId, id, {
@@ -117,6 +118,23 @@ export function createChannelManager(opts) {
                     running: false,
                     lastStopAt: Date.now(),
                 });
+                // Auto-restart channels that exit unexpectedly (not intentionally
+                // stopped via abort).  This is a safety net: the inner reconnect
+                // loop inside monitorWebChannel handles transient failures, but if
+                // the channel exits entirely (e.g., max reconnect attempts
+                // exhausted, or an unexpected throw), we restart it at this level.
+                if (!wasAborted) {
+                    const RESTART_DELAY_MS = 30_000;
+                    log.info?.(`[${id}] scheduling auto-restart in ${RESTART_DELAY_MS / 1000}s`);
+                    setTimeout(() => {
+                        if (store.tasks.has(id))
+                            return; // already restarted
+                        log.info?.(`[${id}] auto-restarting channel`);
+                        void startChannel(channelId, id).catch((restartErr) => {
+                            log.error?.(`[${id}] auto-restart failed: ${formatErrorMessage(restartErr)}`);
+                        });
+                    }, RESTART_DELAY_MS);
+                }
             });
             store.tasks.set(id, tracked);
         }));

package/dist/web/auto-reply/monitor.js

@@ -16,7 +16,7 @@ import { resolveWhatsAppAccount } from "../accounts.js";
 import { setActiveWebListener } from "../active-listener.js";
 import { monitorWebInbox } from "../inbound.js";
 import { computeBackoff, newConnectionId, resolveHeartbeatSeconds, resolveReconnectPolicy, sleepWithAbort, } from "../reconnect.js";
-import { formatError, getWebAuthAgeMs, readWebSelfId } from "../session.js";
+import { formatError, getStatusCode, getWebAuthAgeMs, readWebSelfId } from "../session.js";
 import { DEFAULT_WEB_MEDIA_BYTES } from "./constants.js";
 import { whatsappHeartbeatLog, whatsappLog } from "./loggers.js";
 import { buildMentionConfig } from "./mentions.js";
@@ -142,24 +142,70 @@ export async function monitorWebChannel(verbose, listenerFactory = monitorWebInb
                 return false;
             return !hasControlCommand(msg.body, cfg);
         };
-        const listener = await (listenerFactory ?? monitorWebInbox)({
-            verbose,
-            accountId: account.accountId,
-            authDir: account.authDir,
-            mediaMaxMb: account.mediaMaxMb,
-            sendReadReceipts: account.sendReadReceipts,
-            debounceMs: inboundDebounceMs,
-            shouldDebounce,
-            onMessage: async (msg) => {
-                handledMessages += 1;
-                lastMessageAt = Date.now();
-                status.lastMessageAt = lastMessageAt;
-                status.lastEventAt = lastMessageAt;
-                emitStatus();
-                _lastInboundMsg = msg;
-                await onMessage(msg);
-            },
-        });
+        let listener;
+        try {
+            listener = await (listenerFactory ?? monitorWebInbox)({
+                verbose,
+                accountId: account.accountId,
+                authDir: account.authDir,
+                mediaMaxMb: account.mediaMaxMb,
+                sendReadReceipts: account.sendReadReceipts,
+                debounceMs: inboundDebounceMs,
+                shouldDebounce,
+                onMessage: async (msg) => {
+                    handledMessages += 1;
+                    lastMessageAt = Date.now();
+                    status.lastMessageAt = lastMessageAt;
+                    status.lastEventAt = lastMessageAt;
+                    emitStatus();
+                    _lastInboundMsg = msg;
+                    await onMessage(msg);
+                },
+            });
+        }
+        catch (err) {
+            // Initial socket creation or WebSocket handshake failed (e.g., 408
+            // timeout, 428 Connection Terminated).  Without this catch the error
+            // escapes the while-loop and the reconnect backoff is never reached.
+            const errStatusCode = getStatusCode(err);
+            const errorStr = formatError(err);
+            reconnectLogger.warn({ connectionId, error: errorStr, status: errStatusCode }, "web reconnect: initial connection failed");
+            status.connected = false;
+            status.lastError = errorStr;
+            status.lastDisconnect = {
+                at: Date.now(),
+                status: typeof errStatusCode === "number" ? errStatusCode : undefined,
+                error: errorStr,
+                loggedOut: errStatusCode === 401,
+            };
+            emitStatus();
+            if (errStatusCode === 401) {
+                runtime.error(`WhatsApp session logged out. Run \`${formatCliCommand("lemonade channels login --channel web")}\` to relink.`);
+                break;
+            }
+            reconnectAttempts += 1;
+            status.reconnectAttempts = reconnectAttempts;
+            emitStatus();
+            if (reconnectPolicy.maxAttempts > 0 && reconnectAttempts >= reconnectPolicy.maxAttempts) {
+                reconnectLogger.warn({
+                    connectionId,
+                    status: errStatusCode,
+                    reconnectAttempts,
+                    maxAttempts: reconnectPolicy.maxAttempts,
+                }, "web reconnect: max attempts reached after connection failure");
+                runtime.error(`WhatsApp Web reconnect: max attempts reached (${reconnectAttempts}/${reconnectPolicy.maxAttempts}). Stopping web monitoring.`);
+                break;
+            }
+            const delay = computeBackoff(reconnectPolicy, reconnectAttempts);
+            runtime.error(`WhatsApp Web connection failed (status ${errStatusCode ?? "unknown"}). Retry ${reconnectAttempts}/${reconnectPolicy.maxAttempts || "∞"} in ${formatDurationMs(delay)}… (${errorStr})`);
+            try {
+                await sleep(delay, abortSignal);
+            }
+            catch {
+                break;
+            }
+            continue;
+        }
         status.connected = true;
         status.lastConnectedAt = Date.now();
         status.lastEventAt = status.lastConnectedAt;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@heylemon/lemonade",
-  "version": "2026.2.25",
+  "version": "2026.2.27",
   "description": "AI gateway CLI for Lemon - local AI assistant with integrations",
   "publishConfig": {
     "access": "restricted"