omni-notify-mcp 1.3.292 → 1.3.294

package/dist/agentGateway.js

@@ -15,7 +15,7 @@ import { masterMuted } from "./notify.js";
 import { appendEvent, cliOwns, CONVERSATION_MUTED_MESSAGE, conversationRefusal, editOwed, GatewayError, listConversations, monotonicMs, openConversationOf, openConversationsOf, queueNoticeOf, readEvents, resolveProject, routeAsk, stopTargetOf, sendToConversation, startConversation, updateConversation, } from "./gateway/conversations.js";
 import { SessionDriver } from "./gateway/sessionDriver.js";
 import { DEFAULT_PROVIDER } from "./gateway/provider.js";
-import { turnEnded } from "./gateway/mcpEvents.js";
+import { resendUndelivered, turnEnded } from "./gateway/mcpEvents.js";
 export const AGENT_PREFIX = "!";
 /** A chat door's own words when a message points at a browser CLI console session: the chat does not drive a live CLI, so it says so plainly and names where that session IS reachable. */
 const CONSOLE_NOT_IN_CHAT = "That is a live CLI console session opened in the browser — this chat does not type into it. Use /terminal in BN, or reach the SAME session from MCP/REST by its id (agent_send types into it, agent_stream streams its console).";
@@ -89,6 +89,7 @@ export class AgentGateway {
         if (this.recovered)
             return;
         this.recovered = true;
+        resendUndelivered();
         for (const c of listConversations())
             this.recover(c);
     }

package/dist/gateway/mcpEvents.js

@@ -8,6 +8,10 @@
  * Subscriptions are kept in one store file beside the conversations (`<config dir>/agent/event-subscriptions.json`), so
  * a BN restart keeps them. A callback is HTTPS only, every address its host resolves to must be public, the connection
  * is made to the address that was checked, and a redirect is never followed — the verification challenge included.
+ *
+ * How far each subscription has been served is a second file, `<config dir>/agent/event-deliveries.json`: per subscription the
+ * highest log position whose event reached a final answer (2xx, 413, any other refusal). A completion past it is still owed,
+ * and goes again — same event id, same bytes — with the next completion and on every boot, in order.
  */
 import { createHash, createHmac, randomBytes, randomUUID, timingSafeEqual } from "crypto";
 import { lookup } from "dns/promises";
@@ -17,7 +21,7 @@ import { BlockList, isIP } from "net";
 import { join } from "path";
 import { z } from "zod";
 import { ErrorCode, McpError } from "@modelcontextprotocol/sdk/types.js";
-import { agentDir, GatewayError, readConversation, requireConversationEnabled, writeRecordFile } from "./conversations.js";
+import { agentDir, GatewayError, readConversation, readEvents, requireConversationEnabled, writeRecordFile } from "./conversations.js";
 /** What the door adds to the capabilities its initialize answers: `events`, a key the SDK's capability type does not name. */
 export const EVENTS_CAPABILITY = { events: {} };
 const TURN_COMPLETED = "agent.turn_completed";
@@ -70,6 +74,20 @@ function storedSubscriptions() {
         return [];
     return JSON.parse(readFileSync(storePath(), "utf8")).subscriptions;
 }
+const deliveriesPath = () => join(agentDir(), "event-deliveries.json");
+/** Per subscription id, the highest log position of its conversation that is settled: delivered, or refused for good. */
+function settledPositions() {
+    if (!existsSync(deliveriesPath()))
+        return {};
+    return JSON.parse(readFileSync(deliveriesPath(), "utf8"));
+}
+/** Rewrites the delivery record with `change` applied, keeping only the live subscriptions' entries. */
+function editSettled(change) {
+    const settled = settledPositions();
+    change(settled);
+    const live = new Set(liveSubscriptions().map((s) => s.id));
+    writeRecordFile(deliveriesPath(), JSON.stringify(Object.fromEntries(Object.entries(settled).filter(([id]) => live.has(id))), null, 2));
+}
 /** The subscriptions whose granted lifetime has not passed. */
 function liveSubscriptions(now = Date.now()) {
     return storedSubscriptions().filter((s) => s.refreshBefore === null || Date.parse(s.refreshBefore) > now);
@@ -290,6 +308,8 @@ async function subscribe(principal, params) {
         throw new McpError(CALLBACK_ENDPOINT_ERROR, err.message, { reason: err.reason });
     }
     const subscription = { id, principal, name: TURN_COMPLETED, arguments: args, url: delivery.url, secret: delivery.secret, refreshBefore };
+    if (settledPositions()[id] === undefined)
+        writeRecordFile(deliveriesPath(), JSON.stringify({ ...settledPositions(), [id]: readEvents(args.conversation_id).at(-1)?.n ?? 0 }, null, 2));
     editStore((live) => [...live.filter((s) => s.id !== id), subscription]);
     process.stderr.write(`[agent-gateway] mcp events subscribed ${id} conv=${args.conversation_id} refreshBefore=${refreshBefore ?? "none"}\n`);
     return { id, refreshBefore, cursor: null, truncated: false };
@@ -299,9 +319,13 @@ function unsubscribe(principal, params) {
     const args = argumentsOf(params.arguments);
     const { url } = deliveryOf(params.delivery);
     const id = subscriptionId(principal, url, TURN_COMPLETED, args);
-    editStore((live) => live.filter((s) => s.id !== id));
+    removeSubscription(id);
     return {};
 }
+function removeSubscription(id) {
+    editStore((live) => live.filter((s) => s.id !== id));
+    editSettled((settled) => { delete settled[id]; });
+}
 /** The conversation switch refuses a new subscription as it refuses a tool call, in the switch's own words. */
 function requireConversationEnabledAsMcp() {
     try {
@@ -351,40 +375,74 @@ async function attemptDelivery(subscription, key, eventId, body) {
         return err;
     }
 }
-/** Posts one event to one subscription, the same body and id on every try with a fresh signature, until it lands or a final answer comes. */
+/** Posts one event to one subscription, the same body and id on every try with a fresh signature, until it lands or a final answer comes. Settled: the event needs no further send. Unsettled: the tries ran out on a transient failure. */
 async function deliver(subscription, event) {
     const eventId = `evt_${createHash("sha256").update(`${subscription.id}\n${event.id}\n${event.turn}`).digest("hex").slice(0, 32)}`;
     const body = eventBody(eventId, event);
     const key = signingKey(subscription.secret);
     for (let attempt = 1;; attempt++) {
         const outcome = await attemptDelivery(subscription, key, eventId, body);
-        if (typeof outcome === "number" && outcome >= 200 && outcome < 300)
-            return logDelivery(eventId, subscription, `delivered HTTP ${outcome} on try ${attempt}`);
+        if (typeof outcome === "number" && outcome >= 200 && outcome < 300) {
+            logDelivery(eventId, subscription, `delivered HTTP ${outcome} on try ${attempt}`);
+            return "settled";
+        }
         if (outcome === 410) {
-            editStore((live) => live.filter((s) => s.id !== subscription.id));
-            return logDelivery(eventId, subscription, "the callback answered 410 Gone: the subscription is removed");
+            logDelivery(eventId, subscription, "the callback answered 410 Gone: the subscription is removed");
+            return "gone";
         }
         const answered = typeof outcome === "number" ? `HTTP ${outcome}` : `${outcome.reason}: ${outcome.message}`;
-        if (!transient(outcome))
-            return logDelivery(eventId, subscription, `refused by the callback (${answered}) on try ${attempt}; not retried`);
-        if (attempt === DELIVERY_TRIES)
-            return logDelivery(eventId, subscription, `not delivered after ${attempt} tries, last ${answered}`);
+        if (!transient(outcome)) {
+            logDelivery(eventId, subscription, `refused by the callback (${answered}) on try ${attempt}; not retried`);
+            return "settled";
+        }
+        if (attempt === DELIVERY_TRIES) {
+            logDelivery(eventId, subscription, `not delivered after ${attempt} tries, last ${answered}; it goes again with the next turn or boot`);
+            return "unsettled";
+        }
         await new Promise((r) => setTimeout(r, DELIVERY_FIRST_WAIT_MS << (attempt - 1)));
     }
 }
-/** Reads the live subscriptions of the turn's conversation and delivers to each, after the session driver's own emit has returned. */
-async function reportTurn(event) {
-    await Promise.resolve();
-    for (const subscription of liveSubscriptions().filter((s) => s.arguments.conversation_id === event.id)) {
-        // OWNER: each delivery runs on its own and nothing awaits it — a failure no retry clears is written to the console with its event's conversation, turn and subscription.
-        void deliver(subscription, event).catch((err) => logDelivery(`turn=${event.turn}`, subscription, `not delivered: ${err instanceof Error ? err.message : String(err)}`));
+/** One subscription's deliveries run one after another, so a retry in flight is never overtaken or doubled by the next turn or a boot. */
+const chains = new Map();
+/** Sends one subscription every completed turn past its settled position, in order, stopping at the first that is not settled. */
+async function sendOwed(subscription) {
+    const conversationId = subscription.arguments.conversation_id;
+    const settled = settledPositions()[subscription.id];
+    const owed = readEvents(conversationId).filter((e) => e.n > settled && (e.kind === "answer" || e.kind === "failed"));
+    for (const event of owed) {
+        if (!liveSubscriptions().some((s) => s.id === subscription.id))
+            return;
+        const outcome = await deliver(subscription, { ...event, id: conversationId });
+        if (outcome === "unsettled")
+            return;
+        if (outcome === "gone")
+            return removeSubscription(subscription.id);
+        if (liveSubscriptions().some((s) => s.id === subscription.id))
+            editSettled((settled) => { settled[subscription.id] = event.n; });
     }
 }
+function drain(subscription) {
+    // OWNER: each subscription's delivery runs on its own and nothing awaits it — a failure no retry clears is written to the console with its subscription, and its undelivered turns stay owed for the next turn or boot.
+    const run = (chains.get(subscription.id) ?? Promise.resolve()).then(() => sendOwed(subscription)).catch((err) => { process.stderr.write(`[agent-gateway] mcp events sub=${subscription.id} not delivered: ${err instanceof Error ? err.message : String(err)}\n`); });
+    chains.set(subscription.id, run);
+    return run;
+}
+/** Boot: every live subscription is sent the completions it was owed when the last process ended. */
+export function resendUndelivered() {
+    for (const subscription of liveSubscriptions())
+        void drain(subscription);
+}
+/** The subscriptions of one conversation are sent what they are owed, after the session driver's own emit has returned. */
+async function reportTurn(conversationId) {
+    await Promise.resolve();
+    for (const subscription of liveSubscriptions().filter((s) => s.arguments.conversation_id === conversationId))
+        void drain(subscription);
+}
 /** The session driver's listener: a turn that answered or failed is reported to every live subscription of its conversation. */
 export function turnEnded(event) {
     // NULL-OK: field turn is OPTIONAL and therefore it is ok to check for NULL
     if (event.turn === undefined || (event.kind !== "answer" && event.kind !== "failed"))
         return;
     // OWNER: the report runs on its own after the turn is stored and nothing awaits it — a store that cannot be read is written to the console with the conversation and turn.
-    void reportTurn(event).catch((err) => process.stderr.write(`[agent-gateway] mcp events for conv=${event.id} turn=${event.turn} not reported: ${err instanceof Error ? err.message : String(err)}\n`));
+    void reportTurn(event.id).catch((err) => process.stderr.write(`[agent-gateway] mcp events for conv=${event.id} turn=${event.turn} not reported: ${err instanceof Error ? err.message : String(err)}\n`));
 }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "omni-notify-mcp",
-  "version": "1.3.292",
+  "version": "1.3.294",
   "description": "Reach your AI agents from anywhere — and let them reach you. One stdio process serves the whole tool surface to Claude Code, GitHub Copilot Chat and Codex: desktop, Telegram, Slack, ntfy, Discord, Teams and SMS are configured in one file, and agents notify you when long work finishes or a decision is needed, ask you a question and wait for your answer, and receive and reply to the messages you send them — with Do Not Disturb and idle detection deciding what actually gets through.",
   "main": "dist/index.js",
   "type": "module",