@circuitwall/jarela 2.2.1 → 2.4.0

package/.next/standalone/.next/server/app/api/v1/bridges/[id]/chats/route.js

@@ -31,6 +31,573 @@ module.exports = require("url");
 
 module.exports = require("next/dist/server/app-render/after-task-async-storage.external.js");
 
+/***/ }),
+
+/***/ 3979:
+/***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
+
+
+// EXPORTS
+__webpack_require__.d(__webpack_exports__, {
+  AX: () => (/* binding */ getBridgeRuntimeStatus),
+  HQ: () => (/* binding */ isBridgeRunning),
+  FN: () => (/* binding */ listBridgeChats),
+  qM: () => (/* binding */ lookupBridgeChat),
+  s: () => (/* binding */ removeBridgeAuth),
+  V_: () => (/* binding */ repairBridge),
+  kn: () => (/* binding */ startAllBridges),
+  c0: () => (/* binding */ startBridge),
+  aq: () => (/* binding */ stopBridge)
+});
+
+// UNUSED EXPORTS: restartBridge, stopAllBridges
+
+// EXTERNAL MODULE: ./lib/stores/bridges.ts
+var bridges = __webpack_require__(78361);
+// EXTERNAL MODULE: ./lib/notifications/bus.ts
+var bus = __webpack_require__(76445);
+// EXTERNAL MODULE: ./lib/utils/global-state.ts
+var global_state = __webpack_require__(15559);
+// EXTERNAL MODULE: ./lib/stores/threads.ts
+var threads = __webpack_require__(83042);
+// EXTERNAL MODULE: ./lib/stores/agent-configs.ts
+var agent_configs = __webpack_require__(41720);
+// EXTERNAL MODULE: ./lib/agents/agent-turn.ts
+var agent_turn = __webpack_require__(62032);
+;// ./lib/bridges/router.ts
+
+/**
+ * Resolve which agent should handle an inbound message on (bridge, remote_jid).
+ * 0) Chat is on the ignore list → null (message dropped before any agent
+ *    thread, memory write, or tool call runs — the "listen to everything
+ *    except these chats" primitive).
+ * 1) Exact route match on (bridge_id, remote_jid)
+ * 2) Bridge-level catch-all route (`remote_jid='*'`) when present
+ * 3) null (dispatcher drops the message silently)
+ *
+ * Catch-all lets one agent handle all otherwise-unrouted chats on a bridge.
+ * This is especially useful for "triage" or "observer" agents. The ignore
+ * list is checked FIRST so it wins over both explicit routes and the
+ * catch-all — deleting an ignore entry is how you "resume listening".
+ */ function resolveRoute(bridge_id, remote_jid) {
+    if ((0,bridges/* isIgnored */.pi)(bridge_id, remote_jid)) return null;
+    return (0,bridges/* findRoute */.$6)(bridge_id, remote_jid) ?? (0,bridges/* findRoute */.$6)(bridge_id, "*");
+}
+
+// EXTERNAL MODULE: ./lib/utils/source-link.ts
+var source_link = __webpack_require__(12262);
+;// ./lib/bridges/message-role.ts
+/**
+ * Cross-adapter framing for bridge inbound messages.
+ *
+ * Bridge conversations are inherently multi-party: the paired user, one or
+ * more counterparts (1:1 partner or group members), and the agent that's
+ * observing/assisting. Without role framing, the LLM tends to read every
+ * inbound message as a direct command — even when the message was sent by
+ * the user's chat partner, who has no idea an agent is in the loop.
+ *
+ * This module is the single source of truth for that framing. Every bridge
+ * adapter (WhatsApp today; Telegram/Slack/Discord/email tomorrow) populates
+ * `InboundMessage.role` with one of these values, and the dispatcher feeds
+ * the message through `formatBridgePrompt` to produce the prefix the agent
+ * sees. Adding a new adapter is a matter of mapping its platform-specific
+ * "who sent this" signal onto `MessageRole`; the framing code does not need
+ * to change.
+ */ 
+/**
+ * Build the prompt prefix the agent receives for one bridge-inbound message.
+ *
+ * Output shape:
+ *
+ *   <one-line semantic note framing the role>
+ *
+ *   [bridge:<id>]
+ *   [chat_id:<id>]
+ *   [chat_name:<label>]
+ *   [chat_type:dm|group]
+ *   [message_role:user|counterpart|agent]
+ *   [sender_id:<id>]
+ *   [sender_name:<label>]
+ *   ([chat_link:<https url>] when the platform has a permalink for the chat)
+ *   ([group_name:<label>] [participant_id:<id>] [participant_name:<label>] for groups)
+ *
+ *   <raw text>
+ *
+ * The metadata block is keyed-tag for parseability; the leading note is
+ * prose so the LLM has an explicit framing without having to learn the
+ * convention. Both are stable across adapters.
+ */ function formatBridgePrompt(input) {
+    const note = roleNote(input.role, input.is_group, input.silent === true, input.event);
+    // Header values come from the platform (display names, group subjects) and
+    // are sender-controlled: a line break would forge extra headers or end the
+    // header block early, so every value is flattened onto one line.
+    const h = (value)=>String(value ?? "").replace(/[\r\n\u0085\u2028\u2029]+/g, " ");
+    const lines = [
+        `[bridge:${h(input.bridge_id)}]`,
+        `[chat_id:${h(input.chat_id)}]`,
+        `[chat_name:${h(input.chat_name)}]`,
+        `[chat_type:${input.is_group ? "group" : "dm"}]`,
+        `[message_role:${input.role}]`,
+        `[sender_id:${h(input.sender_id)}]`,
+        `[sender_name:${h(input.sender_name)}]`
+    ];
+    const chatLink = (0,source_link/* httpsUrlOrNull */.N)(input.chat_link);
+    if (chatLink) lines.push(`[chat_link:${chatLink}]`);
+    if (input.event) {
+        lines.push(`[event_type:${input.event.type}]`);
+        lines.push(`[event_subtype:${h(input.event.subtype)}]`);
+    }
+    if (input.is_group) {
+        lines.push(`[group_name:${h(input.chat_name)}]`);
+        lines.push(`[participant_id:${h(input.sender_id)}]`);
+        lines.push(`[participant_name:${h(input.sender_name)}]`);
+    }
+    return `${note}\n\n${lines.join("\n")}\n\n${input.text}`;
+}
+// Parses bridge prompt envelopes rendered by formatBridgePrompt().
+// Back-compat: also accepts legacy keys (chat_jid/sender_jid) and optional
+// prose preface before the [bridge:...] metadata block.
+function parseBridgePrompt(raw) {
+    const start = raw.indexOf("[bridge:");
+    if (start < 0) return null;
+    const src = raw.slice(start);
+    const headers = {};
+    const lines = src.split("\n");
+    let i = 0;
+    for(; i < lines.length; i++){
+        const line = lines[i].replace(/\r$/, "");
+        if (line === "") {
+            i++;
+            break;
+        }
+        const m = /^\[([a-z_]+):([\s\S]*)\]$/.exec(line);
+        if (!m) return null;
+        headers[m[1]] = m[2];
+    }
+    const chatId = headers.chat_id || headers.chat_jid;
+    const senderId = headers.sender_id || headers.sender_jid || chatId;
+    if (!headers.bridge || !chatId || !headers.chat_type) return null;
+    return {
+        bridgeId: headers.bridge,
+        chatJid: chatId,
+        chatName: headers.chat_name || chatId,
+        isGroup: headers.chat_type === "group",
+        senderJid: senderId,
+        senderName: headers.sender_name || senderId || "Unknown",
+        chatLink: httpsUrlOrNull(headers.chat_link),
+        body: lines.slice(i).join("\n").trimEnd()
+    };
+}
+function roleNote(role, isGroup, silent, event) {
+    if (event) {
+        const evt = event.type === "group_profile_update" ? "group profile/settings update" : "group participant update";
+        return `The payload below is a ${evt} (${event.subtype}) emitted by the platform, not a normal chat message typed by a participant. ` + "Use it as conversation state/context. Do not assume someone is directly addressing you unless your instructions explicitly require replying to system events.";
+    }
+    if (silent) {
+        // Observer mode overrides the per-role framing: the agent is forbidden
+        // from speaking on the chat regardless of who sent the inbound message.
+        // It may still use the event as context and take non-chat actions that
+        // its normal instructions require.
+        if (role === "agent") {
+            return "The message below is your own prior output, surfaced again because the bridge adapter could not suppress its echo. Use it only as a record of what you previously said — do not respond to it.";
+        }
+        return "Silent / observer mode is enabled for this route. You are standing on the paired user's side and listening to the chat for context, memory, risk, or tasks that matter to the paired user's instructions. " + "Do not write to the chat, draft a chat reply, imitate a participant, or answer the sender conversationally. " + "Act only through allowed non-chat tools or internal state when your normal instructions require it. " + "Most observed messages need no visible response: if there is no important internal note, risk, or user-actionable item for the paired user inside Jarela, reply with exactly the single token NO_REPLY and nothing else.";
+    }
+    switch(role){
+        case "user":
+            return "The paired user themselves sent the message below in this conversation. Treat it as the user's own reaction/input to the prior chat — they are speaking to the other party, not directly to you. Use it to update your understanding of the user's intent.";
+        case "counterpart":
+            return isGroup ? "The message below was sent by another member of this group chat, addressed to the paired user. Respond on the user's behalf, in their voice, following your agent instructions and persona — do not introduce yourself as an assistant or break character. If your instructions tell you to stay silent or escalate to the user, do that instead." : "The message below was sent by the user's counterpart in this 1:1 chat, addressed to the paired user. Respond on the user's behalf, in their voice, following your agent instructions and persona — do not introduce yourself as an assistant or break character. If your instructions tell you to stay silent or escalate to the user, do that instead.";
+        case "agent":
+            return "The message below is your own prior output, surfaced again because the bridge adapter could not suppress its echo. Use it only as a record of what you previously said — do not respond to it.";
+    }
+}
+
+// EXTERNAL MODULE: ./lib/utils/error.ts
+var error = __webpack_require__(22032);
+// EXTERNAL MODULE: ./lib/agents/run-queue.ts
+var run_queue = __webpack_require__(3944);
+// EXTERNAL MODULE: ./lib/stores/automation-activity.ts
+var automation_activity = __webpack_require__(26316);
+;// ./lib/bridges/dispatcher.ts
+
+
+
+
+
+
+
+
+
+
+/**
+ * Handle one inbound message from a bridge adapter:
+ *   1. Resolve the chat → agent route. Unrouted → publish an advisory
+ *      event and drop. No thread created, no reply sent.
+ *   2. Use `getOrCreateAgentThread(agent_id)` (one-thread-per-agent
+ *      invariant — `UNIQUE(agent_id)` on bridge_routes ensures no chat
+ *      interleaving).
+ *   3. Drive the agent via the canonical `runAgentTurn` helper used by
+ *      every external context turn.
+ *   4. Persist the assistant message and send the reply back through the
+ *      adapter on the originating channel.
+ *
+ * Top-level try/catch — adapter callbacks must never throw into the Baileys
+ * socket event handler (would tear down the WS).
+ */ async function handleInboundMessage(adapter, msg) {
+    try {
+        const route = resolveRoute(adapter.bridge_id, msg.remote_jid);
+        if (!route) {
+            // Unrouted chats are silently dropped. We intentionally do NOT publish
+            // a notification here — the user already declared "this chat isn't
+            // monitored" by not configuring a route, so popping a toast for every
+            // inbound message in an active group would be noise. The console log
+            // remains for debugging; the chat picker in BridgeEditor still shows
+            // observed chats so a route can be added on demand.
+            console.log(`[bridge ${adapter.bridge_id}] dropped: no route for ${msg.remote_jid} (${msg.push_name ?? "?"})`);
+            return;
+        }
+        const agentId = route.agent_id;
+        const agent = (0,agent_configs/* getAgentConfig */.mJ)(agentId);
+        if (!agent) {
+            console.warn(`[bridge ${adapter.bridge_id}] route points at missing agent ${agentId}, dropping`);
+            return;
+        }
+        const thread = (0,threads/* getOrCreateAgentThread */.xH)(agentId);
+        // Stamp bridge/chat provenance + sender role onto every inbound prompt.
+        // Role framing (user / counterpart / agent) is shared across every
+        // bridge adapter via `formatBridgePrompt` — see lib/bridges/message-role.ts.
+        const chatName = msg.chat_name ?? msg.push_name ?? "unknown";
+        const senderJid = msg.sender_jid ?? msg.participant_jid ?? msg.remote_jid;
+        const senderName = msg.sender_name ?? msg.push_name ?? senderJid;
+        const silent = route.silent_mode === 1;
+        const willReply = !silent && msg.role === route.respond_to;
+        const activity = (0,automation_activity/* createAutomationActivity */.P2)({
+            threadId: thread.thread_id,
+            sourceKind: "bridge",
+            sourceId: `${adapter.bridge_id}:${msg.remote_jid}`,
+            label: `Message from ${senderName}`,
+            state: "checking",
+            detail: msg.text
+        });
+        const publishActivity = ()=>{
+            (0,bus/* publish */.mk)({
+                type: "automation_activity",
+                thread_id: thread.thread_id,
+                agent_id: agentId,
+                ts: Date.now()
+            });
+        };
+        publishActivity();
+        const promptText = formatBridgePrompt({
+            bridge_id: adapter.bridge_id,
+            chat_id: msg.remote_jid,
+            chat_name: chatName,
+            is_group: msg.is_group,
+            role: msg.role,
+            sender_id: senderJid,
+            sender_name: senderName,
+            chat_link: adapter.chatLink?.(msg.remote_jid) ?? null,
+            text: msg.text,
+            silent,
+            event: msg.event
+        });
+        const bridgeConversation = {
+            key: `${adapter.bridge_id}:${msg.remote_jid}`,
+            bridge_id: adapter.bridge_id,
+            chat_id: msg.remote_jid
+        };
+        // Keep typing outside the queue so users still see "thinking" while
+        // waiting behind other queued turns for the same thread.
+        let typingActive = willReply;
+        if (willReply) {
+            void adapter.sendTyping(msg.remote_jid, true).catch(()=>{});
+        }
+        const typingTimer = setInterval(()=>{
+            if (!typingActive) return;
+            void adapter.sendTyping(msg.remote_jid, true).catch(()=>{});
+        }, 8000);
+        typingTimer.unref?.();
+        let reply = "";
+        let suppressAssistant = false;
+        let aborted = false;
+        try {
+            // Surface the bridge kind+name in the system prompt so the agent
+            // knows it's answering on e.g. WhatsApp — fixes the "I don't have
+            // access to WhatsApp" reply on bridge-delivered turns. Falls back
+            // to bridge_id when the row was deleted between fetch and dispatch.
+            const bridge = (0,bridges/* getBridge */.e1)(adapter.bridge_id);
+            let result;
+            try {
+                result = await (0,agent_turn.runAgentTurn)({
+                    thread_id: thread.thread_id,
+                    queue_source: "bridge",
+                    message: promptText,
+                    attachments: msg.attachments,
+                    user_category: "bridge",
+                    assistant_category: "bridge",
+                    user_message_metadata: {
+                        bridge_conversation: bridgeConversation
+                    },
+                    assistant_message_metadata: {
+                        bridge_conversation: bridgeConversation
+                    },
+                    history_bridge_key: bridgeConversation.key,
+                    silent,
+                    queue_lane: willReply ? "interactive" : "background",
+                    queue_expires_at: willReply ? undefined : Date.now() + 5 * 60000,
+                    on_queue_state: (state)=>{
+                        (0,automation_activity/* updateAutomationActivity */.ou)(activity.msg_id, {
+                            state: state === "queued" ? "queued" : "checking"
+                        });
+                        publishActivity();
+                    },
+                    delivery_channel: {
+                        kind: bridge?.kind ?? "bridge",
+                        name: bridge?.name ?? null
+                    }
+                });
+            } catch (err) {
+                if (err instanceof run_queue/* QueueExpiredError */.vR) {
+                    (0,automation_activity/* finalizeAutomationActivity */.lU)(activity.msg_id, {
+                        disposition: "expired"
+                    });
+                    publishActivity();
+                    return;
+                }
+                (0,automation_activity/* finalizeAutomationActivity */.lU)(activity.msg_id, {
+                    disposition: "failed",
+                    error: (0,error/* errorMessage */.g)(err)
+                });
+                publishActivity();
+                throw err;
+            }
+            reply = result.assistantContent.trim();
+            suppressAssistant = result.skippedAssistant;
+            aborted = result.aborted;
+        } finally{
+            typingActive = false;
+            clearInterval(typingTimer);
+            if (willReply) {
+                void adapter.sendTyping(msg.remote_jid, false).catch(()=>{});
+            }
+        }
+        // Outbound reply gate: silent_mode (master switch) AND respond_to
+        // (per-role trigger). Both must clear for a message to leave the
+        // dispatcher. The WhatsApp adapter also re-checks `route.silent_mode`
+        // inside its own sendText as a belt-and-suspenders guard, so even a
+        // tool that called adapter.sendText directly would be dropped.
+        let sendError = null;
+        if (reply.length > 0 && willReply) {
+            try {
+                await adapter.sendText(msg.remote_jid, reply);
+            } catch (sendErr) {
+                const m = (0,error/* errorMessage */.g)(sendErr);
+                sendError = m;
+                console.error(`[bridge ${adapter.bridge_id}] sendText failed:`, m);
+            }
+        }
+        (0,automation_activity/* finalizeAutomationActivity */.lU)(activity.msg_id, aborted ? {
+            disposition: "cancelled"
+        } : sendError ? {
+            disposition: "failed",
+            error: sendError
+        } : {
+            disposition: reply.length > 0 && !suppressAssistant ? "action" : "no_action",
+            preview: suppressAssistant ? undefined : reply.replace(/\s+/g, " ").slice(0, 120)
+        });
+        publishActivity();
+        if (!silent || !suppressAssistant) {
+            (0,bus/* publish */.mk)({
+                type: "bridge_message_received",
+                bridge_id: adapter.bridge_id,
+                remote_jid: msg.remote_jid,
+                push_name: msg.push_name,
+                is_group: msg.is_group,
+                thread_id: thread.thread_id,
+                agent_id: agentId,
+                preview: suppressAssistant ? "" : reply.replace(/\s+/g, " ").slice(0, 120),
+                ts: Date.now()
+            });
+        }
+    } catch (err) {
+        const m = (0,error/* errorMessage */.g)(err);
+        console.error(`[bridge ${adapter.bridge_id}] dispatcher error on ${msg.remote_jid}:`, m);
+    }
+}
+
+// EXTERNAL MODULE: ./lib/bridges/registry.ts + 5 modules
+var registry = __webpack_require__(70309);
+;// ./lib/bridges/runtime.ts
+/**
+ * Bridge lifecycle manager.
+ *
+ * Owns a `Map<bridge_id, BridgeAdapter>` plus a `Map<bridge_id, StatusUpdate>`
+ * of the latest known status per bridge (so the HTTP status endpoint can
+ * return live QR / connection state without consulting the adapter directly).
+ *
+ * - `startAllBridges()` — called at app boot; scans `bridges` for
+ *   `enabled=1` rows and spins up their adapters.
+ * - `startBridge(id)` / `stopBridge(id)` / `restartBridge(id)` — called from
+ *   the HTTP layer (toggle enabled, re-pair, delete).
+ *
+ * Pinned to globalThis so dev HMR doesn't double-start (same pattern as
+ * lib/scheduler/index.ts).
+ */ 
+
+
+
+
+
+const state = (0,global_state/* getOrCreateGlobal */.X)("__jarela_bridges", ()=>({
+        adapters: new Map(),
+        status: new Map(),
+        started: false
+    }));
+function makeAdapter(bridge_id, kind) {
+    const bridgeModule = (0,registry/* getBridgeModule */.ut)(kind);
+    if (!bridgeModule) throw new Error(`Unknown bridge kind: ${kind}`);
+    return bridgeModule.createAdapter(bridge_id);
+}
+async function removeBridgeAuth(bridge_id) {
+    const bridge = (0,bridges/* getBridge */.e1)(bridge_id);
+    if (!bridge) return;
+    await (0,registry/* getBridgeModule */.ut)(bridge.kind)?.removeAuth(bridge_id);
+}
+function wireAdapter(adapter) {
+    adapter.onInboundMessage((msg)=>handleInboundMessage(adapter, msg));
+    adapter.onStatusChange((update)=>{
+        state.status.set(adapter.bridge_id, update);
+        // Persist the user-visible bits so they survive a process restart.
+        const patch = {
+            status: update.status,
+            qr: update.qr_data_url ?? null,
+            last_error: update.error ?? null
+        };
+        if (update.paired_id !== undefined) patch.paired_id = update.paired_id;
+        (0,bridges/* updateBridge */.po)(adapter.bridge_id, patch);
+        (0,bus/* publish */.mk)({
+            type: "bridge_status",
+            bridge_id: adapter.bridge_id,
+            status: update.status,
+            error: update.error ?? null,
+            paired_id: update.paired_id ?? null,
+            ts: Date.now()
+        });
+    });
+}
+async function startBridge(bridge_id) {
+    if (state.adapters.has(bridge_id)) return;
+    const row = (0,bridges/* getBridge */.e1)(bridge_id);
+    if (!row) throw new Error(`Bridge ${bridge_id} not found`);
+    const adapter = makeAdapter(bridge_id, row.kind);
+    state.adapters.set(bridge_id, adapter);
+    wireAdapter(adapter);
+    try {
+        await adapter.start();
+    } catch (err) {
+        state.adapters.delete(bridge_id);
+        const m = (0,error/* errorMessage */.g)(err);
+        (0,bridges/* updateBridge */.po)(bridge_id, {
+            status: "error",
+            last_error: m
+        });
+        throw err;
+    }
+}
+async function stopBridge(bridge_id) {
+    const adapter = state.adapters.get(bridge_id);
+    state.adapters.delete(bridge_id);
+    state.status.delete(bridge_id);
+    if (adapter) {
+        try {
+            await adapter.stop();
+        } catch (err) {
+            console.error(`[bridge ${bridge_id}] stop failed:`, err);
+        }
+    }
+    // Persist that the bridge is down (in case status callback didn't fire).
+    (0,bridges/* updateBridge */.po)(bridge_id, {
+        status: "disconnected",
+        qr: null
+    });
+}
+async function restartBridge(bridge_id) {
+    await stopBridge(bridge_id);
+    await startBridge(bridge_id);
+}
+async function repairBridge(bridge_id) {
+    const bridge = (0,bridges/* getBridge */.e1)(bridge_id);
+    if (!bridge) throw new Error(`Bridge ${bridge_id} not found`);
+    const bridgeModule = (0,registry/* getBridgeModule */.ut)(bridge.kind);
+    if (!bridgeModule?.pairing) throw new Error(`Bridge kind "${bridge.kind}" does not support pairing`);
+    await stopBridge(bridge_id);
+    await bridgeModule.removeAuth(bridge_id);
+    (0,bridges/* updateBridge */.po)(bridge_id, {
+        status: "disconnected",
+        qr: null,
+        last_error: null,
+        paired_id: null
+    });
+    await startBridge(bridge_id);
+}
+function getBridgeRuntimeStatus(bridge_id) {
+    return state.status.get(bridge_id) ?? null;
+}
+function isBridgeRunning(bridge_id) {
+    return state.adapters.has(bridge_id);
+}
+/**
+ * Snapshot of chats the adapter has observed since connecting. Returns []
+ * when the bridge isn't running yet. Triggers a background refresh so that
+ * subsequent calls see newly-fetched group metadata.
+ */ function listBridgeChats(bridge_id) {
+    const adapter = state.adapters.get(bridge_id);
+    if (!adapter?.listChats) return [];
+    // Fire-and-forget — refreshChats hits a WS round-trip; HTTP shouldn't
+    // wait. The next poll will pick up any new entries.
+    void adapter.refreshChats?.().catch(()=>{});
+    return adapter.listChats();
+}
+/**
+ * Look up a freeform phone number (or other identifier) against the bridge
+ * and return the resolved chat if it exists, else null. Returns null also
+ * if the bridge isn't running.
+ */ async function lookupBridgeChat(bridge_id, input) {
+    const adapter = state.adapters.get(bridge_id);
+    if (!adapter?.lookupChat) return null;
+    return adapter.lookupChat(input);
+}
+/**
+ * Boot hook. Idempotent — safe to call from a layout module that may be
+ * evaluated multiple times in Next.js dev HMR.
+ */ async function startAllBridges() {
+    if (state.started) return;
+    state.started = true;
+    const rows = (0,bridges/* listBridges */.X9)();
+    for (const row of rows){
+        if (row.enabled !== 1) continue;
+        try {
+            await startBridge(row.id);
+        } catch (err) {
+            const m = (0,error/* errorMessage */.g)(err);
+            console.error(`[bridge ${row.id}] failed to start at boot:`, m);
+        // updateBridge already happened inside startBridge's catch.
+        }
+    }
+}
+// Stop every running bridge. Called from the graceful-shutdown path so
+// WhatsApp WS sockets etc. close cleanly before the process exits. We
+// await in parallel — a single slow `adapter.stop()` shouldn't gate the
+// others — but the whole call is still bounded by the outer shutdown
+// timeout in `lib/lifecycle/shutdown.ts`.
+async function stopAllBridges() {
+    const ids = Array.from(state.adapters.keys());
+    await Promise.allSettled(ids.map((id)=>stopBridge(id)));
+    state.started = false;
+}
+
+
 /***/ }),
 
 /***/ 8128:
@@ -230,21 +797,7 @@ module.exports = require("https");
 
 /***/ }),
 
-/***/ 57075:
-/***/ ((module) => {
-
-module.exports = require("node:stream");
-
-/***/ }),
-
-/***/ 57975:
-/***/ ((module) => {
-
-module.exports = require("node:util");
-
-/***/ }),
-
-/***/ 62289:
+/***/ 55691:
 /***/ ((__unused_webpack_module, __webpack_exports__, __webpack_require__) => {
 
 __webpack_require__.r(__webpack_exports__);
@@ -686,6 +1239,20 @@ async function handler(req, res, ctx) {
 //# sourceMappingURL=app-route.js.map
 
 
+/***/ }),
+
+/***/ 57075:
+/***/ ((module) => {
+
+module.exports = require("node:stream");
+
+/***/ }),
+
+/***/ 57975:
+/***/ ((module) => {
+
+module.exports = require("node:util");
+
 /***/ }),
 
 /***/ 63033:
@@ -807,7 +1374,7 @@ module.exports = import("@huggingface/transformers");;
 var __webpack_require__ = require("../../../../../../webpack-runtime.js");
 __webpack_require__.C(exports);
 var __webpack_exec__ = (moduleId) => (__webpack_require__(__webpack_require__.s = moduleId))
-var __webpack_exports__ = __webpack_require__.X(0, [2970,7377,1813,7981,513,6299,563,8808,7547,4992,46,3042,3566,2068,4377,1638,5585,3524,9640,3175,6142,540,4955,5908,5936,424,4540,3979], () => (__webpack_exec__(62289)));
+var __webpack_exports__ = __webpack_require__.X(0, [2970,7377,1813,7981,513,6299,563,8808,7547,4992,46,3042,3566,2068,4377,1638,5585,9304,3524,3175,6142,540,4189,4955,5908,5120,1388,309], () => (__webpack_exec__(55691)));
 module.exports = __webpack_exports__;
 
 })();