omni-notify-mcp 1.3.12 → 1.3.14

package/README.md

@@ -13,7 +13,7 @@
 
 <p align="center">
   <a href="https://www.npmjs.com/package/omni-notify-mcp"><img src="https://img.shields.io/npm/v/omni-notify-mcp.svg" alt="npm"></a>
-  <a href="https://marketplace.visualstudio.com/items?itemName=MeniHillel.omni-notify-mcp"><img src="https://img.shields.io/visual-studio-marketplace/v/MeniHillel.omni-notify-mcp?label=marketplace" alt="VS Code Marketplace"></a>
+  <a href="https://marketplace.visualstudio.com/items?itemName=Karish911.omni-notify-mcp"><img src="https://img.shields.io/visual-studio-marketplace/v/Karish911.omni-notify-mcp?label=marketplace" alt="VS Code Marketplace"></a>
   <img src="https://img.shields.io/badge/license-MIT-4ea3ff.svg" alt="MIT license">
   <img src="https://img.shields.io/badge/MCP-compatible-4ea3ff.svg" alt="MCP compatible">
 </p>
@@ -110,6 +110,11 @@ Subscribe to `GET /api/inbox/stream` (text/event-stream) to receive unsolicited
 ### Multi-session tagging
 Run multiple agents against the same notify server (e.g. one Claude session in `repo-a`, another in `repo-b`). Each connects with `?tag=<name>` and the user can route a Telegram message to a specific agent by prefixing `@<name>`. Untagged messages broadcast to every session.
 
+The stdio bridge derives its tag as `<hostname>-<workspace-folder>` unless you override it with the **`NOTIFY_MCP_TAG`** env var — set it to give a bridge a durable, human-meaningful name (e.g. `NOTIFY_MCP_TAG=frontend`). This is the only stable per-bridge name: Claude Code exposes no per-session id to MCP subprocesses, so two extension panels on the *same* workspace share a tag by default.
+
+### Multiple panels in one window
+Open N Claude extension panels in one VS Code window and each spawns its own bridge → its own MCP session. They share a tag (same host + workspace), but `/api/clients` lists each as a separate logical client (one per panel), disambiguated by an auto-suffixed id (`foo`, `foo-2`, …) plus `panel <n>/<total>` and a short session id. `list clients` annotates the panel count. To give a panel its own durable identity instead of an ordinal, launch it with a distinct `NOTIFY_MCP_TAG`.
+
 ### Do Not Disturb
 - **Manual toggle** — flip it on, all `priority < high` notifs drop on the floor.
 - **Scheduled quiet hours** — e.g. 22:00 → 08:00, configurable per-day.

package/config.example.json

@@ -1,26 +1,33 @@
-{
-  "desktop": {
-    "enabled": true
-  },
-  "whatsapp": {
-    "enabled": true,
-    "phone": "+1234567890",
-    "apikey": "YOUR_CALLMEBOT_APIKEY"
-  },
-  "sms": {
-    "enabled": true,
-    "accountSid": "YOUR_TWILIO_ACCOUNT_SID",
-    "authToken": "YOUR_TWILIO_AUTH_TOKEN",
-    "from": "+1YOUR_TWILIO_NUMBER",
-    "to": "+1YOUR_PERSONAL_NUMBER"
-  },
-  "email": {
-    "enabled": true,
-    "host": "smtp.gmail.com",
-    "port": 587,
-    "secure": false,
-    "user": "your-email@gmail.com",
-    "pass": "YOUR_GMAIL_APP_PASSWORD",
-    "to": "your-email@gmail.com"
-  }
-}
+{
+  "desktop": {
+    "enabled": true
+  },
+  "telegram": {
+    "enabled": true,
+    "token": "YOUR_BOT_TOKEN",
+    "chatIds": ["123456789", "-1009876543210"]
+  },
+  "sms": {
+    "enabled": true,
+    "accessKeyId": "YOUR_AWS_ACCESS_KEY_ID",
+    "secretAccessKey": "YOUR_AWS_SECRET_ACCESS_KEY",
+    "region": "us-east-1",
+    "originationNumber": "+1YOUR_AWS_ORIGINATION_NUMBER",
+    "to": ["+1YOUR_PERSONAL_NUMBER", "+1ANOTHER_NUMBER"]
+  },
+  "slack": {
+    "enabled": true,
+    "botToken": "xoxb-YOUR-BOT-TOKEN",
+    "channels": ["C0123456789", "C0987654321"],
+    "webhookUrl": ""
+  },
+  "email": {
+    "enabled": true,
+    "host": "smtp.gmail.com",
+    "port": 587,
+    "secure": false,
+    "user": "your-email@gmail.com",
+    "pass": "YOUR_GMAIL_APP_PASSWORD",
+    "to": "your-email@gmail.com"
+  }
+}

package/dist/channels/slack.js

@@ -3,22 +3,33 @@ export async function sendSlack(config, message, priority = "normal", title = "C
     if (!config.enabled)
         return;
     const emoji = EMOJI_MAP[priority] ?? EMOJI_MAP.normal;
+    const blocks = [
+        { type: "section", text: { type: "mrkdwn", text: `${emoji} *${title}*\n${message}` } },
+        { type: "context", elements: [{ type: "mrkdwn", text: `Priority: ${priority} · <!date^${Math.floor(Date.now() / 1000)}^{time}|now>` }] },
+    ];
+    if (config.botToken && config.channels?.length) {
+        const errors = [];
+        let sent = 0;
+        for (const channel of config.channels) {
+            const res = await fetch("https://slack.com/api/chat.postMessage", {
+                method: "POST",
+                headers: { "Content-Type": "application/json", Authorization: `Bearer ${config.botToken}` },
+                body: JSON.stringify({ channel, text: `${emoji} *${title}*`, blocks }),
+            });
+            const json = await res.json().catch(() => ({}));
+            if (res.ok && json.ok)
+                sent++;
+            else
+                errors.push(`${channel}: ${json.error ?? res.status}`);
+        }
+        if (sent === 0 && errors.length)
+            throw new Error(`Slack error — ${errors.join("; ")}`);
+        return;
+    }
     const res = await fetch(config.webhookUrl, {
         method: "POST",
         headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({
-            text: `${emoji} *${title}*`,
-            blocks: [
-                {
-                    type: "section",
-                    text: { type: "mrkdwn", text: `${emoji} *${title}*\n${message}` },
-                },
-                {
-                    type: "context",
-                    elements: [{ type: "mrkdwn", text: `Priority: ${priority} · <!date^${Math.floor(Date.now() / 1000)}^{time}|now>` }],
-                },
-            ],
-        }),
+        body: JSON.stringify({ text: `${emoji} *${title}*`, blocks }),
     });
     if (!res.ok)
         throw new Error(`Slack ${res.status}: ${await res.text()}`);

package/dist/channels/sms.js

@@ -1,7 +1,27 @@
-import twilio from "twilio";
+import { PinpointSMSVoiceV2Client, SendTextMessageCommand } from "@aws-sdk/client-pinpoint-sms-voice-v2";
 export async function sendSms(config, message) {
     if (!config.enabled)
         return;
-    const client = twilio(config.accountSid, config.authToken);
-    await client.messages.create({ body: message, from: config.from, to: config.to });
+    const client = new PinpointSMSVoiceV2Client({
+        region: config.region,
+        credentials: { accessKeyId: config.accessKeyId, secretAccessKey: config.secretAccessKey },
+    });
+    const errors = [];
+    let sent = 0;
+    const e164 = (s) => String(s ?? "").replace(/[^\d+]/g, "");
+    for (const to of config.to ?? []) {
+        try {
+            await client.send(new SendTextMessageCommand({
+                DestinationPhoneNumber: e164(to),
+                OriginationIdentity: e164(config.originationNumber) || undefined,
+                MessageBody: message,
+            }));
+            sent++;
+        }
+        catch (err) {
+            errors.push(`${to}: ${err instanceof Error ? err.message : String(err)}`);
+        }
+    }
+    if (sent === 0 && errors.length)
+        throw new Error(`SMS error — ${errors.join("; ")}`);
 }

package/dist/channels/telegram.js

@@ -1,11 +1,19 @@
 export async function sendTelegram(config, message) {
     if (!config.enabled)
         return;
-    const res = await fetch(`https://api.telegram.org/bot${config.token}/sendMessage`, {
-        method: "POST",
-        headers: { "Content-Type": "application/json" },
-        body: JSON.stringify({ chat_id: config.chatId, text: message }),
-    });
-    if (!res.ok)
-        throw new Error(`Telegram error ${res.status}: ${await res.text()}`);
+    const errors = [];
+    let sent = 0;
+    for (const chatId of config.chatIds ?? []) {
+        const res = await fetch(`https://api.telegram.org/bot${config.token}/sendMessage`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({ chat_id: chatId, text: message }),
+        });
+        if (res.ok)
+            sent++;
+        else
+            errors.push(`${chatId}: ${res.status} ${await res.text()}`);
+    }
+    if (sent === 0 && errors.length)
+        throw new Error(`Telegram error — ${errors.join("; ")}`);
 }

package/dist/chunk.js

@@ -0,0 +1,37 @@
+export const NOTIFY_CHUNK_LIMIT = 500;
+function packChunks(message, body, wordAware) {
+    const chunks = [];
+    let rest = message;
+    while (rest.length > body) {
+        let cut = body;
+        if (wordAware) {
+            const window = rest.slice(0, body + 1);
+            const brk = Math.max(window.lastIndexOf(" "), window.lastIndexOf("\n"));
+            if (brk >= Math.floor(body * 0.6))
+                cut = brk;
+        }
+        chunks.push(rest.slice(0, cut).replace(/\s+$/, ""));
+        rest = rest.slice(cut).replace(/^\s+/, "");
+    }
+    if (rest.length)
+        chunks.push(rest);
+    return chunks;
+}
+export function splitForNotify(message, limit = NOTIFY_CHUNK_LIMIT) {
+    if (message.length <= limit)
+        return [message];
+    let parts = Math.ceil(message.length / limit);
+    for (;;) {
+        const reserve = `(${parts}/${parts}) `.length;
+        const needed = Math.ceil(message.length / Math.max(1, limit - reserve));
+        if (needed <= parts)
+            break;
+        parts = needed;
+    }
+    const body = Math.max(1, limit - `(${parts}/${parts}) `.length);
+    let chunks = packChunks(message, body, true);
+    if (chunks.length > parts)
+        chunks = packChunks(message, body, false);
+    const total = chunks.length;
+    return chunks.map((chunk, i) => `(${i + 1}/${total}) ${chunk}`);
+}

package/dist/index.js

@@ -31,13 +31,16 @@ import { join, dirname, basename } from "path";
 import { hostname } from "os";
 import { fileURLToPath } from "url";
 import { z } from "zod";
+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, "");
-// NOTIFY_MCP_TAG is the explicit per-window name; otherwise use the nearest
-// meaningful working-dir folder, skipping generic launcher/tool/system dirs so a
-// bridge spawned from an editor's launch dir names itself after the project
-// (e.g. "bullseyenotify"), never the host ("claude-code").
+// 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/
+// tool/system dirs so each window names itself after its project (e.g.
+// "bullseyenotify" / "alphawave"), never the host ("claude-code"). Using
+// CLAUDE_PROJECT_DIR is what lets one globally-wired bridge self-tag per window.
 function deriveVscId() {
     const explicit = CLEAN_ID(process.env.NOTIFY_MCP_TAG ?? "");
     if (explicit)
@@ -47,7 +50,8 @@ function deriveVscId() {
         "bin", "dist", "build", "src", "out", "node_modules",
         "windows", "system32", "users", "appdata", "roaming", "local", "programs", "temp", "tmp",
     ]);
-    let dir = process.cwd();
+    const root = process.env.CLAUDE_PROJECT_DIR || process.cwd();
+    let dir = root;
     for (let i = 0; i < 5; i++) {
         const name = CLEAN_ID(basename(dir));
         if (name && !generic.has(name))
@@ -57,11 +61,38 @@ function deriveVscId() {
             break;
         dir = parent;
     }
-    return CLEAN_ID(basename(process.cwd())) || "agent";
+    return CLEAN_ID(basename(root)) || "agent";
 }
 const VSC_ID = deriveVscId();
-const SESSION_TAG = `${hostname().toLowerCase().replace(/[^a-z0-9_-]/g, "")}-${VSC_ID}`;
+// In the VS Code extension Claude Code does NOT set CLAUDE_PROJECT_DIR for MCP
+// servers, and the bridge's cwd is shared across windows (VSCODE_CWD), so the
+// project name alone collapses every window to one tag. When no explicit tag /
+// project dir was provided, append a short stable hash of CLAUDE_CODE_SESSION_ID
+// (shared by a session + its subagents → they still fold) so each window is a
+// distinct client. The extension supplies the readable workspace name separately.
+const SESSION_SUFFIX = (() => {
+    if (process.env.NOTIFY_MCP_TAG || process.env.CLAUDE_PROJECT_DIR)
+        return "";
+    const sid = (process.env.CLAUDE_CODE_SESSION_ID || "").replace(/[^a-zA-Z0-9]/g, "").toLowerCase();
+    return sid ? `-${sid.slice(0, 6)}` : "";
+})();
+const SESSION_TAG = `${hostname().toLowerCase().replace(/[^a-z0-9_-]/g, "")}-${VSC_ID}${SESSION_SUFFIX}`;
 const CLIENT_NAME = "claude-channel-bridge";
+// CLAUDE_CODE_SESSION_ID is shared by an interactive Claude session AND every
+// subagent (Task tool) it spawns — a spawned subagent inherits the parent's id
+// verbatim. Reporting it lets the server fold a main session + its subagents
+// into one interactive panel, so subagents don't inflate the clients tab. Empty
+// for non-Claude-Code hosts (Cursor/Codex) — those stay one-panel-per-bridge.
+const HOST_SESSION_ID = (process.env.CLAUDE_CODE_SESSION_ID || "").replace(/[^a-zA-Z0-9_-]/g, "");
+const MCP_QUERY = (() => {
+    const p = new URLSearchParams();
+    if (SESSION_TAG)
+        p.set("tag", SESSION_TAG);
+    if (HOST_SESSION_ID)
+        p.set("hsid", HOST_SESSION_ID);
+    const s = p.toString();
+    return s ? `?${s}` : "";
+})();
 // ── 1. Ensure the HTTP server is up ───────────────────────────────────────────
 async function serverIsUp() {
     try {
@@ -137,8 +168,7 @@ async function httpRpc(method, params, isNotification = false) {
     };
     if (httpSessionId)
         headers["mcp-session-id"] = httpSessionId;
-    const tagQuery = SESSION_TAG ? `?tag=${encodeURIComponent(SESSION_TAG)}` : "";
-    const r = await fetch(`${BASE}/mcp${tagQuery}`, {
+    const r = await fetch(`${BASE}/mcp${MCP_QUERY}`, {
         method: "POST",
         headers,
         body: JSON.stringify(body),
@@ -229,15 +259,14 @@ const server = new McpServer({ name: "notify-mcp", version: "1.2.0" }, {
         "shorten it with '…' or a summary. NEVER mention delivery channels (Telegram, " +
         "SMS, desktop, etc.) or echo 'Sent via: …' — those are server internals. " +
         "Say 'notif' or 'notification' if you need to refer to the act of notifying.\n\n" +
-        "🚨 500-CHAR LIMIT — CHUNK, NEVER TRUNCATE 🚨\n" +
-        "The `notify` tool rejects bodies > 500 chars with `MCP error -32602: too_big`. " +
-        "When you have more to say than fits in 500 chars, you MUST split into MULTIPLE " +
-        "notify calls — do NOT silently shorten the body. Procedure: (1) decide what " +
-        "the user MUST see (every fact, file path, line number, recommendation); (2) if " +
-        "the body exceeds 500 chars, split into N chunks numbered '(1/N) ...', '(2/N) ...', " +
-        "each ≤ 500 chars including the prefix; (3) send all N chunks in order via separate " +
-        "notify calls and echo all N IN FULL in chat. NEVER respond to a `too_big` error by " +
-        "shortening to a single chunk — that loses information the user explicitly needs.\n\n" +
+        "🚨 NEVER TRUNCATE — THE SERVER CHUNKS FOR YOU 🚨\n" +
+        "Send the COMPLETE message (up to 5000 chars) in a single `notify` call. Bodies over " +
+        "500 chars are automatically split server-side into numbered '(1/N) ...', '(2/N) ...' " +
+        "chunks (each ≤500 chars) and delivered in order — you no longer hand-split, and a " +
+        "`too_big` error only fires past the 5000-char cap. Decide what the user MUST see " +
+        "(every fact, file path, line number, recommendation), send it all in one call, and " +
+        "echo it IN FULL in chat. NEVER shorten or summarize to fit — that loses information " +
+        "the user explicitly needs.\n\n" +
         "When the user asks you to remember a behavioral rule or change how you should act, " +
         "call `update_instructions` with the full updated rules block. This writes to CLAUDE.md " +
         "so the instructions persist across sessions and context compaction.",
@@ -256,13 +285,46 @@ async function proxyToolCall(name, args) {
     }
     return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }] };
 }
+async function sendNotifyChunked(message, priority) {
+    const chunks = splitForNotify(message);
+    if (chunks.length === 1)
+        return proxyToolCall("notify", { message, priority });
+    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
+        .map(t => { const i = t.indexOf(inboxMarker); return i === -1 ? null : t.slice(i); })
+        .filter((b) => b !== null);
+    const inboxSuffix = inboxBlocks.length ? `\n\n${inboxBlocks.join("\n\n")}` : "";
+    const delivered = texts.filter(t => t.includes("Sent via:")).length;
+    const n = chunks.length;
+    let summary;
+    if (delivered === n) {
+        summary = `Delivered as ${n} chunks (${message.length} chars).`;
+    }
+    else {
+        const stripInbox = (t) => { const i = t.indexOf(inboxMarker); return (i === -1 ? t : t.slice(0, i)).trim(); };
+        const failedSummaries = [...new Set(texts.filter(t => !t.includes("Sent via:")).map(stripInbox))];
+        const said = failedSummaries.map(s => `"${s}"`).join(", ");
+        summary = delivered === 0
+            ? `Suppressed — 0 of ${n} chunks reached any channel. Server said: ${said}`
+            : `Delivered ${delivered}/${n} chunks (${message.length} chars); ${n - delivered} reached no channel — server said: ${said}.`;
+    }
+    return { content: [{ type: "text", text: `${summary}${inboxSuffix}` }] };
+}
 server.tool("notify", "Send a notification to the user. Delivery channels and DND are server-configured. " +
-    "MAX 500 CHARS PER MESSAGE. If you have more to say, split into multiple notify " +
-    "calls with '(1/N) ...', '(2/N) ...' prefixes — never silently shorten on " +
-    "`too_big` error; that loses information the user needs.", {
-    message: z.string().max(500),
+    "Messages over 500 chars are automatically split into numbered '(1/N) ...' chunks " +
+    "(each ≤500 chars) and delivered in order — send the full message in one call, never " +
+    "truncate. Hard cap 5000 chars.", {
+    message: z.string().max(5000),
     priority: z.enum(["low", "normal", "high"]).default("normal"),
-}, async (args) => proxyToolCall("notify", args));
+}, async ({ message, priority }) => sendNotifyChunked(message, priority));
 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),
@@ -292,7 +354,7 @@ 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 proxyToolCall("notify", { message: `${tagPrefix}${message}`, priority });
+    return sendNotifyChunked(`${tagPrefix}${message}`, priority);
 });
 async function subscribeInbox() {
     const tagQuery = SESSION_TAG ? `?tag=${encodeURIComponent(SESSION_TAG)}` : "";
@@ -366,6 +428,31 @@ async function emitChannelEvent(entry) {
     }
 }
 // ── 5. Wire it up ────────────────────────────────────────────────────────────
+// When the parent (claude.exe / Cursor / Codex) dies, the OS closes our stdin
+// pipe and the stdio transport reaches EOF. Without exiting here the bridge
+// lives on: startSessionKeepalive() keeps pinging /mcp every 30s, so the
+// server's lastSeen never goes stale and the 90s reaper never removes the
+// session — a closed window leaves a phantom "panel" in the clients tab
+// forever. On EOF we DELETE our /mcp session (instant server-side removal) and
+// exit so the panel disappears immediately.
+let shuttingDown = false;
+async function shutdownOnPeerLoss(why) {
+    if (shuttingDown)
+        return;
+    shuttingDown = true;
+    stderr(`[bridge] ${why} — closing /mcp session and exiting`);
+    if (httpSessionId) {
+        try {
+            await fetch(`${BASE}/mcp`, {
+                method: "DELETE",
+                headers: { "mcp-session-id": httpSessionId },
+                signal: AbortSignal.timeout(2000),
+            });
+        }
+        catch { /* server may already be gone; the reaper will clear it */ }
+    }
+    process.exit(0);
+}
 async function main() {
     if (!(await serverIsUp())) {
         spawnUiServerIfNeeded();
@@ -385,6 +472,10 @@ async function main() {
     startSessionKeepalive();
     const transport = new StdioServerTransport();
     await server.connect(transport);
+    // EOF on stdin = the parent process is gone. Tear down so we don't linger as
+    // an orphan heartbeating a phantom panel.
+    process.stdin.on("end", () => { void shutdownOnPeerLoss("stdin ended (parent gone)"); });
+    process.stdin.on("close", () => { void shutdownOnPeerLoss("stdin closed (parent gone)"); });
     stderr(`[bridge] stdio MCP bridge ready (tag=${SESSION_TAG ?? "none"}, port=${PORT})`);
 }
 main().catch(err => {

package/dist/ui/messaging/notificationEngine.js

@@ -19,12 +19,10 @@ export async function sendWithRouting(options) {
     if (mode.suppressedReason === "dnd") {
         return { delivered: [], errors: [], suppressedReason: "DND active" };
     }
-    if (mode.suppressedReason === "idle") {
-        return { delivered: [], errors: [], suppressedReason: "Idle gated while active" };
-    }
     const delivered = [];
     const errors = [];
-    const desktopOnly = mode.desktopOnly;
+    // Idle gating downgrades to desktop-only; Slack (vsc_notif channel-log) is exempt below.
+    const desktopOnly = mode.desktopOnly || mode.suppressedReason === "idle";
     const trySend = async (name, fn) => {
         if (!fn)
             return;
@@ -54,7 +52,7 @@ export async function sendWithRouting(options) {
     if (!desktopOnly && enableDiscord) {
         await trySend("discord", senders.discord ? () => senders.discord(message, priority) : undefined);
     }
-    if (!desktopOnly && enableSlack) {
+    if (enableSlack) {
         await trySend("slack", senders.slack ? () => senders.slack(message, priority) : undefined);
     }
     if (!desktopOnly && enableTeams) {