omni-notify-mcp 1.2.0 → 1.2.3

package/dist/channels/desktop.js

@@ -36,7 +36,7 @@ export async function speak(text, voice = DEFAULT_TTS_VOICE) {
     if (process.platform === "win32") {
         spawn("powershell", [
             "-NoProfile", "-Command",
-            `Add-Type -AssemblyName presentationCore; $p = New-Object System.Windows.Media.MediaPlayer; $p.Open([uri]'${audioFilePath.replace(/\\/g, "\\\\")}'); $p.Play(); Start-Sleep -Seconds 10`,
+            `Add-Type -AssemblyName presentationCore; $p = New-Object System.Windows.Media.MediaPlayer; $done = $false; Register-ObjectEvent $p MediaEnded -Action { $script:done = $true } | Out-Null; $p.Open([uri]'${audioFilePath.replace(/\\/g, "\\\\")}'); $p.Play(); while (-not $done) { Start-Sleep -Milliseconds 200 }`,
         ], { windowsHide: true, stdio: "ignore" });
     }
     else if (process.platform === "darwin") {

package/dist/index.js

@@ -171,7 +171,17 @@ const server = new McpServer({ name: "notify-mcp", version: "1.2.0" }, {
     instructions: "This is the stdio bridge for notify-mcp. It pushes unsolicited user " +
         "messages to the agent via `notifications/claude/channel` when the host " +
         "supports Channels (Claude Code v2.1.80+). Otherwise call `wait_for_inbox` " +
-        "as a long-poll to reliably receive user messages as tool results.",
+        "as a long-poll to reliably receive user messages as tool results.\n\n" +
+        "ALWAYS call `notify` when: (a) a task that took >60s of wall-clock time " +
+        "just finished (success or failure), (b) you have a question or need a " +
+        "decision, (c) something important happened the user needs to know right " +
+        "now. Idle/DND gating is handled server-side — fire notify and let the " +
+        "server decide routing. Err on the side of notifying: a wrong-call gets " +
+        "silently downgraded by idle gating; a missed notify costs the user hours.\n\n" +
+        "ALWAYS echo the COMPLETE, UNTRUNCATED message in your chat output — never " +
+        "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.",
 });
 // Thin proxy: forward a tool call to the HTTP server and return its content
 // block array verbatim. Error shape matches what the SDK expects from tool

package/dist/ui/server.js

@@ -181,7 +181,7 @@ async function speakText(text, voice) {
     if (process.platform === "win32") {
         spawn("powershell", [
             "-NoProfile", "-Command",
-            `Add-Type -AssemblyName presentationCore; $p = New-Object System.Windows.Media.MediaPlayer; $p.Open([uri]'${audioFilePath.replace(/\\/g, "\\\\")}'); $p.Play(); Start-Sleep -Seconds 10`,
+            `Add-Type -AssemblyName presentationCore; $p = New-Object System.Windows.Media.MediaPlayer; $done = $false; Register-ObjectEvent $p MediaEnded -Action { $script:done = $true } | Out-Null; $p.Open([uri]'${audioFilePath.replace(/\\/g, "\\\\")}'); $p.Play(); while (-not $done) { Start-Sleep -Milliseconds 200 }`,
         ], { windowsHide: true, stdio: "ignore" });
     }
     else if (process.platform === "darwin") {
@@ -558,11 +558,29 @@ app.get("/api/sessions", (_req, res) => {
         tag: s.tag,
         clientName: s.clientName,
         clientVersion: s.clientVersion,
+        workspaceName: s.workspaceName,
         host: s.host,
         connectedAt: s.connectedAt,
+        lastSeen: s.lastSeen,
     }));
     res.json({ sessions: list });
 });
+app.delete("/api/sessions/:clientId", (req, res) => {
+    const { clientId } = req.params;
+    const entry = Object.entries(sessions).find(([, m]) => m.clientId === clientId);
+    if (!entry) {
+        res.status(404).json({ error: "not found" });
+        return;
+    }
+    const [sessionId] = entry;
+    try {
+        httpTransports[sessionId]?.close();
+    }
+    catch { /* ignore */ }
+    delete httpTransports[sessionId];
+    delete sessions[sessionId];
+    res.json({ ok: true });
+});
 app.get("/api/logs", (req, res) => {
     res.setHeader("Content-Type", "text/event-stream");
     res.setHeader("Cache-Control", "no-cache");
@@ -1116,12 +1134,37 @@ channels are in use — just call 'notify' or 'ask' with a generic message.
 
 BEHAVIORAL RULES for every client that connects:
 
-1. Always call 'notify' for milestones, decisions, completions. The SERVER
-   handles all gating (DND, idle, channel routing). You do not need to
-   pre-flight with 'get_idle_seconds' — the server checks it itself and
-   downgrades the delivery automatically. When the user is active, the server
-   will play a local desktop sound+banner so they know something happened
-   (without blasting their phone). Just call 'notify'.
+1. ALWAYS call 'notify' in these three situations — idle or not, DND or not,
+   the server decides routing, you decide whether to fire:
+
+   (a) LONG PROCESSING FINISHED. Any single task that took more than ~60
+       seconds of wall-clock time (long build, test run, backtest, migration,
+       big refactor, multi-step plan) gets a 'notify' the moment it completes
+       — success OR failure. Rule of thumb: if the user could have reasonably
+       walked away to grab coffee while you ran, they need a ping on the way
+       back. Don't try to guess whether they were watching. Just notify.
+
+   (b) YOU HAVE A QUESTION OR NEED A DECISION. Any time you're about to ask
+       the user something — "should I delete these?", "which branch?",
+       "proceed with plan B?" — fire 'notify' (or 'ask' for blocking
+       two-way). Silent questions in the terminal get missed; a notification
+       does not.
+
+   (c) SOMETHING IMPORTANT HAPPENED that the user needs to know about right
+       now. Examples: a test suddenly failed after being green, a destructive
+       operation is about to run, you found a security issue, a deploy
+       succeeded, a production service looks degraded, you hit an
+       unrecoverable error. When in doubt on importance, ERR ON THE SIDE OF
+       NOTIFYING — the server's idle gating will automatically downgrade a
+       mis-judged 'normal' to a silent desktop banner if the user is active,
+       so the cost of over-notifying is near zero. The cost of missing a
+       real event is that the user finds out 4 hours later.
+
+   The SERVER handles all routing (DND, idle threshold, channel selection,
+   priority escalation). You do NOT need to pre-flight with
+   'get_idle_seconds' before these three triggers — fire 'notify' and let
+   the server decide. get_idle_seconds is the HEARTBEAT primitive (rule 6),
+   not a gate on legitimate milestones.
 
 2. Use priority correctly:
    - 'low'    = email only — for low-stakes status (background completion).
@@ -1130,13 +1173,18 @@ BEHAVIORAL RULES for every client that connects:
                 Use ONLY for catastrophic findings or decisions that block
                 progress. Misuse will train the user to ignore your notifs.
 
-3. Echo the full message body in your own chat / conversation output as well
-   as sending it through 'notify'. The user may be reading the terminal
-   directly; don't rely on them checking their phone / email.
+3. Echo the COMPLETE, UNTRUNCATED message body in your own chat / conversation
+   output as well as sending it through 'notify'. The user may be reading the
+   terminal directly; don't rely on them checking their phone / email. Do NOT
+   shorten, summarise, or cut off the message with "…" in your chat output —
+   show every word exactly as sent.
 
 4. The message body should be channel-agnostic. Never name 'Telegram', 'SMS',
-   'email', etc. in your messages — those are server delivery details the
-   user has already configured. Say 'notif' or 'notification' instead.
+   'email', 'desktop', etc. in your messages or in your chat output — those are
+   server delivery details the user has already configured and the client has
+   no business surfacing. Do NOT echo "Sent via: <channel list>" or any
+   variant of it. Just say 'notif' or 'notification' if you need to refer to
+   the act of notifying.
 
 5. When the user sends you an unsolicited message (visible as INBOX items in
    the 'notify' response, via 'poll', via 'wait_for_inbox', via
@@ -1231,7 +1279,9 @@ BEHAVIORAL RULES for every client that connects:
    MCP client is broken, you owe them the bypass — not an excuse.
 `.trim();
 function createMcpServer(clientId, sessionTag) {
-    const server = new McpServer({ name: "notify-mcp", version: "1.0.0" }, { instructions: MCP_INSTRUCTIONS });
+    const identity = sessionTag ? `@${sessionTag}` : clientId;
+    const identityLine = `\nYOUR SESSION IDENTITY: "${identity}" — use this as your prefix in all notify replies (e.g. "[${identity}] done with build").\n`;
+    const server = new McpServer({ name: "notify-mcp", version: "1.0.0" }, { instructions: identityLine + MCP_INSTRUCTIONS });
     server.tool("notify", "Send a notification to the user. Delivery channels and DND are server-configured. " +
         "Before calling, check get_idle_seconds against get_idle_config.thresholdSeconds; " +
         "skip the call if the user is active (unless priority='high'). " +
@@ -1475,14 +1525,16 @@ function sessionDisplay(s) {
     return s.tag ? `@${s.tag}` : s.clientId;
 }
 app.all("/mcp", async (req, res) => {
+    console.log("[debug-url]", req.method, req.url, "query:", JSON.stringify(req.query), "ua:", req.headers["user-agent"]);
     const existingSessionId = req.headers["mcp-session-id"];
     if (existingSessionId && httpTransports[existingSessionId]) {
-        await httpTransports[existingSessionId].handleRequest(req, res, req.body);
+        const transport = httpTransports[existingSessionId];
+        await transport.handleRequest(req, res, req.body);
         // Lazy-populate clientInfo after initialize lands on an existing session.
         const meta = sessions[existingSessionId];
         if (meta)
             meta.lastSeen = Date.now();
-        const mcpServer = httpTransports[existingSessionId].__mcpServer;
+        const mcpServer = httpTransports[existingSessionId]?.__mcpServer;
         if (meta && !meta.clientName && mcpServer?.getClientVersion) {
             try {
                 const info = mcpServer.getClientVersion();
@@ -1495,12 +1547,19 @@ app.all("/mcp", async (req, res) => {
         }
         return;
     }
-    // Spec-compliant: if the client presents a session ID we don't know about
-    // (server was restarted, or the transport was closed), return 404 so the
-    // client knows to re-initialize. The previous silent-new-session behavior
-    // left idle clients stuck with stale session bookkeeping until the VS Code
-    // window was manually reloaded.
-    if (existingSessionId) {
+    // Auto-reconnect path. If the client presents a session id we don't know
+    // about AND the request body is a fresh `initialize`, adopt the stale id
+    // instead of 404-ing. This covers the "server was restarted while Claude
+    // Code was open" case: clients that cache the session id (claude-code#27142)
+    // would otherwise stay ghost until the human manually reloaded the window.
+    // A non-initialize request with an unknown id still gets 404 — the client
+    // is expected to reinitialize in response.
+    const bodyIsInitialize = req.method === "POST" &&
+        req.body &&
+        (Array.isArray(req.body)
+            ? req.body.some((m) => m?.method === "initialize")
+            : req.body.method === "initialize");
+    if (existingSessionId && !bodyIsInitialize) {
         res.status(404).json({
             jsonrpc: "2.0",
             error: { code: -32000, message: "Session not found — reinitialize" },
@@ -1510,13 +1569,40 @@ app.all("/mcp", async (req, res) => {
     }
     const rawTag = typeof req.query.tag === "string" ? req.query.tag : undefined;
     const sessionTag = rawTag?.toLowerCase().replace(/[^a-z0-9_-]/g, "") || undefined;
-    const newSessionId = randomUUID();
+    // If the client brought a stale id on an initialize, reuse it so the client
+    // never has to swap ids. Otherwise mint a fresh one.
+    const newSessionId = existingSessionId ?? randomUUID();
     const host = (req.socket.remoteAddress || "").replace(/^::ffff:/, "") || undefined;
     const port = req.socket.remotePort;
-    // Build a distinguishable client id: tag wins if set; otherwise use host+port
-    // so two untagged sessions from the same machine are still distinguishable.
-    const clientId = sessionTag
+    // Pull clientInfo and workspace from the initialize body immediately so the
+    // pill shows a readable name from the start.
+    const initBody = Array.isArray(req.body)
+        ? req.body.find((m) => m?.method === "initialize")
+        : req.body;
+    const earlyClientName = initBody?.params?.clientInfo?.name;
+    // Prefer the workspace folder name (e.g. "AlphaWave", "notify-mcp-src") over
+    // the generic client name ("claude-code"). workspaceFolders[0].name is set by
+    // Claude Code and Cursor; rootUri is the fallback.
+    const workspaceFolders = initBody?.params?.workspaceFolders;
+    const rootUri = initBody?.params?.rootUri ?? initBody?.params?.root_uri;
+    const workspaceName = workspaceFolders?.[0]?.name ||
+        (rootUri ? rootUri.replace(/\\/g, "/").split("/").filter(Boolean).pop() : undefined);
+    // Build a distinguishable client id: tag wins if set; workspace name next;
+    // then clientInfo.name; otherwise use host+port. If the base id is already
+    // taken, append -2, -3, … so two windows on the same project still show up.
+    const baseId = sessionTag
+        ?? workspaceName
+        ?? earlyClientName
         ?? (host && port ? `${host === "127.0.0.1" || host === "::1" ? "local" : host}:${port}` : `sess-${newSessionId.slice(0, 8)}`);
+    // Exclude the session being re-adopted from the "taken" set — it's about to
+    // be replaced, so its old clientId should be available for reuse.
+    const adoptingId = existingSessionId && bodyIsInitialize ? existingSessionId : undefined;
+    const takenIds = new Set(Object.entries(sessions)
+        .filter(([sid]) => sid !== adoptingId)
+        .map(([, s]) => s.clientId));
+    let clientId = baseId;
+    for (let n = 2; takenIds.has(clientId); n++)
+        clientId = `${baseId}-${n}`;
     const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: () => newSessionId });
     transport.onclose = () => {
         if (transport.sessionId) {
@@ -1535,6 +1621,9 @@ app.all("/mcp", async (req, res) => {
         const now = Date.now();
         sessions[transport.sessionId] = {
             clientId, tag: sessionTag, host, connectedAt: now, lastSeen: now,
+            clientName: earlyClientName,
+            clientVersion: initBody?.params?.clientInfo?.version,
+            workspaceName,
         };
     }
 });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omni-notify-mcp",
-  "version": "1.2.0",
+  "version": "1.2.3",
   "description": "An MCP server that lets AI agents (Claude, Cursor, etc.) reach you on any channel — desktop, Telegram, SMS, email — with two-way ask/reply, real-time inbox push, Do Not Disturb, idle gating, multi-session routing, and a one-page web UI for setup. Zero config code; configure once, agents call notify/ask.",
   "main": "dist/index.js",
   "type": "module",

package/ui/public/app.js

@@ -613,39 +613,66 @@ function renderLogEntry(raw) {
   if (atBottom) panel.scrollTop = panel.scrollHeight;
 }
 
+function sessionStatus(lastSeen) {
+  const age = Date.now() - lastSeen;
+  if (age < 35_000) return "live";
+  if (age < 95_000) return "idle";
+  return "stale";
+}
+
+async function dismissSession(clientId) {
+  await fetch(`/api/sessions/${encodeURIComponent(clientId)}`, { method: "DELETE" });
+  refreshSessions();
+}
+
 async function refreshSessions() {
   try {
     const res = await fetch("/api/sessions");
     if (!res.ok) return;
     const { sessions } = await res.json();
     const bar = $("session-pills");
-    // Build a set of desired pills (keyed by clientId). Keep the "All" pill.
     const existing = new Map();
-    bar.querySelectorAll(".pill").forEach(p => existing.set(p.dataset.client || "", p));
+    bar.querySelectorAll(".pill[data-client]").forEach(p => {
+      if (p.dataset.client !== "") existing.set(p.dataset.client, p);
+    });
     const desired = new Set([""]);
     for (const s of sessions) desired.add(s.clientId);
-    // Remove pills for disconnected sessions.
+
+    // Remove pills for sessions the server no longer knows about.
     for (const [id, el] of existing) {
       if (!desired.has(id)) el.remove();
     }
-    // Add pills for new sessions.
+
+    // Add or update pills.
     for (const s of sessions) {
+      const status = sessionStatus(s.lastSeen);
+      const label = s.tag ? `@${s.tag}` : s.clientId;
+      const title = [s.workspaceName ?? s.clientName, s.host, `last seen ${Math.round((Date.now() - s.lastSeen) / 1000)}s ago`].filter(Boolean).join(" · ");
+
       if (!existing.has(s.clientId)) {
         const btn = document.createElement("button");
         btn.className = "pill";
         btn.dataset.client = s.clientId;
-        btn.textContent = s.tag ? `@${s.tag}` : s.clientId;
-        btn.title = [s.clientName, s.host].filter(Boolean).join(" · ");
         btn.onclick = () => selectLogFilter(s.clientId);
         bar.appendChild(btn);
+        existing.set(s.clientId, btn);
       }
+
+      const btn = existing.get(s.clientId);
+      btn.title = title;
+      btn.innerHTML =
+        `<span class="pill-dot pill-dot-${status}"></span>` +
+        `<span class="pill-label">${label}</span>` +
+        (status === "stale"
+          ? `<span class="pill-dismiss" title="Remove" onclick="event.stopPropagation();dismissSession('${s.clientId.replace(/'/g,"\\'")}')">×</span>`
+          : "");
     }
+
     // If the currently-selected client disconnected, fall back to "All".
     if (logFilterClient && !desired.has(logFilterClient)) {
       selectLogFilter("");
     } else {
-      // Re-sync active state (in case pills were re-added).
-      bar.querySelectorAll(".pill").forEach(p => {
+      bar.querySelectorAll(".pill[data-client]").forEach(p => {
         p.classList.toggle("pill-active", (p.dataset.client || "") === logFilterClient);
       });
     }

package/ui/public/style.css

@@ -231,6 +231,18 @@ main {
   border-color: var(--accent);
   color: #fff;
 }
+.pill { display: inline-flex; align-items: center; gap: 5px; }
+.pill-dot {
+  width: 7px; height: 7px; border-radius: 50%; flex-shrink: 0;
+}
+.pill-dot-live  { background: #4ade80; }
+.pill-dot-idle  { background: #facc15; }
+.pill-dot-stale { background: #f87171; }
+.pill-dismiss {
+  margin-left: 1px; font-size: 13px; line-height: 1;
+  opacity: .6; cursor: pointer;
+}
+.pill-dismiss:hover { opacity: 1; }
 
 /* ── Cards ───────────────────────────────────────────────────────────────── */