mcp-event-intelligence 0.1.1 → 0.2.1

package/scripts/lib/local-event-intelligence-runtime.mjs

@@ -22,7 +22,9 @@ import {
   TriggerControlPlane,
 } from './trigger-control-plane.mjs';
 import {
+  DEFAULT_EVENT_SCOPE_ID,
   PersistentEventStore,
+  normalizeEventScopeId,
 } from './persistent-event-store.mjs';
 import {
   TriggerInspector,
@@ -33,6 +35,66 @@ import {
 import {
   McpEventsClientManager,
 } from './mcp-events-client.mjs';
+import {
+  WakeRetryScheduler,
+} from './wake-retry-scheduler.mjs';
+
+const REQUIRED_STORE_METHODS = [
+  'putTrigger',
+  'listTriggers',
+  'getTriggerState',
+  'setTriggerState',
+  'appendTriggerMatch',
+  'listTriggerMatches',
+  'putEventSource',
+  'listEventSources',
+  'appendWake',
+  'latestWake',
+  'ensureWakeDelivery',
+  'getWakeDelivery',
+  'claimWakeDelivery',
+  'completeWakeDelivery',
+  'failWakeDelivery',
+  'listDueWakeDeliveries',
+  'appendAudit',
+  'auditLength',
+  'getMcpClientState',
+  'putMcpClientState',
+  'appendMcpOccurrence',
+];
+
+function assertStoreContract(store) {
+  if (!store || typeof store !== 'object') {
+    throw new Error('Event Intelligence store must be an object');
+  }
+  const missing = REQUIRED_STORE_METHODS.filter(
+    (method) => typeof store[method] !== 'function',
+  );
+  if (missing.length) {
+    const error = new Error(
+      `Event Intelligence store is missing required methods: ${missing.join(', ')}`,
+    );
+    error.code = 'EVENT_INTELLIGENCE_STORE_INVALID';
+    throw error;
+  }
+  return store;
+}
+
+async function initializeStore(store) {
+  const restored =
+    typeof store.init === 'function'
+      ? await store.init()
+      : {};
+  assertStoreContract(store);
+  return restored;
+}
+
+function scopedPacketBuilder(scopeId) {
+  return (input) => ({
+    ...buildGenericRuntimeWakePacket(input),
+    scope_id: scopeId,
+  });
+}
 
 export async function createLocalEventIntelligenceRuntime({
   env = process.env,
@@ -40,10 +102,11 @@ export async function createLocalEventIntelligenceRuntime({
   wakeHandlers = {},
   wake,
   semanticEvaluator,
+  store: providedStore,
 } = {}) {
   const dataDir = env.DATA_DIR ?? './data';
-  const store = new PersistentEventStore(dataDir);
-  const restored = await store.init();
+  const rootStore = providedStore ?? new PersistentEventStore(dataDir);
+  const restored = await initializeStore(rootStore);
 
   const evaluator =
     semanticEvaluator !== undefined
@@ -52,42 +115,106 @@ export async function createLocalEventIntelligenceRuntime({
         ? TypeSafeJevEvaluator.fromEnvironment(env)
         : null;
 
-  const triggerEngine = new CompositeTriggerEngine(store, evaluator);
-
-  const wakeCoordinators = new Map();
-
   const runtimeWakeTargets = readRuntimeWakeTargets(
     env.RUNTIME_WAKE_TARGETS_JSON,
   );
-  for (const [runtime, target] of runtimeWakeTargets) {
-    wakeCoordinators.set(
-      runtime,
-      new CompositeWakeCoordinator({
-        store,
-        triggerEngine,
-        deliverer: createSignedRuntimeWakeDeliverer(target),
-        packetBuilder: buildGenericRuntimeWakePacket,
-      }),
-    );
-  }
-
   const hostWakeEntries =
     wakeHandlers instanceof Map
       ? [...wakeHandlers.entries()]
       : Object.entries(wakeHandlers || {});
 
+  if (wake !== undefined && typeof wake !== 'function') {
+    throw new Error('Host wake dispatcher must be a function');
+  }
   for (const [runtime, handler] of hostWakeEntries) {
     if (typeof handler !== 'function') {
       throw new Error(`Host wake handler for ${runtime} must be a function`);
     }
-    wakeCoordinators.set(
-      runtime,
-      new CompositeWakeCoordinator({
+  }
+
+  const scopeContexts = new Map();
+
+  const createScopeContext = async (scopeIdInput = DEFAULT_EVENT_SCOPE_ID) => {
+    const scopeId = normalizeEventScopeId(scopeIdInput);
+    const cached = scopeContexts.get(scopeId);
+    if (cached) return cached;
+
+    let store;
+    if (scopeId === DEFAULT_EVENT_SCOPE_ID) {
+      store = rootStore;
+    } else {
+      if (typeof rootStore.forScope !== 'function') {
+        const error = new Error(
+          `Configured Event Intelligence store does not support scope ${scopeId}`,
+        );
+        error.code = 'EVENT_INTELLIGENCE_STORE_SCOPE_UNSUPPORTED';
+        throw error;
+      }
+      store = await rootStore.forScope(scopeId);
+      assertStoreContract(store);
+    }
+
+    const triggerEngine = new CompositeTriggerEngine(store, evaluator);
+    const wakeCoordinators = new Map();
+    const packetBuilder = scopedPacketBuilder(scopeId);
+    const deliveryOptions = {
+      leaseMs: Number(env.WAKE_DELIVERY_LEASE_MS ?? 30000),
+      maxAttempts: Number(env.WAKE_DELIVERY_MAX_ATTEMPTS ?? 5),
+      retryBaseDelayMs: Number(env.WAKE_RETRY_BASE_DELAY_MS ?? 1000),
+      retryMaxDelayMs: Number(env.WAKE_RETRY_MAX_DELAY_MS ?? 60000),
+    };
+
+    for (const [runtime, target] of runtimeWakeTargets) {
+      wakeCoordinators.set(
+        runtime,
+        new CompositeWakeCoordinator({
+          store,
+          triggerEngine,
+          deliverer: createSignedRuntimeWakeDeliverer(target),
+          packetBuilder,
+          ...deliveryOptions,
+        }),
+      );
+    }
+
+    for (const [runtime, handler] of hostWakeEntries) {
+      wakeCoordinators.set(
+        runtime,
+        new CompositeWakeCoordinator({
+          store,
+          triggerEngine,
+          packetBuilder,
+          ...deliveryOptions,
+          deliverer: async (packet) => {
+            const result = await handler(packet);
+            if (typeof result === 'string' && result) {
+              return { runtimeReceiptId: result };
+            }
+            if (
+              result &&
+              typeof result === 'object' &&
+              typeof result.runtimeReceiptId === 'string' &&
+              result.runtimeReceiptId
+            ) {
+              return result;
+            }
+            throw new Error(
+              `Host wake handler for ${runtime} must return runtimeReceiptId`,
+            );
+          },
+        }),
+      );
+    }
+
+    let wakeCoordinator = null;
+    if (wake) {
+      wakeCoordinator = new CompositeWakeCoordinator({
         store,
         triggerEngine,
-        packetBuilder: buildGenericRuntimeWakePacket,
+        packetBuilder,
+        ...deliveryOptions,
         deliverer: async (packet) => {
-          const result = await handler(packet);
+          const result = await wake(packet);
           if (typeof result === 'string' && result) {
             return { runtimeReceiptId: result };
           }
@@ -99,70 +226,84 @@ export async function createLocalEventIntelligenceRuntime({
           ) {
             return result;
           }
-          throw new Error(
-            `Host wake handler for ${runtime} must return runtimeReceiptId`,
-          );
+          throw new Error('Host wake dispatcher must return runtimeReceiptId');
         },
-      }),
-    );
-  }
-
-  let wakeCoordinator = null;
-  if (wake !== undefined) {
-    if (typeof wake !== 'function') {
-      throw new Error('Host wake dispatcher must be a function');
+      });
     }
-    wakeCoordinator = new CompositeWakeCoordinator({
+
+    const derivedEventCoordinator = new DerivedEventCoordinator({ store });
+    const compositeEventConsumer = new CompositeEventConsumer({
       store,
       triggerEngine,
-      packetBuilder: buildGenericRuntimeWakePacket,
-      deliverer: async (packet) => {
-        const result = await wake(packet);
-        if (typeof result === 'string' && result) {
-          return { runtimeReceiptId: result };
-        }
-        if (
-          result &&
-          typeof result === 'object' &&
-          typeof result.runtimeReceiptId === 'string' &&
-          result.runtimeReceiptId
-        ) {
-          return result;
-        }
-        throw new Error('Host wake dispatcher must return runtimeReceiptId');
-      },
+      wakeCoordinator,
+      wakeCoordinators,
+      derivedEventCoordinator,
+      maxDerivedDepth: Number(env.MAX_DERIVED_EVENT_DEPTH ?? 16),
     });
-  }
 
-  const derivedEventCoordinator = new DerivedEventCoordinator({ store });
-  const compositeEventConsumer = new CompositeEventConsumer({
-    store,
-    triggerEngine,
-    wakeCoordinator,
-    wakeCoordinators,
-    derivedEventCoordinator,
-    maxDerivedDepth: Number(env.MAX_DERIVED_EVENT_DEPTH ?? 16),
-  });
+    const temporalScheduler = new TemporalDeadlineScheduler({
+      store,
+      compositeEventConsumer,
+      intervalMs: Number(env.TEMPORAL_TICK_MS ?? 1000),
+    });
+    temporalScheduler.start();
 
-  const temporalScheduler = new TemporalDeadlineScheduler({
-    store,
-    compositeEventConsumer,
-    intervalMs: Number(env.TEMPORAL_TICK_MS ?? 1000),
-  });
-  temporalScheduler.start();
+    const triggerControl = new TriggerControlPlane({
+      store,
+      triggerEngine,
+    });
+    const triggerInspector = new TriggerInspector({ store });
 
-  const triggerControl = new TriggerControlPlane({
-    store,
-    triggerEngine,
-  });
-  const triggerInspector = new TriggerInspector({ store });
+    const coordinatorFor = (runtime) =>
+      wakeCoordinators.get(runtime) ?? wakeCoordinator;
+    const wakeRetryScheduler = new WakeRetryScheduler({
+      store,
+      resolveCoordinator: coordinatorFor,
+      intervalMs: Number(env.WAKE_RETRY_TICK_MS ?? 1000),
+    });
+    wakeRetryScheduler.start();
+
+    const context = {
+      scopeId,
+      store,
+      evaluator,
+      triggerEngine,
+      triggerControl,
+      triggerInspector,
+      compositeEventConsumer,
+      temporalScheduler,
+      wakeRetryScheduler,
+      wakeCoordinator,
+      wakeCoordinators,
+      async close() {
+        await Promise.all([
+          temporalScheduler.close(),
+          wakeRetryScheduler.close(),
+        ]);
+      },
+    };
+    scopeContexts.set(scopeId, context);
+    return context;
+  };
+
+  const defaultContext = await createScopeContext(DEFAULT_EVENT_SCOPE_ID);
+
+  if (typeof rootStore.listScopeIds === 'function') {
+    const restoredScopes = await rootStore.listScopeIds();
+    for (const scopeId of restoredScopes) {
+      if (scopeId !== DEFAULT_EVENT_SCOPE_ID) {
+        await createScopeContext(scopeId);
+      }
+    }
+  }
 
   const mcpEventsClient = new McpEventsClientManager({
-    store,
-    compositeEventConsumer,
+    store: defaultContext.store,
+    compositeEventConsumer: defaultContext.compositeEventConsumer,
+    resolveScope: createScopeContext,
     connections: mcpEventConnections,
     registerEventSource: (source) =>
-      triggerControl.registerEventSource(
+      defaultContext.triggerControl.registerEventSource(
         source,
         {
           type: 'system',
@@ -176,18 +317,32 @@ export async function createLocalEventIntelligenceRuntime({
 
   return {
     restored,
-    store,
+    store: defaultContext.store,
     evaluator,
-    triggerEngine,
-    triggerControl,
-    triggerInspector,
-    compositeEventConsumer,
-    temporalScheduler,
+    triggerEngine: defaultContext.triggerEngine,
+    triggerControl: defaultContext.triggerControl,
+    triggerInspector: defaultContext.triggerInspector,
+    compositeEventConsumer: defaultContext.compositeEventConsumer,
+    temporalScheduler: defaultContext.temporalScheduler,
     mcpEventsClient,
     discovery,
+    scope: createScopeContext,
+    loadedScopes() {
+      return [...scopeContexts.keys()].sort();
+    },
     async close() {
-      temporalScheduler.stop();
-      mcpEventsClient.stop();
+      await mcpEventsClient.close();
+      const contexts = [...scopeContexts.values()];
+      await Promise.all(contexts.map((context) => context.close()));
+
+      const stores = new Set(contexts.map((context) => context.store));
+      for (const store of stores) {
+        if (typeof store.close === 'function') {
+          await store.close();
+        } else if (typeof store.drain === 'function') {
+          await store.drain();
+        }
+      }
     },
   };
 }