omni-notify-mcp 1.3.8 → 1.3.12

package/README.md

@@ -6,9 +6,9 @@
 
 <p align="center">
   <em>Reach me on any channel. Ask me anything. Get out of my way when I'm busy.</em><br>
-  An MCP server that gives AI agents (Claude, Cursor, etc.) a single
-  <code>notify</code> / <code>ask</code> interface — desktop, Telegram, SMS, email —
-  with two-way replies, idle gating, and Do Not Disturb.
+  HTTP-first notification/control server with optional MCP compatibility for AI agents
+  (Claude, Copilot, Cursor, etc.): desktop, Telegram, Slack, SMS, email,
+  two-way replies, idle gating, and Do Not Disturb.
 </p>
 
 <p align="center">
@@ -37,6 +37,20 @@ You step away from your machine and the AI is still working. **It needs to**:
 
 ## Quick start
 
+```bash
+npx omni-notify-ui
+```
+
+This starts the HTTP/UI server on `http://localhost:3737`.
+
+MCP is optional. To enable the `/mcp` endpoint, start with:
+
+```bash
+ENABLE_MCP=1 npx omni-notify-ui
+```
+
+Or use the stdio bridge (which auto-spawns the UI with MCP enabled):
+
 ```bash
 npx omni-notify-mcp
 ```
@@ -54,12 +68,6 @@ Add to your MCP config (`~/.claude.json`, `.vscode/mcp.json`, `claude_desktop_co
 }
 ```
 
-Then run the config UI to wire up your channels:
-
-```bash
-npx omni-notify-ui
-```
-
 Open <http://localhost:3737>, toggle the channels you want, and hit Save. The MCP server picks up changes immediately — no restart.
 
 ## What the agent gets

package/dist/index.js

@@ -27,12 +27,40 @@ 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 { join, dirname } from "path";
+import { join, dirname, basename } from "path";
+import { hostname } from "os";
 import { fileURLToPath } from "url";
 import { z } from "zod";
 const PORT = process.env.NOTIFY_MCP_PORT ? parseInt(process.env.NOTIFY_MCP_PORT) : 3737;
 const BASE = `http://localhost:${PORT}`;
-const SESSION_TAG = (process.env.NOTIFY_MCP_TAG ?? "").toLowerCase().replace(/[^a-z0-9_-]/g, "") || undefined;
+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").
+function deriveVscId() {
+    const explicit = CLEAN_ID(process.env.NOTIFY_MCP_TAG ?? "");
+    if (explicit)
+        return explicit;
+    const generic = new Set([
+        "claude-code", "claude", "code", "cursor", "vscode", "windsurf",
+        "bin", "dist", "build", "src", "out", "node_modules",
+        "windows", "system32", "users", "appdata", "roaming", "local", "programs", "temp", "tmp",
+    ]);
+    let dir = process.cwd();
+    for (let i = 0; i < 5; i++) {
+        const name = CLEAN_ID(basename(dir));
+        if (name && !generic.has(name))
+            return name;
+        const parent = dirname(dir);
+        if (!parent || parent === dir)
+            break;
+        dir = parent;
+    }
+    return CLEAN_ID(basename(process.cwd())) || "agent";
+}
+const VSC_ID = deriveVscId();
+const SESSION_TAG = `${hostname().toLowerCase().replace(/[^a-z0-9_-]/g, "")}-${VSC_ID}`;
 const CLIENT_NAME = "claude-channel-bridge";
 // ── 1. Ensure the HTTP server is up ───────────────────────────────────────────
 async function serverIsUp() {
@@ -43,9 +71,9 @@ async function serverIsUp() {
             body: JSON.stringify({ jsonrpc: "2.0", id: 0, method: "initialize", params: {} }),
             signal: AbortSignal.timeout(1500),
         });
-        // Any HTTP response (including 400/406 from malformed init) means the
-        // server is alive and speaking HTTP. Real "down" surfaces as a throw.
-        return r.status > 0;
+        // The bridge requires an active /mcp endpoint.
+        // 404 specifically means UI may be up but MCP transport is disabled.
+        return r.status > 0 && r.status !== 404;
     }
     catch {
         return false;
@@ -68,7 +96,7 @@ function spawnUiServerIfNeeded() {
     const child = spawn(process.execPath, [uiPath], {
         detached: true,
         stdio: "ignore",
-        env: { ...process.env, PORT: String(PORT) },
+        env: { ...process.env, PORT: String(PORT), ENABLE_MCP: "1" },
     });
     child.unref();
 }
@@ -159,6 +187,21 @@ async function httpInitialize() {
     // Follow-up: the spec requires a notifications/initialized after initialize.
     await httpRpc("notifications/initialized").catch(() => { });
 }
+// 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
+// infrequently, and after 60s of idle the server wipes the session from its
+// sessions[] map — which makes Telegram's "routed to X agents" ack say
+// "no agents connected" even though the bridge is still alive and subscribed.
+function startSessionKeepalive() {
+    setInterval(async () => {
+        try {
+            await httpRpc("tools/list").catch(() => { });
+        }
+        catch {
+            // best effort; next call will re-initialize via 404 retry path
+        }
+    }, 30_000);
+}
 // ── 3. Stdio MCP server — the thing Claude Code / Cursor attaches to ─────────
 const server = new McpServer({ name: "notify-mcp", version: "1.2.0" }, {
     // Declare the claude/channel capability so Claude Code knows to surface
@@ -168,10 +211,14 @@ const server = new McpServer({ name: "notify-mcp", version: "1.2.0" }, {
     capabilities: {
         experimental: { "claude/channel": {} },
     },
-    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.\n\n" +
+    instructions: "This is the stdio bridge for notify-mcp. To receive unsolicited user " +
+        "messages in ANY MCP host (Claude Code, Copilot, Cursor), call `wait_for_inbox` " +
+        "— it long-polls up to 50s and returns new user messages as tool results. Call " +
+        "it whenever you finish a task or would otherwise wait, then again right after " +
+        "handling each batch, so messages keep arriving. (The Claude Code CLI launched " +
+        "with `--channels` ALSO delivers messages as synthetic turns automatically, but " +
+        "that path does NOT exist in the VSCode extension or Copilot — `wait_for_inbox` " +
+        "is the reliable lowest-common-denominator mechanism across every host.)\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 " +
@@ -182,6 +229,15 @@ 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" +
         "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.",
@@ -200,7 +256,10 @@ async function proxyToolCall(name, args) {
     }
     return { content: [{ type: "text", text: JSON.stringify(result ?? {}) }] };
 }
-server.tool("notify", "Send a notification to the user. Delivery channels and DND are server-configured.", {
+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),
     priority: z.enum(["low", "normal", "high"]).default("normal"),
 }, async (args) => proxyToolCall("notify", args));
@@ -323,6 +382,7 @@ async function main() {
     // 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)}`));
+    startSessionKeepalive();
     const transport = new StdioServerTransport();
     await server.connect(transport);
     stderr(`[bridge] stdio MCP bridge ready (tag=${SESSION_TAG ?? "none"}, port=${PORT})`);

package/dist/ui/messaging/notificationEngine.js

@@ -0,0 +1,67 @@
+export function computeDesktopOnlyMode(priority, policy, ctx) {
+    if (priority === "high") {
+        return { desktopOnly: false };
+    }
+    if (policy.dndActive) {
+        return { desktopOnly: false, suppressedReason: "dnd" };
+    }
+    if (ctx.uiActive || (policy.idleEnabled && !ctx.inTelegramConversation && ctx.idleSeconds >= 0 && ctx.idleSeconds < policy.idleThresholdSeconds)) {
+        if (policy.alwaysDesktopWhenActive) {
+            return { desktopOnly: true };
+        }
+        return { desktopOnly: false, suppressedReason: "idle" };
+    }
+    return { desktopOnly: false };
+}
+export async function sendWithRouting(options) {
+    const { message, priority, senders, policy, ctx, enableDesktop, enableTelegram, enableEmail, enableSms, enableNtfy, enableDiscord, enableSlack, enableTeams, } = options;
+    const mode = computeDesktopOnlyMode(priority, policy, ctx);
+    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;
+    const trySend = async (name, fn) => {
+        if (!fn)
+            return;
+        try {
+            await fn();
+            delivered.push(name);
+        }
+        catch (err) {
+            const msg = err instanceof Error ? err.message : String(err);
+            errors.push(`${name}: ${msg}`);
+        }
+    };
+    if (priority !== "low") {
+        if (enableDesktop) {
+            await trySend("desktop", senders.desktop ? () => senders.desktop(message) : undefined);
+        }
+        if (!desktopOnly && enableTelegram) {
+            await trySend("telegram", senders.telegram ? () => senders.telegram(message) : undefined);
+        }
+    }
+    if (!desktopOnly && enableEmail) {
+        await trySend("email", senders.email ? () => senders.email(message) : undefined);
+    }
+    if (!desktopOnly && enableNtfy) {
+        await trySend("ntfy", senders.ntfy ? () => senders.ntfy(message, priority) : undefined);
+    }
+    if (!desktopOnly && enableDiscord) {
+        await trySend("discord", senders.discord ? () => senders.discord(message, priority) : undefined);
+    }
+    if (!desktopOnly && enableSlack) {
+        await trySend("slack", senders.slack ? () => senders.slack(message, priority) : undefined);
+    }
+    if (!desktopOnly && enableTeams) {
+        await trySend("teams", senders.teams ? () => senders.teams(message, priority) : undefined);
+    }
+    if (priority === "high" && enableSms) {
+        await trySend("sms", senders.sms ? () => senders.sms(message) : undefined);
+    }
+    return { delivered, errors };
+}

package/dist/ui/messaging/types.js

@@ -0,0 +1 @@
+export {};