omni-notify-mcp 1.3.14 → 1.3.21

package/dist/index.js

@@ -241,35 +241,41 @@ const server = new McpServer({ name: "notify-mcp", version: "1.2.0" }, {
     capabilities: {
         experimental: { "claude/channel": {} },
     },
-    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 " +
-        "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.\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.",
+    instructions: "This server is how you reach the user — and only you can decide to use it: nothing " +
+        "here delivers a message the user never asked for unless you or your own loop calls a " +
+        "tool. Four tools hold that conversation over whatever channels the server has " +
+        "configured: `notify` sends the user a message; `ask` sends a question and waits for " +
+        "their answer; `wait_for_inbox` waits up to 50s and returns the messages the user sent " +
+        "you; `reply` answers the user's most recent message back over the channel they are " +
+        "reading. Call `wait_for_inbox` whenever you finish a task or would otherwise be " +
+        "waiting, then call it again right after handling anything it returns.\n\n" +
+        "ALWAYS call `notify` when: (a) a task that took more than about a minute 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 now. Never pre-check whether " +
+        "the user is at their desk — the server applies Do Not Disturb and idle gating itself, " +
+        "so fire `notify` and let the server decide routing. Fire it even when you are unsure: " +
+        "an unwanted notification the server holds back costs nothing, while a missed one " +
+        "costs the user hours.\n\n" +
+        "Read the result of every `notify` call. `outcome=delivered` means at least one channel " +
+        "carried it. `outcome=failed` or `outcome=blocked` means it reached nobody — never " +
+        "assume the user was told: say so in your reply and tell them no notification channel " +
+        "is configured.\n\n" +
+        "Echo the COMPLETE, UNTRUNCATED message in your chat output as well — never shorten it " +
+        "with '…' or a summary. Never name a delivery channel (Telegram, SMS, desktop, etc.) — " +
+        "those are server internals. Say 'notif' or 'notification' to refer to the act of " +
+        "notifying.\n\n" +
+        "NEVER TRUNCATE — THE SERVER CHUNKS FOR YOU.\n" +
+        "The hard limit is 500 characters per message, and the server enforces it by splitting " +
+        "for you: send the COMPLETE message (up to 5000 characters) in a single `notify` call " +
+        "and any body over 500 characters is automatically split into numbered parts — " +
+        "'(1/N) ...', '(2/N) ...' — each 500 characters or less and delivered in order, so you " +
+        "never hand-split and never lose the tail. A `too_big` error means you exceeded the " +
+        "5000-character cap; it never means you should shorten the message. Decide everything " +
+        "the user must see — every fact, file path, line number, recommendation — send it all " +
+        "in one call, and echo it in full in chat.\n\n" +
+        "When the user asks you to remember a rule or change how you should act, call " +
+        "`update_instructions` with the full updated rules block: it replaces the previous " +
+        "block atomically so the rule survives session restarts and context compaction.",
 });
 // 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
@@ -302,7 +308,11 @@ async function sendNotifyChunked(message, priority) {
         .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;
+    // Structural, never a string match: the server answers with an explicit
+    // `outcome=` token, so a send that reached nobody cannot read as a delivery
+    // merely because it failed to match some happy-path phrase.
+    const outcomeOf = (t) => (t.match(/outcome=(\w+)/)?.[1] ?? "unknown");
+    const delivered = texts.filter(t => outcomeOf(t) === "delivered").length;
     const n = chunks.length;
     let summary;
     if (delivered === n) {
@@ -310,18 +320,27 @@ async function sendNotifyChunked(message, priority) {
     }
     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 failedSummaries = [...new Set(texts.filter(t => outcomeOf(t) !== "delivered").map(stripInbox))];
         const said = failedSummaries.map(s => `"${s}"`).join(", ");
         summary = delivered === 0
-            ? `Suppressed — 0 of ${n} chunks reached any channel. Server said: ${said}`
+            ? `NOT DELIVERED — 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}.`;
     }
+    // A chunk that reached nobody is an ERROR result, not a report the caller
+    // reads past: an escalation that silently went nowhere is the whole defect.
+    if (delivered < n) {
+        return { content: [{ type: "text", text: `${summary}${inboxSuffix}` }], isError: true };
+    }
     return { content: [{ type: "text", text: `${summary}${inboxSuffix}` }] };
 }
 server.tool("notify", "Send a notification to the user. Delivery channels and DND are server-configured. " +
-    "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.", {
+    "The result always carries an explicit outcome: `outcome=delivered` means at least one " +
+    "channel carried the message, while `outcome=failed` or `outcome=blocked` means it " +
+    "reached NOBODY — never assume the user was told. " +
+    "One message is limited to 500 characters; the 5000-character cap on this tool is only " +
+    "the outer bound. Send the COMPLETE message in one call — anything over 500 characters " +
+    "is split for you into numbered '(1/N) ...' parts, each 500 characters or less, and " +
+    "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));
@@ -334,7 +353,12 @@ server.tool("wait_for_inbox", "Block until an unsolicited user message arrives o
     "delivery across every MCP client (messages come back as tool results).", {
     timeout_seconds: z.number().min(5).max(55).default(50),
 }, async (args) => proxyToolCall("wait_for_inbox", args));
-server.tool("get_idle_seconds", "Seconds since user's last keyboard/mouse input. Drains inbox as a side-effect.", {}, async () => proxyToolCall("get_idle_seconds", {}));
+server.tool("get_idle_seconds", "Periodic heartbeat: how long since the user's last keyboard/mouse input, and drains " +
+    "the inbox as a side effect. Two distinct answers — 'idle: measured N seconds since " +
+    "the last keyboard/mouse input' is a reading; 'idle: could not measure' means this " +
+    "machine cannot report user activity at all, in which case gating is skipped and the " +
+    "server delivers. Neither is a number for you to compare against a threshold; the " +
+    "server gates internally.", {}, async () => proxyToolCall("get_idle_seconds", {}));
 server.tool("get_idle_config", "Server's idle gating policy. Drains inbox as a side-effect.", {}, async () => proxyToolCall("get_idle_config", {}));
 server.tool("get_dnd_status", "Current DND state. Drains inbox as a side-effect.", {}, async () => proxyToolCall("get_dnd_status", {}));
 server.tool("update_instructions", "Persist behavioral instructions for this client into CLAUDE.md so they survive " +
@@ -349,7 +373,8 @@ server.tool("update_instructions", "Persist behavioral instructions for this cli
 // it straight through `notify` so it flows to whatever channel the user is
 // actually reading (Telegram, desktop, email, ...).
 server.tool("reply", "Reply to the user's most recent channel message. Routes through notify so " +
-    "the response reaches whichever channel the user is reading.", {
+    "the response reaches whichever channel the user is reading. The result " +
+    "carries the same `outcome=` contract as notify — an error means it reached nobody.", {
     message: z.string().max(2000).describe("The reply text to deliver"),
     priority: z.enum(["low", "normal", "high"]).default("normal"),
 }, async ({ message, priority }) => {

package/dist/ui/messaging/notificationEngine.js

@@ -1,65 +1,190 @@
+// A failed measurement is a NAMED state, never a number. `get_idle_seconds`
+// answers -1 when it could not read, and -1 sits in-band with every real
+// threshold comparison (a negative is always "under" the threshold), so a
+// failed read and a genuine reading are indistinguishable once it is a number.
+// Converting at the producer keeps the distinction for every consumer.
+export function idleReading(seconds) {
+    return seconds >= 0 ? { measurable: true, seconds } : { measurable: false };
+}
+export function formatIdleReading(reading) {
+    return reading.measurable
+        ? `idle: measured ${reading.seconds} seconds since the last keyboard/mouse input`
+        : "idle: could not measure — user activity unknown, so activity gating is skipped";
+}
+const EVERY_PRIORITY = ["low", "normal", "high"];
+// GATE: which priorities reach each channel, in send order, and what an at-keyboard user holds back — a channel is never attempted for a priority outside its list
+const CHANNEL_ROUTES = [
+    { channel: "desktop", priorities: ["normal", "high"], atKeyboard: "desktopSignal" },
+    { channel: "telegram", priorities: ["normal", "high"], atKeyboard: "heldBack" },
+    { channel: "email", priorities: EVERY_PRIORITY, atKeyboard: "heldBack" },
+    { channel: "ntfy", priorities: EVERY_PRIORITY, atKeyboard: "heldBack" },
+    { channel: "discord", priorities: EVERY_PRIORITY, atKeyboard: "heldBack" },
+    { channel: "slack", priorities: EVERY_PRIORITY, atKeyboard: "channelLog" },
+    { channel: "teams", priorities: EVERY_PRIORITY, atKeyboard: "heldBack" },
+    { channel: "sms", priorities: ["high"], atKeyboard: "heldBack" },
+];
+export function describePriorityRouting() {
+    return EVERY_PRIORITY
+        .map((priority) => `${priority}=${CHANNEL_ROUTES.filter((route) => route.priorities.includes(priority)).map((route) => route.channel).join("+")}`)
+        .join("; ");
+}
 export function computeDesktopOnlyMode(priority, policy, ctx) {
+    const idleKnown = ctx.idle.measurable;
     if (priority === "high") {
-        return { desktopOnly: false };
+        return {
+            desktopOnly: false,
+            idle: ctx.idle,
+            idleKnown,
+            reason: "priority=high — every enabled channel is used and activity gating is waived",
+        };
     }
     if (policy.dndActive) {
-        return { desktopOnly: false, suppressedReason: "dnd" };
+        return {
+            desktopOnly: false,
+            suppressedReason: "dnd",
+            idle: ctx.idle,
+            idleKnown,
+            reason: "DND active — no channel was attempted",
+        };
+    }
+    // The measurement FAILED: a deliberate fail-open. Stated as its own branch so
+    // it can never be reached by accident of a comparison against a sentinel.
+    if (policy.idleEnabled && !ctx.inTelegramConversation && !ctx.idle.measurable) {
+        return {
+            desktopOnly: false,
+            idle: ctx.idle,
+            idleKnown,
+            reason: "user activity could not be measured — gating skipped and every enabled channel is used",
+        };
     }
-    if (ctx.uiActive || (policy.idleEnabled && !ctx.inTelegramConversation && ctx.idleSeconds >= 0 && ctx.idleSeconds < policy.idleThresholdSeconds)) {
+    const idleGated = policy.idleEnabled
+        && !ctx.inTelegramConversation
+        && ctx.idle.measurable
+        && ctx.idle.seconds < policy.idleThresholdSeconds;
+    if (ctx.uiActive || idleGated) {
+        const why = ctx.uiActive
+            ? "the UI is open"
+            : `idle ${ctx.idle.measurable ? ctx.idle.seconds : 0}s is under the ${policy.idleThresholdSeconds}s threshold`;
         if (policy.alwaysDesktopWhenActive) {
-            return { desktopOnly: true };
+            return {
+                desktopOnly: true,
+                idle: ctx.idle,
+                idleKnown,
+                reason: `${why} — desktop only, remote channels skipped`,
+            };
         }
-        return { desktopOnly: false, suppressedReason: "idle" };
+        return {
+            desktopOnly: false,
+            suppressedReason: "idle",
+            idle: ctx.idle,
+            idleKnown,
+            reason: `${why} and alwaysDesktopWhenActive is false — no desktop signal, only the Slack channel log is used`,
+        };
     }
-    return { desktopOnly: false };
+    return {
+        desktopOnly: false,
+        idle: ctx.idle,
+        idleKnown,
+        reason: "the user is considered away — every enabled channel is used",
+    };
+}
+function reachWhileAtKeyboard(decision) {
+    if (decision.suppressedReason === "idle")
+        return ["channelLog"];
+    if (decision.desktopOnly)
+        return ["desktopSignal", "channelLog"];
+    return ["heldBack", "desktopSignal", "channelLog"];
 }
 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" };
+    const { message, priority, senders, policy, ctx } = options;
+    const enabled = {
+        desktop: options.enableDesktop,
+        telegram: options.enableTelegram,
+        email: options.enableEmail,
+        ntfy: options.enableNtfy,
+        discord: options.enableDiscord,
+        slack: options.enableSlack,
+        teams: options.enableTeams,
+        sms: options.enableSms,
+    };
+    const decision = computeDesktopOnlyMode(priority, policy, ctx);
+    if (decision.suppressedReason === "dnd") {
+        return {
+            delivered: [],
+            attempted: [],
+            errors: [],
+            suppressedReason: "DND active",
+            outcome: "suppressed",
+            summary: `Suppressed — ${decision.reason}. ${formatIdleReading(decision.idle)}.`,
+        };
     }
     const delivered = [];
     const errors = [];
-    // 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;
+    const attempted = [];
+    const reach = reachWhileAtKeyboard(decision);
+    for (const route of CHANNEL_ROUTES) {
+        if (!enabled[route.channel] || !route.priorities.includes(priority) || !reach.includes(route.atKeyboard))
+            continue;
+        attempted.push(route.channel);
+        // OWNER: ITER/LOOP — one channel's provider failing must not stop the remaining channels — its reason is recorded per channel and the outcome below reports failed when no channel delivered
         try {
-            await fn();
-            delivered.push(name);
+            await senders[route.channel](message, priority);
+            delivered.push(route.channel);
         }
         catch (err) {
-            const msg = err instanceof Error ? err.message : String(err);
-            errors.push(`${name}: ${msg}`);
+            errors.push(`${route.channel}: ${err instanceof Error ? err.message : String(err)}`);
         }
-    };
-    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);
+    // A send that reached nobody is its own outcome — never a value the caller
+    // has to compare against a happy-path string to notice.
+    if (delivered.length > 0) {
+        return {
+            delivered,
+            attempted,
+            errors,
+            outcome: "delivered",
+            summary: `Delivered to ${delivered.length} channel${delivered.length === 1 ? "" : "s"}: ${delivered.join(", ")} — ${decision.reason}.`,
+        };
     }
-    if (!desktopOnly && enableDiscord) {
-        await trySend("discord", senders.discord ? () => senders.discord(message, priority) : undefined);
+    if (decision.suppressedReason === "idle" && attempted.length === 0) {
+        return {
+            delivered,
+            attempted,
+            errors,
+            suppressedReason: "idle",
+            outcome: "suppressed",
+            summary: `Suppressed — ${decision.reason}. ${formatIdleReading(decision.idle)}.`,
+        };
     }
-    if (enableSlack) {
-        await trySend("slack", senders.slack ? () => senders.slack(message, priority) : undefined);
+    // Nothing was even eligible to try — this is NOT a hold (the branches above
+    // already caught dnd/idle) and it is NOT a per-channel send error (nothing
+    // was attempted, so `errors` is necessarily empty). It is either "nothing is
+    // turned on at all" or "something is turned on but doesn't reach this
+    // priority/activity state" — story #438: the old text here ("reached 0 of 0
+    // enabled channels; the server log names which send failed") actively lied
+    // in this branch, since nothing was ever attempted and no log line exists to
+    // name. Naming what IS enabled (or that nothing is) is the whole difference
+    // between an agent that can act on the failure and one that cannot.
+    if (attempted.length === 0) {
+        const enabledChannels = Object.keys(enabled).filter((c) => enabled[c]);
+        const configHint = enabledChannels.length === 0
+            ? "no channel is enabled at all — enable at least one (desktop, telegram, email, ntfy, discord, slack, teams, sms) in the settings UI before calling notify again"
+            : `${enabledChannels.join(", ")} ${enabledChannels.length === 1 ? "is" : "are"} enabled but none of them reaches priority=${priority} while ${reach.join("/")}-class channels are reachable — check each channel's priority range and activity gating`;
+        return {
+            delivered,
+            attempted,
+            errors,
+            outcome: "failed",
+            summary: `NOT DELIVERED — no channel was eligible to try: ${configHint} — ${decision.reason}. ${formatIdleReading(decision.idle)}.`,
+        };
     }
-    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 };
+    return {
+        delivered,
+        attempted,
+        errors,
+        outcome: "failed",
+        summary: `NOT DELIVERED — reached 0 of ${attempted.length} enabled channel${attempted.length === 1 ? "" : "s"}`
+            + `; all ${errors.length} failed: ${errors.join("; ")}`
+            + ` — ${decision.reason}. ${formatIdleReading(decision.idle)}.`,
+    };
 }