mcp-event-intelligence 0.1.1 → 0.2.0

package/scripts/lib/persistent-event-store.mjs

@@ -1,4 +1,4 @@
-import { appendFile, mkdir, readFile } from 'node:fs/promises';
+import { appendFile, mkdir, readFile, readdir } from 'node:fs/promises';
 import path from 'node:path';
 import {
   AuditChain,
@@ -9,6 +9,29 @@ import {
   McpEventOccurrenceSchema,
 } from '../../dist/src/intelligenceProtocol/index.js';
 
+export const DEFAULT_EVENT_SCOPE_ID = 'default';
+
+export function normalizeEventScopeId(input = DEFAULT_EVENT_SCOPE_ID) {
+  const scopeId = String(input ?? DEFAULT_EVENT_SCOPE_ID).trim();
+  if (!scopeId) throw new Error('Event Intelligence scopeId must not be empty');
+  if (scopeId.length > 240) {
+    throw new Error('Event Intelligence scopeId must be at most 240 characters');
+  }
+  return scopeId;
+}
+
+function scopeDirectoryName(scopeId) {
+  return Buffer.from(scopeId, 'utf8').toString('base64url');
+}
+
+function scopeIdFromDirectoryName(name) {
+  try {
+    return Buffer.from(name, 'base64url').toString('utf8');
+  } catch {
+    return null;
+  }
+}
+
 async function readJsonLines(filePath) {
   try {
     const raw = await readFile(filePath, 'utf8');
@@ -28,6 +51,7 @@ export class PersistentEventStore {
   #events = [];
   #decisions = [];
   #wakes = [];
+  #wakeDeliveries = new Map();
   #triggers = new Map();
   #triggerStates = new Map();
   #eventSources = new Map();
@@ -40,6 +64,7 @@ export class PersistentEventStore {
   #derivedEvents = new Map();
   #derivedContracts = new Map();
   #auditChain = new AuditChain();
+  #scopeStores = new Map();
 
   constructor(dataDir) {
     this.dataDir = dataDir;
@@ -47,6 +72,7 @@ export class PersistentEventStore {
       events: path.join(dataDir, 'events.jsonl'),
       decisions: path.join(dataDir, 'decisions.jsonl'),
       wakes: path.join(dataDir, 'wakes.jsonl'),
+      wakeDeliveries: path.join(dataDir, 'wake-deliveries.jsonl'),
       triggers: path.join(dataDir, 'triggers.jsonl'),
       triggerStates: path.join(dataDir, 'trigger-states.jsonl'),
       eventSources: path.join(dataDir, 'event-sources.jsonl'),
@@ -60,6 +86,41 @@ export class PersistentEventStore {
     };
   }
 
+  async forScope(scopeIdInput = DEFAULT_EVENT_SCOPE_ID) {
+    const scopeId = normalizeEventScopeId(scopeIdInput);
+    if (scopeId === DEFAULT_EVENT_SCOPE_ID) return this;
+
+    const existing = this.#scopeStores.get(scopeId);
+    if (existing) return existing;
+
+    const scoped = new PersistentEventStore(
+      path.join(this.dataDir, 'scopes', scopeDirectoryName(scopeId)),
+    );
+    await scoped.init();
+    this.#scopeStores.set(scopeId, scoped);
+    return scoped;
+  }
+
+  async listScopeIds() {
+    const scopes = new Set([
+      DEFAULT_EVENT_SCOPE_ID,
+      ...this.#scopeStores.keys(),
+    ]);
+    try {
+      const entries = await readdir(path.join(this.dataDir, 'scopes'), {
+        withFileTypes: true,
+      });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const scopeId = scopeIdFromDirectoryName(entry.name);
+        if (scopeId) scopes.add(scopeId);
+      }
+    } catch (error) {
+      if (error?.code !== 'ENOENT') throw error;
+    }
+    return [...scopes].sort();
+  }
+
   async init() {
     await mkdir(this.dataDir, { recursive: true });
 
@@ -67,6 +128,7 @@ export class PersistentEventStore {
       events,
       decisions,
       wakes,
+      wakeDeliveries,
       triggers,
       triggerStates,
       eventSources,
@@ -81,6 +143,7 @@ export class PersistentEventStore {
       readJsonLines(this.files.events),
       readJsonLines(this.files.decisions),
       readJsonLines(this.files.wakes),
+      readJsonLines(this.files.wakeDeliveries),
       readJsonLines(this.files.triggers),
       readJsonLines(this.files.triggerStates),
       readJsonLines(this.files.eventSources),
@@ -97,6 +160,42 @@ export class PersistentEventStore {
     this.#decisions = decisions;
     this.#wakes = wakes;
 
+    this.#wakeDeliveries = new Map();
+    for (const raw of wakeDeliveries) {
+      if (!raw?.wakeId || !raw?.runtime || (!raw?.sourceId && !raw?.matchId)) continue;
+      const status = [
+        'pending',
+        'claimed',
+        'retry_pending',
+        'delivered',
+        'dead_letter',
+      ].includes(raw.status)
+        ? raw.status
+        : 'pending';
+      const record = {
+        wakeId: String(raw.wakeId),
+        sourceType: raw.sourceType === 'event' ? 'event' : 'composite',
+        sourceId: String(raw.sourceId || raw.matchId),
+        matchId: raw.matchId ? String(raw.matchId) : '',
+        triggerId: String(raw.triggerId || ''),
+        triggerVersion: String(raw.triggerVersion || '1'),
+        runtime: String(raw.runtime),
+        status,
+        attemptCount:
+          Number.isInteger(raw.attemptCount) && raw.attemptCount >= 0
+            ? raw.attemptCount
+            : 0,
+        nextAttemptAt: String(raw.nextAttemptAt || raw.updatedAt || new Date(0).toISOString()),
+        leaseOwner: raw.leaseOwner ? String(raw.leaseOwner) : null,
+        leaseUntil: raw.leaseUntil ? String(raw.leaseUntil) : null,
+        runtimeReceiptId: raw.runtimeReceiptId ? String(raw.runtimeReceiptId) : null,
+        lastError: raw.lastError ? String(raw.lastError) : null,
+        createdAt: String(raw.createdAt || new Date(0).toISOString()),
+        updatedAt: String(raw.updatedAt || new Date(0).toISOString()),
+      };
+      this.#wakeDeliveries.set(record.wakeId, record);
+    }
+
     this.#triggers = new Map();
     for (const raw of triggers) {
       const definition = parseCompositeTriggerDefinition(raw);
@@ -265,6 +364,7 @@ export class PersistentEventStore {
       events: events.length,
       decisions: decisions.length,
       wakes: wakes.length,
+      wakeDeliveries: this.#wakeDeliveries.size,
       triggers: this.#triggers.size,
       triggerStates: this.#triggerStates.size,
       eventSources: this.#eventSources.size,
@@ -307,6 +407,213 @@ export class PersistentEventStore {
     });
   }
 
+  getWakeDelivery(wakeId) {
+    return this.#wakeDeliveries.get(String(wakeId)) ?? null;
+  }
+
+  listDueWakeDeliveries(nowIso = new Date().toISOString()) {
+    const now = Date.parse(nowIso);
+    return [...this.#wakeDeliveries.values()]
+      .filter((record) => {
+        if (record.status === 'pending' || record.status === 'retry_pending') {
+          return Date.parse(record.nextAttemptAt) <= now;
+        }
+        if (record.status === 'claimed' && record.leaseUntil) {
+          return Date.parse(record.leaseUntil) <= now;
+        }
+        if (record.status === 'delivered') {
+          const latestWake = this.latestWake(record.wakeId);
+          const wakeFinalized =
+            latestWake?.status === 'delivered' ||
+            latestWake?.status === 'handled';
+          if (record.sourceType === 'event') {
+            return !wakeFinalized;
+          }
+          const match = this.#triggerMatches.get(record.matchId);
+          return !wakeFinalized || match?.status !== 'fired';
+        }
+        return false;
+      })
+      .sort((a, b) =>
+        Date.parse(a.nextAttemptAt) - Date.parse(b.nextAttemptAt) ||
+        a.wakeId.localeCompare(b.wakeId)
+      );
+  }
+
+  async ensureWakeDelivery(input) {
+    return this.#serialized(async () => {
+      const wakeId = String(input.wakeId || '');
+      const sourceType = input.sourceType === 'event' ? 'event' : 'composite';
+      const matchId = String(input.matchId || '');
+      const sourceId = String(input.sourceId || matchId || '');
+      const runtime = String(input.runtime || '');
+      if (!wakeId || !sourceId || !runtime) {
+        throw new Error('Wake delivery requires wakeId, sourceId and runtime');
+      }
+      if (sourceType === 'composite' && !matchId) {
+        throw new Error('Composite wake delivery requires matchId');
+      }
+      const existing = this.#wakeDeliveries.get(wakeId);
+      if (existing) return existing;
+
+      const now = String(input.now ?? new Date().toISOString());
+      const record = {
+        wakeId,
+        sourceType,
+        sourceId,
+        matchId,
+        triggerId: String(input.triggerId || ''),
+        triggerVersion: String(input.triggerVersion || '1'),
+        runtime,
+        status: 'pending',
+        attemptCount: 0,
+        nextAttemptAt: now,
+        leaseOwner: null,
+        leaseUntil: null,
+        runtimeReceiptId: null,
+        lastError: null,
+        createdAt: now,
+        updatedAt: now,
+      };
+      this.#wakeDeliveries.set(wakeId, record);
+      await appendFile(
+        this.files.wakeDeliveries,
+        `${JSON.stringify(record)}\n`,
+        'utf8',
+      );
+      return record;
+    });
+  }
+
+  async claimWakeDelivery(wakeIdInput, {
+    workerId,
+    now = new Date().toISOString(),
+    leaseMs = 30000,
+  } = {}) {
+    return this.#serialized(async () => {
+      const wakeId = String(wakeIdInput || '');
+      const owner = String(workerId || '');
+      if (!wakeId || !owner) {
+        throw new Error('Wake delivery claim requires wakeId and workerId');
+      }
+      const current = this.#wakeDeliveries.get(wakeId);
+      if (!current) return null;
+      if (current.status === 'delivered' || current.status === 'dead_letter') {
+        return null;
+      }
+
+      const nowMs = Date.parse(now);
+      const ready =
+        (
+          (current.status === 'pending' || current.status === 'retry_pending') &&
+          Date.parse(current.nextAttemptAt) <= nowMs
+        ) ||
+        (
+          current.status === 'claimed' &&
+          current.leaseUntil &&
+          Date.parse(current.leaseUntil) <= nowMs
+        );
+      if (!ready) return null;
+
+      const record = {
+        ...current,
+        status: 'claimed',
+        attemptCount: current.attemptCount + 1,
+        leaseOwner: owner,
+        leaseUntil: new Date(nowMs + Math.max(1000, Number(leaseMs) || 30000)).toISOString(),
+        updatedAt: now,
+      };
+      this.#wakeDeliveries.set(wakeId, record);
+      await appendFile(
+        this.files.wakeDeliveries,
+        `${JSON.stringify(record)}\n`,
+        'utf8',
+      );
+      return record;
+    });
+  }
+
+  async completeWakeDelivery(wakeIdInput, {
+    workerId,
+    runtimeReceiptId,
+    now = new Date().toISOString(),
+  } = {}) {
+    return this.#serialized(async () => {
+      const wakeId = String(wakeIdInput || '');
+      const current = this.#wakeDeliveries.get(wakeId);
+      if (!current) return null;
+      if (current.status === 'delivered') return current;
+      if (
+        current.status !== 'claimed' ||
+        current.leaseOwner !== String(workerId || '')
+      ) {
+        const error = new Error(`Wake delivery ${wakeId} is not owned by this worker`);
+        error.code = 'WAKE_DELIVERY_CLAIM_LOST';
+        throw error;
+      }
+
+      const record = {
+        ...current,
+        status: 'delivered',
+        runtimeReceiptId: String(runtimeReceiptId || ''),
+        leaseOwner: null,
+        leaseUntil: null,
+        nextAttemptAt: now,
+        lastError: null,
+        updatedAt: now,
+      };
+      this.#wakeDeliveries.set(wakeId, record);
+      await appendFile(
+        this.files.wakeDeliveries,
+        `${JSON.stringify(record)}\n`,
+        'utf8',
+      );
+      return record;
+    });
+  }
+
+  async failWakeDelivery(wakeIdInput, {
+    workerId,
+    error,
+    now = new Date().toISOString(),
+    maxAttempts = 5,
+    nextAttemptAt = now,
+  } = {}) {
+    return this.#serialized(async () => {
+      const wakeId = String(wakeIdInput || '');
+      const current = this.#wakeDeliveries.get(wakeId);
+      if (!current) return null;
+      if (
+        current.status !== 'claimed' ||
+        current.leaseOwner !== String(workerId || '')
+      ) {
+        const claimError = new Error(
+          `Wake delivery ${wakeId} is not owned by this worker`,
+        );
+        claimError.code = 'WAKE_DELIVERY_CLAIM_LOST';
+        throw claimError;
+      }
+
+      const terminal = current.attemptCount >= Math.max(1, Number(maxAttempts) || 5);
+      const record = {
+        ...current,
+        status: terminal ? 'dead_letter' : 'retry_pending',
+        leaseOwner: null,
+        leaseUntil: null,
+        nextAttemptAt: terminal ? now : String(nextAttemptAt),
+        lastError: error instanceof Error ? error.message : String(error || 'wake delivery failed'),
+        updatedAt: now,
+      };
+      this.#wakeDeliveries.set(wakeId, record);
+      await appendFile(
+        this.files.wakeDeliveries,
+        `${JSON.stringify(record)}\n`,
+        'utf8',
+      );
+      return record;
+    });
+  }
+
   async putTrigger(definitionInput) {
     return this.#serialized(async () => {
       const definition = parseCompositeTriggerDefinition(definitionInput);

package/scripts/lib/wake-retry-scheduler.mjs

@@ -0,0 +1,94 @@
+export class WakeRetryScheduler {
+  constructor({
+    store,
+    resolveCoordinator,
+    eventProcessor = null,
+    intervalMs = 1000,
+    now = () => new Date(),
+  }) {
+    this.store = store;
+    this.resolveCoordinator = resolveCoordinator;
+    this.eventProcessor = eventProcessor;
+    this.intervalMs = Math.max(100, Number(intervalMs) || 1000);
+    this.now = now;
+    this.timer = null;
+    this.running = false;
+  }
+
+  async runDue() {
+    if (this.running) return [];
+    this.running = true;
+    try {
+      const due = this.store.listDueWakeDeliveries(this.now().toISOString());
+      const outcomes = [];
+
+      for (const delivery of due) {
+        if (delivery.sourceType === 'event') {
+          if (!this.eventProcessor || typeof this.eventProcessor.retryWake !== 'function') {
+            outcomes.push({
+              wakeId: delivery.wakeId,
+              status: 'event_processor_unconfigured',
+            });
+            continue;
+          }
+          const result = await this.eventProcessor.retryWake(delivery.wakeId);
+          outcomes.push({
+            wakeId: delivery.wakeId,
+            status: result.status,
+          });
+          continue;
+        }
+
+        const coordinator = this.resolveCoordinator(delivery.runtime);
+        if (!coordinator) {
+          outcomes.push({
+            wakeId: delivery.wakeId,
+            status: 'runtime_unconfigured',
+          });
+          continue;
+        }
+
+        const match = this.store.listTriggerMatches(delivery.triggerId)
+          .filter((candidate) => candidate.matchId === delivery.matchId)
+          .sort((a, b) => Date.parse(b.updatedAt) - Date.parse(a.updatedAt))[0];
+
+        if (!match) {
+          outcomes.push({
+            wakeId: delivery.wakeId,
+            status: 'match_missing',
+          });
+          continue;
+        }
+
+        const result = await coordinator.deliverMatched(match);
+        outcomes.push({
+          wakeId: delivery.wakeId,
+          status: result.status,
+        });
+      }
+
+      return outcomes;
+    } finally {
+      this.running = false;
+    }
+  }
+
+  start() {
+    if (this.timer) return;
+    this.timer = setInterval(() => {
+      this.runDue().catch((error) => {
+        console.error(JSON.stringify({
+          message: 'wake_retry_scheduler_error',
+          error: error instanceof Error ? error.message : String(error),
+        }));
+      });
+    }, this.intervalMs);
+    this.timer.unref?.();
+  }
+
+  stop() {
+    if (!this.timer) return;
+    clearInterval(this.timer);
+    this.timer = null;
+  }
+}

package/scripts/mcp-stdio-server.mjs

@@ -341,7 +341,7 @@ export async function buildEventIntelligenceMcpServer({
   const server = new McpServer(
     {
       name: 'mcp-event-intelligence',
-      version: '0.1.1',
+      version: '0.2.0',
     },
     {
       instructions:

package/scripts/service.mjs

@@ -49,6 +49,9 @@ import {
 import {
   TemporalDeadlineScheduler,
 } from './lib/temporal-deadline-scheduler.mjs';
+import {
+  WakeRetryScheduler,
+} from './lib/wake-retry-scheduler.mjs';
 
 const port = Number(process.env.PORT ?? 3000);
 const dataDir = process.env.DATA_DIR ?? './data';
@@ -66,10 +69,18 @@ const wakeDeliverer = createHttpWakeDeliverer(
   process.env.RUNTIME_WAKE_URL ?? '',
 );
 
+const deliveryOptions = {
+  leaseMs: Number(process.env.WAKE_DELIVERY_LEASE_MS ?? 30000),
+  maxAttempts: Number(process.env.WAKE_DELIVERY_MAX_ATTEMPTS ?? 5),
+  retryBaseDelayMs: Number(process.env.WAKE_RETRY_BASE_DELAY_MS ?? 1000),
+  retryMaxDelayMs: Number(process.env.WAKE_RETRY_MAX_DELAY_MS ?? 60000),
+};
+
 const processor = new EventProcessor({
   store,
   evaluator,
   wakeDeliverer,
+  ...deliveryOptions,
 });
 const compositeTriggers = new CompositeTriggerEngine(store, evaluator);
 const runtimeWakeTargets = readRuntimeWakeTargets(
@@ -83,6 +94,7 @@ const wakeCoordinators = new Map(
       triggerEngine: compositeTriggers,
       deliverer: createSignedRuntimeWakeDeliverer(target),
       packetBuilder: buildGenericRuntimeWakePacket,
+      ...deliveryOptions,
     }),
   ]),
 );
@@ -102,6 +114,14 @@ const temporalScheduler = new TemporalDeadlineScheduler({
 });
 temporalScheduler.start();
 
+const wakeRetryScheduler = new WakeRetryScheduler({
+  store,
+  eventProcessor: processor,
+  resolveCoordinator: (runtime) => wakeCoordinators.get(runtime) ?? null,
+  intervalMs: Number(process.env.WAKE_RETRY_TICK_MS ?? 1000),
+});
+wakeRetryScheduler.start();
+
 const triggerControl = new TriggerControlPlane({
   store,
   triggerEngine: compositeTriggers,

package/server.json

@@ -3,7 +3,7 @@
   "name": "io.github.sarooo17/event-intelligence",
   "title": "MCP Event Intelligence",
   "description": "Durable temporal event intelligence: composite triggers, derived events, and runtime wakeups.",
-  "version": "0.1.1",
+  "version": "0.2.0",
   "repository": {
     "url": "https://github.com/sarooo17/event-intelligence",
     "source": "github"
@@ -13,7 +13,7 @@
       "registryType": "npm",
       "registryBaseUrl": "https://registry.npmjs.org",
       "identifier": "mcp-event-intelligence",
-      "version": "0.1.1",
+      "version": "0.2.0",
       "transport": {
         "type": "stdio"
       },