omni-notify-mcp 1.3.30 → 1.3.34

package/README.md

@@ -28,11 +28,13 @@
 
 | Process | Entry | What it owns |
 |---|---|---|
-| **UI/HTTP server** | `dist/ui/server.js` (bin `omni-notify-ui`) | Every channel implementation, the routing policy (DND / idle / mute), the inbound inbox, the Telegram long-poll listener, the Slack channel poller, the built-in ntfy server, the web config UI, and — when `ENABLE_MCP=1` — the Streamable-HTTP `/mcp` endpoint. Listens on `0.0.0.0:3737` by default. |
+| **UI/HTTP server** | `dist/ui/server.js` (bin `omni-notify-ui`) | Every channel implementation, the routing policy (DND / idle / mute), the inbound inbox, the Telegram long-poll listener, the Slack channel poller, the built-in ntfy server, the web config UI, and — when `ENABLE_MCP=1` — the Streamable-HTTP `/mcp` endpoint. Listens on port 3737 on every interface, IPv4 and IPv6, by default. |
 | **stdio MCP bridge** | `dist/index.js` (bin `omni-notify-mcp`) | A stateless proxy. Auto-spawns the server if `:3737` isn't answering, opens one persistent `/mcp` session, forwards every tool call to it, subscribes to `/api/inbox/stream` and re-emits each message as a `notifications/claude/channel` event. Holds no config and no queue. |
 
 The VS Code extension (`vscode-extension/`) is a third, optional face: it starts the
-server if needed and renders `http://localhost:3737/` inside a webview.
+server if needed, renders `http://localhost:3737/` inside a webview, reports on its status
+bar whether the server can actually deliver, and writes the stdio bridge into both MCP
+host config files (`~/.claude.json` and the open folder's `.vscode/mcp.json`).
 
 > **Build note.** `package.json` is deliberately untracked in this repo (see
 > `.gitignore`), so the dependency list, the `bin` map, the version and the extension
@@ -77,7 +79,7 @@ entirely server-side.
 | `ask` | `question`, `timeout_seconds` (30–3600, default 300) | Sends the question to Telegram (every configured chat id) and email (with a one-shot `/reply/:token` web page), then **blocks** until a reply lands or the timeout throws. |
 | `poll` | — | Drains queued inbox messages for this session's tag; returns `inbox:empty` when there are none. |
 | `wait_for_inbox` | `timeout_seconds` (5–55, default 50) | Parks a waiter and returns the moment a matching message arrives, as a tool *result*. Returns already-queued messages immediately without parking. |
-| `get_idle_seconds` | — | Seconds since the last OS keyboard/mouse input, or `-1` where unsupported. Drains the inbox as a side effect. |
+| `get_idle_seconds` | — | How long since the last OS keyboard/mouse input, as one of two DIFFERENT answers: `idle: measured N seconds …`, or `idle: could not measure — user activity unknown, so activity gating is skipped` when this machine cannot report user activity at all. Drains the inbox as a side effect. |
 | `get_idle_config` | — | `{ enabled, thresholdSeconds, alwaysDesktopWhenActive }`. Drains the inbox. |
 | `get_dnd_status` | — | `{ active, reason }` where reason is `disabled` (master mute or this client disabled), `manual`, `schedule` or `off`. Drains the inbox. |
 | `update_instructions` | `instructions` (≤4000), `target` = `global`\|`project` | Rewrites a marker-delimited block in `~/.claude/CLAUDE.md` (global) or `./.claude/CLAUDE.md` (project). |
@@ -273,7 +275,7 @@ rename, disable or force-reconnect one. `help.html` is the copy-paste setup page
 | `POST /api/slack/events` | Slack Events API receiver; HMAC-verified when `SLACK_SIGNING_SECRET` is set. |
 | `POST /api/ui/visibility` | The web UI heartbeats its own visibility; while visible, non-`high` notifications stay desktop-only. |
 | `GET /reply/:token`, `POST /reply/:token` | One-shot web reply page for `ask` over email. |
-| `GET /v1/health`, `/v1/info` | Liveness (used by the VS Code extension) and version stub. |
+| `GET /v1/health`, `/v1/info` | Delivery report read by the VS Code extension's status bar: `{healthy, process, mcp, channels, reason}`. `healthy` is true only when the MCP endpoint is enabled **and** at least one channel is enabled and able to carry, so a listening server that could send nothing is reported unhealthy rather than green. `/v1/info` stays a version stub. |
 | `/:topic/sse`, `/:topic/json`, `PUT`/`POST /:topic`, `/:topic/subscribers` | Built-in ntfy protocol server (also mounted under `/ntfy/…`). |
 
 `POST /__test__/inject-inbox` and `GET /__test__/slack-clients` exist only when
@@ -298,7 +300,7 @@ rename, disable or force-reconnect one. `help.html` is the copy-paste setup page
 | Script | What it does |
 |---|---|
 | `notify-ui.sh` | Build if `dist/ui/server.js` is missing, then run the server in the foreground (**without** `ENABLE_MCP`). |
-| `restart.sh` | `npm run build:ui`, kill the running `dist/ui/server.js`, relaunch detached to `/tmp/notify-mcp.log`. |
+| `restart.sh` | `npm run build:ui`, stop the one pid holding `:3737`, relaunch detached with `ENABLE_MCP=1` to `/tmp/notify-mcp.log`, then read `/v1/health` and exit non-zero unless the server reports it can deliver. |
 | `bus-up.sh` | Singleton watchdog: keeps `:3737` listening, redeploys when `dist/ui/server.js` changes on disk, and keeps one `notify-watch.sh` alive. Logs to `.run/`. |
 | `notify-watch.sh` | Detached responder. Long-polls `/api/agent/inbox/wait` for `<host>-<folder>-bot`, and passes every message **verbatim** to a headless `claude -p` that answers via `POST /api/agent/slack/reply`. |
 | `scripts/agent-notify.sh`, `agent-poll-inbox.sh`, `agent-wait-inbox.sh`, `agent-listen-loop.sh` | curl wrappers over the plain-HTTP agent API (`NOTIFY_BASE_URL`, `NOTIFY_AGENT_KEY`, `NOTIFY_TAG`, `NOTIFY_ON_MESSAGE_CMD`). |

package/dist/index.js

@@ -7,7 +7,11 @@
  * listener) lives in the long-running HTTP server (`ui/server.js`, default
  * port 3737). The bridge:
  *
- *   1. Ensures the HTTP server is running (auto-spawns it detached if not).
+ *   1. Ensures the HTTP server is running, and auto-spawns it detached when a
+ *      server ships beside this bridge — the npm package and this repo both put
+ *      `ui/server.js` there. A bridge-only copy (the VS Code extension mirrors
+ *      `dist/index.mjs` alone, deliberately: see vscode-extension/esbuild.js)
+ *      has no server to start, so it reports that instead of spawning one.
  *   2. Subscribes to /api/inbox/stream via SSE and re-emits each unsolicited
  *      user message as a `notifications/claude/channel` notification to the
  *      attached client. Claude Code (v2.1.80+) surfaces those as synthetic
@@ -26,7 +30,7 @@
 import { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
 import { spawn } from "child_process";
-import { existsSync } from "fs";
+import { existsSync, readFileSync } from "fs";
 import { join, dirname, basename } from "path";
 import { hostname } from "os";
 import { fileURLToPath } from "url";
@@ -35,6 +39,16 @@ import { splitForNotify } from "./chunk.js";
 const PORT = process.env.NOTIFY_MCP_PORT ? parseInt(process.env.NOTIFY_MCP_PORT) : 3737;
 const BASE = `http://localhost:${PORT}`;
 const CLEAN_ID = (s) => s.toLowerCase().replace(/[^a-z0-9_-]/g, "");
+const BRIDGE_VERSION = (() => {
+    const manifest = join(dirname(fileURLToPath(import.meta.url)), "..", "package.json");
+    // An absent manifest is a legitimate state for a bridge-only copy and renders
+    // `unversioned`; a manifest present but unreadable throws.
+    if (!existsSync(manifest)) {
+        stderr(`[bridge] no manifest at ${manifest}, so this copy cannot name the build it is — a bridge-only copy has nothing to read. Install the server package, or start the server another way; the bridge still works, it just cannot say which version it is.`);
+        return "unversioned";
+    }
+    return JSON.parse(readFileSync(manifest, "utf8")).version;
+})();
 // NOTIFY_MCP_TAG is the explicit per-window name; otherwise derive from the
 // workspace Claude Code passes (CLAUDE_PROJECT_DIR) — falling back to the launch
 // dir — and walk up to the nearest meaningful folder, skipping generic launcher/
@@ -120,16 +134,18 @@ function spawnUiServerIfNeeded() {
     ];
     const uiPath = candidates.find(p => existsSync(p));
     if (!uiPath) {
-        stderr(`[bridge] could not locate ui/server.js near ${here} — skipping auto-spawn`);
-        return;
+        stderr(`[bridge] no ui/server.js beside this bridge at ${here}, so there is nothing here to spawn — a bridge-only copy (the VS Code extension mirrors the bridge alone). Start a server with 'npx -y omni-notify-mcp' or the extension's Start Server command, or install the package so the server ships beside the bridge.`);
+        return false;
     }
     stderr(`[bridge] auto-spawning UI server: ${uiPath}`);
     const child = spawn(process.execPath, [uiPath], {
         detached: true,
         stdio: "ignore",
+        windowsHide: true,
         env: { ...process.env, PORT: String(PORT), ENABLE_MCP: "1" },
     });
     child.unref();
+    return true;
 }
 async function waitForServer(maxMs = 15_000) {
     const deadline = Date.now() + maxMs;
@@ -147,6 +163,16 @@ function stderr(line) {
     }
     catch { /* ignore */ }
 }
+// A transport failure must NAME THE HOP — `fetch` reports a bare "fetch failed" with no host, port or cause, which is the exact string that hid a dead channel for ten minutes (#752). Do not simplify this back to `throw err`.
+function unreachable(url, err) {
+    const cause = err?.cause;
+    const code = cause && typeof cause === "object" && "code" in cause
+        ? String(cause.code)
+        : undefined;
+    const why = code === "ECONNREFUSED" ? `nothing is listening on ${new URL(url).host}`
+        : code ?? (err instanceof Error ? err.message : String(err));
+    return new Error(`${url} is unreachable: ${why}`, { cause: err });
+}
 // ── 2. HTTP /mcp session — the bridge itself is an MCP client of the server ──
 // We run a single persistent MCP-over-HTTP session per bridge process and
 // forward every local stdio tool call through it. Using one shared session
@@ -154,68 +180,122 @@ function stderr(line) {
 // draining all consistent with what the HTTP server sees.
 let httpSessionId;
 let httpRpcId = 1;
-async function httpRpc(method, params, isNotification = false) {
-    // JSON-RPC notifications (method name starts with `notifications/` or the
-    // caller says so) carry no `id` and get no response. Spec-compliant servers
-    // return 202 Accepted with empty body.
-    const notif = isNotification || method.startsWith("notifications/");
-    const body = { jsonrpc: "2.0", method, params: params ?? {} };
-    if (!notif)
-        body.id = httpRpcId++;
+let handshake;
+async function postToMcp(body, sid) {
     const headers = {
         "Content-Type": "application/json",
         "Accept": "application/json, text/event-stream",
     };
-    if (httpSessionId)
-        headers["mcp-session-id"] = httpSessionId;
-    const r = await fetch(`${BASE}/mcp${MCP_QUERY}`, {
-        method: "POST",
-        headers,
-        body: JSON.stringify(body),
-        // Long-poll tools may block up to ~55s server-side. Give the fetch
-        // generous headroom but not infinite, so a wedged server surfaces fast.
-        signal: AbortSignal.timeout(120_000),
-    });
-    // The server returns 404 when our cached session is stale (spec-compliant
-    // behavior after a server restart). Clear and retry once with a fresh init.
-    if (r.status === 404 && httpSessionId) {
-        httpSessionId = undefined;
-        await httpInitialize();
-        return httpRpc(method, params, isNotification);
+    if (sid)
+        headers["mcp-session-id"] = sid;
+    const url = `${BASE}/mcp${MCP_QUERY}`;
+    let r;
+    try {
+        r = await fetch(url, {
+            method: "POST",
+            headers,
+            body: JSON.stringify(body),
+            // Long-poll tools may block up to ~55s server-side. Give the fetch
+            // generous headroom but not infinite, so a wedged server surfaces fast.
+            signal: AbortSignal.timeout(120_000),
+        });
+    }
+    catch (err) {
+        throw unreachable(url, err);
     }
     if (r.status >= 500) {
         throw new Error(`HTTP ${r.status} from /mcp: ${await r.text().catch(() => "")}`);
     }
-    const sid = r.headers.get("mcp-session-id");
-    if (sid && !httpSessionId)
-        httpSessionId = sid;
-    if (notif)
-        return undefined;
-    const ctype = r.headers.get("content-type") ?? "";
     const raw = await r.text();
+    const answer = { status: r.status, sessionId: r.headers.get("mcp-session-id") ?? undefined, raw };
+    if (!raw)
+        return answer;
+    const ctype = r.headers.get("content-type") ?? "";
     if (ctype.includes("application/json")) {
-        return JSON.parse(raw);
+        answer.json = JSON.parse(raw);
+        return answer;
     }
     // SSE framing: pull the first data: line as the JSON-RPC response.
     for (const line of raw.split(/\r?\n/)) {
         if (line.startsWith("data:")) {
             const json = line.slice(5).trim();
-            if (json)
-                return JSON.parse(json);
+            if (json) {
+                answer.json = JSON.parse(json);
+                return answer;
+            }
         }
     }
-    throw new Error(`unexpected response from /mcp: ${raw.slice(0, 200)}`);
+    return answer;
 }
-async function httpInitialize() {
-    const res = await httpRpc("initialize", {
-        protocolVersion: "2024-11-05",
-        capabilities: {},
-        clientInfo: { name: CLIENT_NAME, version: "1.0" },
-    });
-    if (res?.error)
-        throw new Error(`initialize failed: ${JSON.stringify(res.error)}`);
-    // Follow-up: the spec requires a notifications/initialized after initialize.
-    await httpRpc("notifications/initialized").catch(() => { });
+function sessionWasRefused(answer) {
+    return answer.status === 404 || (answer.status === 400 && answer.json?.error?.code === -32000);
+}
+function sessionRefusal(answer) {
+    if (answer.json?.error === "mcp_disabled") {
+        return new Error(`${BASE}/mcp cannot carry a message: the server has its MCP endpoint DISABLED (start it with ENABLE_MCP=1)`);
+    }
+    const said = answer.json?.error ? JSON.stringify(answer.json.error) : answer.raw.slice(0, 200);
+    return new Error(`${BASE}/mcp refused the session (HTTP ${answer.status}): ${said}`);
+}
+async function liveSession() {
+    const current = httpSessionId;
+    if (current)
+        return current;
+    handshake ??= openSession();
+    return handshake;
+}
+async function openSession() {
+    try {
+        const res = await postToMcp({
+            jsonrpc: "2.0",
+            id: httpRpcId++,
+            method: "initialize",
+            params: {
+                protocolVersion: "2024-11-05",
+                capabilities: {},
+                clientInfo: { name: CLIENT_NAME, version: "1.0" },
+            },
+        }, undefined);
+        if (res.json?.error)
+            throw sessionRefusal(res);
+        const sid = res.sessionId;
+        if (!sid)
+            throw new Error(`/mcp answered initialize with no session id (HTTP ${res.status}): ${res.raw.slice(0, 200)}`);
+        httpSessionId = sid;
+        // Follow-up: the spec requires a notifications/initialized after initialize.
+        await postToMcp({ jsonrpc: "2.0", method: "notifications/initialized" }, sid);
+        return sid;
+    }
+    finally {
+        handshake = undefined;
+    }
+}
+async function httpRpc(method, params, isNotification = false) {
+    // JSON-RPC notifications (method name starts with `notifications/` or the
+    // caller says so) carry no `id` and get no response. Spec-compliant servers
+    // return 202 Accepted with empty body.
+    const notif = isNotification || method.startsWith("notifications/");
+    return sendOverSession(method, params, notif, false);
+}
+async function sendOverSession(method, params, notif, rehandshaken) {
+    const sid = await liveSession();
+    const body = { jsonrpc: "2.0", method, params: params ?? {} };
+    if (!notif)
+        body.id = httpRpcId++;
+    const answer = await postToMcp(body, sid);
+    if (sessionWasRefused(answer)) {
+        if (httpSessionId === sid)
+            httpSessionId = undefined;
+        if (rehandshaken) {
+            throw sessionRefusal(answer);
+        }
+        return sendOverSession(method, params, notif, true);
+    }
+    if (notif)
+        return undefined;
+    if (!answer.json)
+        throw new Error(`unexpected response from /mcp: ${answer.raw.slice(0, 200)}`);
+    return answer.json;
 }
 // Periodically touch our /mcp session so the server's reaper doesn't prune it.
 // Without this, the bridge opens a session on startup, proxies tool calls
@@ -233,7 +313,7 @@ function startSessionKeepalive() {
     }, 30_000);
 }
 // ── 3. Stdio MCP server — the thing Claude Code / Cursor attaches to ─────────
-const server = new McpServer({ name: "notify-mcp", version: "1.2.0" }, {
+const server = new McpServer({ name: "notify-mcp", version: BRIDGE_VERSION }, {
     // Declare the claude/channel capability so Claude Code knows to surface
     // our notifications/claude/channel events as synthetic user turns. The
     // `reply` tool below is how Claude hands the agent's response back to us.
@@ -291,17 +371,52 @@ async function proxyToolCall(name, args) {
     }
     return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }] };
 }
+async function deliverOverAgentApi(message, priority, mcpFailure) {
+    const headers = { "Content-Type": "application/json" };
+    const key = (process.env.NOTIFY_AGENT_KEY ?? "").trim();
+    if (key)
+        headers["x-notify-key"] = key;
+    const tagPrefix = SESSION_TAG ? `[${SESSION_TAG}] ` : "";
+    const agentUrl = `${BASE}/api/agent/notify`;
+    const failed = (detail) => ({
+        content: [{ type: "text", text: `NOT DELIVERED — outcome=failed; neither door carried it: ${mcpFailure}; ${detail}` }],
+        isError: true,
+    });
+    try {
+        const r = await fetch(agentUrl, {
+            method: "POST",
+            headers,
+            body: JSON.stringify({ message: `${tagPrefix}${message}`, priority }),
+            signal: AbortSignal.timeout(120_000),
+        });
+        const out = await r.json().catch(() => undefined);
+        if (out?.outcome !== "delivered") {
+            return failed(`${agentUrl} answered HTTP ${r.status} ${JSON.stringify(out ?? {})}`);
+        }
+        stderr(`[bridge] /mcp could not carry a notify (${mcpFailure}); delivered over /api/agent/notify instead`);
+        return {
+            content: [{
+                    type: "text",
+                    text: `outcome=delivered attempted=[${(out.attempted ?? []).join(", ")}] delivered=[${(out.delivered ?? []).join(", ")}]`,
+                }],
+        };
+    }
+    catch (err) {
+        return failed(unreachable(agentUrl, err).message);
+    }
+}
 async function sendNotifyChunked(message, priority) {
     const chunks = splitForNotify(message);
     if (chunks.length === 1)
         return proxyToolCall("notify", { message, priority });
+    // Every chunk is sent, and the ANSWER is composed from all of them — a chunk
+    // that reached nobody must not short-circuit the report into one chunk's text,
+    // losing how many of how many failed (#774: the server now flags such a result
+    // as an error itself, so a short-circuit here would swallow the summary).
     const results = [];
     for (const chunk of chunks) {
         results.push(await proxyToolCall("notify", { message: chunk, priority }));
     }
-    const failed = results.find(r => r.isError);
-    if (failed)
-        return failed;
     const texts = results.map(r => r.content?.[0]?.text ?? "");
     const inboxMarker = "⚠️ USER SENT YOU A MESSAGE";
     const inboxBlocks = texts
@@ -343,7 +458,15 @@ server.tool("notify", "Send a notification to the user. Delivery channels and DN
     "delivered in order. Never truncate to fit a part.", {
     message: z.string().max(5000),
     priority: z.enum(["low", "normal", "high"]).default("normal"),
-}, async ({ message, priority }) => sendNotifyChunked(message, priority));
+}, async ({ message, priority }) => {
+    try {
+        return await sendNotifyChunked(message, priority);
+    }
+    catch (err) {
+        // OWNER: a notification the user never sees is the whole defect this tool exists to prevent, so a /mcp transport failure must not end the send — the same server's /api/agent/notify door carries no session and finishes it, and the server's own log stream records the outcome either way.
+        return deliverOverAgentApi(message, priority, err instanceof Error ? err.message : String(err));
+    }
+});
 server.tool("ask", "Send a question to the user and wait for their reply.", {
     question: z.string().max(500),
     timeout_seconds: z.number().min(30).max(3600).default(300),
@@ -379,7 +502,13 @@ server.tool("reply", "Reply to the user's most recent channel message. Routes th
     priority: z.enum(["low", "normal", "high"]).default("normal"),
 }, async ({ message, priority }) => {
     const tagPrefix = SESSION_TAG ? `[@${SESSION_TAG}] ` : "";
-    return sendNotifyChunked(`${tagPrefix}${message}`, priority);
+    try {
+        return await sendNotifyChunked(`${tagPrefix}${message}`, priority);
+    }
+    catch (err) {
+        // OWNER: the user is waiting on this reply over the channel they are reading, so a /mcp transport failure must not end it — the same server's /api/agent/notify door carries no session and finishes it, and the server's own log stream records the outcome either way.
+        return deliverOverAgentApi(message, priority, err instanceof Error ? err.message : String(err));
+    }
 });
 async function subscribeInbox() {
     const tagQuery = SESSION_TAG ? `?tag=${encodeURIComponent(SESSION_TAG)}` : "";
@@ -413,12 +542,20 @@ async function subscribeInbox() {
                         const payload = line.slice(5).trim();
                         if (!payload)
                             continue;
+                        let entry;
                         try {
-                            const entry = JSON.parse(payload);
-                            await emitChannelEvent(entry);
+                            entry = JSON.parse(payload);
                         }
                         catch (err) {
                             stderr(`[bridge] bad SSE payload: ${err instanceof Error ? err.message : String(err)}`);
+                            continue;
+                        }
+                        // OWNER: ITER/LOOP — one frame that cannot be emitted must not end the stream, so this frame reports itself with its own cause and the next one is read.
+                        try {
+                            await emitChannelEvent(entry);
+                        }
+                        catch (err) {
+                            stderr(`[bridge] channel notification NOT DELIVERED: ${err instanceof Error ? err.message : String(err)}`);
                         }
                     }
                 }
@@ -432,25 +569,15 @@ async function subscribeInbox() {
     }
 }
 async function emitChannelEvent(entry) {
-    // Emit the new Claude Code Channels notification *and* the generic
-    // `notifications/message` as a belt-and-suspenders approach: hosts that
-    // ignore `notifications/claude/channel` may still surface the message as
-    // a log line. Both are fire-and-forget; a failure just means the peer
-    // closed the stdio transport (we'll notice on the next tool call).
+    // Emit the new Claude Code Channels notification; `wait_for_inbox` remains the universal fallback for a host that does not carry it.
     const content = entry.tag ? `[@${entry.tag}] ${entry.text}` : entry.text;
-    try {
-        await server.server.notification({
-            method: "notifications/claude/channel",
-            params: {
-                content,
-                meta: { ts: entry.ts, tag: entry.tag ?? null, source: "notify-mcp" },
-            },
-        });
-    }
-    catch {
-        // client doesn't support the experimental capability — that's fine,
-        // wait_for_inbox is the universal fallback.
-    }
+    await server.server.notification({
+        method: "notifications/claude/channel",
+        params: {
+            content,
+            meta: { ts: entry.ts, tag: entry.tag ?? null, source: "notify-mcp" },
+        },
+    });
 }
 // ── 5. Wire it up ────────────────────────────────────────────────────────────
 // When the parent (claude.exe / Cursor / Codex) dies, the OS closes our stdin
@@ -480,17 +607,14 @@ async function shutdownOnPeerLoss(why) {
 }
 async function main() {
     if (!(await serverIsUp())) {
-        spawnUiServerIfNeeded();
+        const spawned = spawnUiServerIfNeeded();
         if (!(await waitForServer())) {
-            stderr(`[bridge] HTTP server at ${BASE} did not come up within 15s — giving up on push; tool calls will fail.`);
+            stderr(spawned
+                ? `[bridge] HTTP server at ${BASE} did not come up within 15s of being spawned — giving up on push; tool calls will fail.`
+                : `[bridge] no HTTP server at ${BASE} and none was spawned (see above) — giving up on push; tool calls will fail.`);
         }
     }
-    try {
-        await httpInitialize();
-    }
-    catch (err) {
-        stderr(`[bridge] initial HTTP initialize failed: ${err instanceof Error ? err.message : String(err)}`);
-    }
+    await liveSession().catch(err => stderr(`[bridge] initial /mcp handshake failed: ${err instanceof Error ? err.message : String(err)} — the next tool call handshakes again`));
     // Fire-and-forget: the stdio transport should be usable immediately; the
     // push channel attaches as soon as the SSE handshake completes.
     subscribeInbox().catch(err => stderr(`[bridge] inbox subscriber crashed: ${err instanceof Error ? err.message : String(err)}`));