@reventlessdev/reventless-local 3.0.0-alpha.113

package/src/adapter/DomainMCP_Server.res.mjs

@@ -0,0 +1,358 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as S from "sury/src/S.res.mjs";
+import * as Http from "http";
+import * as Stdlib_JsExn from "@rescript/runtime/lib/es6/Stdlib_JsExn.js";
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as McpSdk_Helpers from "@reventlessdev/rescript-mcp-sdk/src/McpSdk_Helpers.res.mjs";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as Identity$Reventless from "@reventlessdev/reventless-spec/src/types/Identity.res.mjs";
+import * as Primitive_exceptions from "@rescript/runtime/lib/es6/Primitive_exceptions.js";
+import * as Logger$ReventlessCore from "@reventlessdev/reventless-core/src/util/Logger.res.mjs";
+import * as MCP_SchemaGenerator$ReventlessCore from "@reventlessdev/reventless-core/src/components/Api/MCP_SchemaGenerator.res.mjs";
+import * as IndexJs from "@modelcontextprotocol/sdk/server/index.js";
+import * as StreamableHttpJs from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+
+let log = Logger$ReventlessCore.fromEnv();
+
+let tools = {
+  contents: {}
+};
+
+let resources = {
+  contents: {}
+};
+
+let resourceTemplates = {
+  contents: {}
+};
+
+function registerTool(name, definition, handler) {
+  tools.contents[name] = {
+    definition: definition,
+    handler: handler
+  };
+}
+
+function registerResource(name, definition, handler) {
+  resources.contents[name] = {
+    definition: definition,
+    handler: handler
+  };
+}
+
+function registerResourceTemplate(name, definition, handler) {
+  resourceTemplates.contents[name] = {
+    definition: definition,
+    handler: handler
+  };
+}
+
+function registerToolsFromEntries(pluginName, mutationEntries, commandHandler) {
+  let toolDefs = MCP_SchemaGenerator$ReventlessCore.generateTools(pluginName, mutationEntries);
+  toolDefs.forEach(def => {
+    let handler = async (args, identity) => {
+      try {
+        return McpSdk_Helpers.toolResult(await commandHandler(def.name, args, identity));
+      } catch (raw_exn) {
+        let exn = Primitive_exceptions.internalToException(raw_exn);
+        return McpSdk_Helpers.toolError(Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "Command failed"));
+      }
+    };
+    registerTool(def.name, def, handler);
+  });
+}
+
+function registerResourcesFromEntries(pluginName, queryEntries, queryHandler) {
+  let resourceDefs = MCP_SchemaGenerator$ReventlessCore.generateResources(pluginName, queryEntries);
+  resourceDefs.forEach(def => {
+    let handler = async uri => {
+      let result = await queryHandler(def.name, uri);
+      return {
+        contents: [{
+            uri: uri,
+            text: JSON.stringify(result)
+          }]
+      };
+    };
+    if (def.uriTemplate.includes("{")) {
+      return registerResourceTemplate(def.name, def, handler);
+    } else {
+      return registerResource(def.name, def, handler);
+    }
+  });
+}
+
+function registerEventHistoryResourcesFromEntries(pluginName, eventLogEntries, eventLogHandler) {
+  let resourceDefs = MCP_SchemaGenerator$ReventlessCore.generateEventHistoryResources(pluginName, eventLogEntries);
+  resourceDefs.forEach(def => {
+    let handler = async uri => {
+      let result = await eventLogHandler(def.name, uri);
+      return {
+        contents: [{
+            uri: uri,
+            text: JSON.stringify(result)
+          }]
+      };
+    };
+    registerResourceTemplate(def.name, def, handler);
+  });
+}
+
+let activeServer = {
+  contents: undefined
+};
+
+let debug = Stdlib_Option.isSome(process.env["MCP_DEBUG"]);
+
+function extractIdentity(req) {
+  try {
+    let headers = req.headers;
+    let json = headers["x-identity"];
+    if (json !== undefined) {
+      return S.parseOrThrow(JSON.parse(json), Identity$Reventless.schema);
+    } else {
+      return Identity$Reventless.anonymous;
+    }
+  } catch (exn) {
+    return Identity$Reventless.anonymous;
+  }
+}
+
+function createServerInstance(identity) {
+  let server = new IndexJs.Server({
+    name: "reventless-mcp",
+    version: "1.0.0"
+  }, {
+    capabilities: {
+      tools: {
+        _placeholder: false
+      },
+      resources: {
+        _placeholder: false
+      }
+    }
+  });
+  McpSdk_Helpers.onListTools(server, async () => {
+    let toolDefs = Object.values(tools.contents).map(param => {
+      let definition = param.definition;
+      return {
+        name: definition.name,
+        description: definition.description,
+        inputSchema: definition.inputSchema
+      };
+    });
+    return {
+      tools: toolDefs
+    };
+  });
+  McpSdk_Helpers.onCallTool(server, async req => {
+    let toolName = req.params.name;
+    let args = Stdlib_Option.getOr(req.params.arguments, null);
+    if (debug) {
+      log.info("MCP:Domain", undefined, `tools/call: ` + toolName);
+    }
+    let match = tools.contents[toolName];
+    if (match !== undefined) {
+      return await match.handler(args, identity);
+    } else {
+      return McpSdk_Helpers.toolError(`Unknown tool: ` + toolName);
+    }
+  });
+  McpSdk_Helpers.onListResources(server, async () => {
+    let resourceDefs = Object.values(resources.contents).map(param => {
+      let definition = param.definition;
+      return {
+        uri: definition.uriTemplate,
+        name: definition.name,
+        description: definition.description,
+        mimeType: definition.mimeType
+      };
+    });
+    return {
+      resources: resourceDefs
+    };
+  });
+  McpSdk_Helpers.onListResourceTemplates(server, async () => {
+    let templateDefs = Object.values(resourceTemplates.contents).map(param => {
+      let definition = param.definition;
+      return {
+        uriTemplate: definition.uriTemplate,
+        name: definition.name,
+        description: definition.description,
+        mimeType: definition.mimeType
+      };
+    });
+    return {
+      resourceTemplates: templateDefs
+    };
+  });
+  McpSdk_Helpers.onReadResource(server, async req => {
+    let uri = req.params.uri;
+    if (debug) {
+      log.info("MCP:Domain", undefined, `resources/read: ` + uri);
+    }
+    let matchedResource = Object.values(resources.contents).find(param => uri.includes(param.definition.name));
+    if (matchedResource !== undefined) {
+      if (debug) {
+        log.debug("MCP:Domain", undefined, `matched resource: ` + matchedResource.definition.name);
+      }
+      return await matchedResource.handler(uri);
+    }
+    let matchedTemplate = Object.values(resourceTemplates.contents).find(param => uri.includes(param.definition.name));
+    if (matchedTemplate !== undefined) {
+      if (debug) {
+        log.debug("MCP:Domain", undefined, `matched template: ` + matchedTemplate.definition.name);
+      }
+      return await matchedTemplate.handler(uri);
+    } else {
+      return {
+        contents: [{
+            uri: uri,
+            text: `{"error": "Resource not found: ` + uri + `"}`
+          }]
+      };
+    }
+  });
+  return server;
+}
+
+function start(portOpt, param) {
+  let port = portOpt !== undefined ? portOpt : 3001;
+  let httpServer = Http.createServer((req, res) => {
+    (async () => {
+      let reqMethod = req.method;
+      let reqUrl = req.url;
+      res.setHeader("Access-Control-Allow-Origin", "*");
+      res.setHeader("Access-Control-Allow-Methods", "GET, POST, DELETE, OPTIONS");
+      res.setHeader("Access-Control-Allow-Headers", "Content-Type");
+      if (reqUrl === "/mcp" || reqUrl.startsWith("/mcp?")) {
+        switch (reqMethod) {
+          case "DELETE" :
+            res.statusCode = 200;
+            res.end();
+            return;
+          case "GET" :
+            res.setHeader("Content-Type", "text/plain");
+            res.end("MCP server running");
+            return;
+          case "OPTIONS" :
+            res.statusCode = 204;
+            res.end();
+            return;
+          case "POST" :
+            let body = await McpSdk_Helpers.parseJsonBody(req);
+            let identity = extractIdentity(req);
+            let server = createServerInstance(identity);
+            let transport = new StreamableHttpJs.StreamableHTTPServerTransport({
+              enableJsonResponse: true
+            });
+            await server.connect(transport);
+            await transport.handleRequest(req, res, body);
+            return;
+          default:
+            res.statusCode = 405;
+            res.end("Method not allowed");
+            return;
+        }
+      } else {
+        res.statusCode = 404;
+        res.end("Not found");
+        return;
+      }
+    })();
+  });
+  httpServer.listen(port, () => {
+    log.info("MCP:Domain", undefined, `listening on http://localhost:` + port.toString() + `/mcp`);
+    if (!debug) {
+      return;
+    }
+    let toolNames = Object.keys(tools.contents);
+    let resourceNames = Object.keys(resources.contents);
+    let templateNames = Object.keys(resourceTemplates.contents);
+    log.info("MCP:Domain", undefined, `tools (` + toolNames.length.toString() + `):`);
+    toolNames.forEach(t => log.info("MCP:Domain", undefined, `  - ` + t));
+    log.info("MCP:Domain", undefined, `resources (` + resourceNames.length.toString() + `):`);
+    resourceNames.forEach(r => log.info("MCP:Domain", undefined, `  - ` + r));
+    log.info("MCP:Domain", undefined, `resource templates (` + templateNames.length.toString() + `):`);
+    templateNames.forEach(r => log.info("MCP:Domain", undefined, `  - ` + r));
+  });
+  activeServer.contents = Primitive_option.some(httpServer);
+}
+
+function stop() {
+  let server = activeServer.contents;
+  if (server !== undefined) {
+    Primitive_option.valFromOption(server).close(() => {});
+    activeServer.contents = undefined;
+    return;
+  }
+}
+
+function reset() {
+  tools.contents = {};
+  resources.contents = {};
+  resourceTemplates.contents = {};
+}
+
+function diagnostics() {
+  let toolNames = Object.keys(tools.contents);
+  let resourceNames = Object.keys(resources.contents).concat(Object.keys(resourceTemplates.contents));
+  return {
+    registeredTools: toolNames,
+    registeredResources: resourceNames,
+    toolCount: toolNames.length,
+    resourceCount: resourceNames.length,
+    serverRunning: Stdlib_Option.isSome(activeServer.contents)
+  };
+}
+
+function printDiagnostics() {
+  let d = diagnostics();
+  log.info("MCP:Domain", undefined, "diagnostics");
+  log.info("MCP:Domain", undefined, `  tools (` + d.toolCount.toString() + `):`);
+  d.registeredTools.forEach(t => log.info("MCP:Domain", undefined, `    - ` + t));
+  log.info("MCP:Domain", undefined, `  resources (` + d.resourceCount.toString() + `):`);
+  d.registeredResources.forEach(r => log.info("MCP:Domain", undefined, `    - ` + r));
+  log.info("MCP:Domain", undefined, `  server running: ` + (
+    d.serverRunning ? "yes" : "no"
+  ));
+}
+
+let asInterface = {
+  registerTool: registerTool,
+  registerResource: registerResource,
+  registerResourceTemplate: registerResourceTemplate,
+  registerToolsFromEntries: registerToolsFromEntries,
+  registerResourcesFromEntries: registerResourcesFromEntries,
+  registerEventHistoryResourcesFromEntries: registerEventHistoryResourcesFromEntries,
+  start: start,
+  stop: stop,
+  reset: reset,
+  diagnostics: diagnostics,
+  printDiagnostics: printDiagnostics
+};
+
+export {
+  log,
+  tools,
+  resources,
+  resourceTemplates,
+  registerTool,
+  registerResource,
+  registerResourceTemplate,
+  registerToolsFromEntries,
+  registerResourcesFromEntries,
+  registerEventHistoryResourcesFromEntries,
+  activeServer,
+  debug,
+  extractIdentity,
+  createServerInstance,
+  start,
+  stop,
+  reset,
+  diagnostics,
+  printDiagnostics,
+  asInterface,
+}
+/* log Not a pure module */

package/src/adapter/EventCollector/LocalEventCollectorChannel.res

@@ -0,0 +1,87 @@
+// In-memory EventCollector channel.
+// connect subscribes to all event topics in the bus using the resource name as topic key.
+// Each published event awaits the handler Deferred before delivery — eliminating the race
+// where consumers see None and silently drop events.
+// The runtime's subscriptionLatch is opened after each subscription is registered so
+// callers can await it to know subscriptions are ready before publishing.
+
+module Make = (Bus: LocalBus.T) => {
+  type callbackEvent = JSON.t
+  type channelParts = unit
+  type runtimeParts = LocalRuntimeEnvironment.parts
+
+  let make: ReventlessCore.EventCollector_Adapter.channelMaker<callbackEvent, 'context, channelParts> = (
+    ~name as _,
+    ~eventTopics,
+    ~opts as _,
+  ) => {
+    // Collect all event topic resources as our channel resources
+    let eventTopicResources =
+      eventTopics
+      ->Dict.valuesToArray
+      ->Array.flatMap((outputs: ReventlessCore.EventTopic.outputs) => outputs.resources)
+
+    {
+      parts: (),
+      resources: eventTopicResources,
+      enqueueEvent: ((_, _, _) => Promise.resolve())->Pulumi.Output.make,
+      handleChannelEvent: (handleEvents: ReventlessCore.EventCollector.jsonEventsHandler) =>
+        ((json: JSON.t, _ctx) =>
+          handleEvents(Stream.fromIterable([json]))->Effect.map(_ => ())
+        )->Pulumi.Output.make,
+    }
+  }
+
+  let connect: ReventlessCore.EventCollector_Adapter.connect<
+    callbackEvent,
+    'context,
+    channelParts,
+    runtimeParts,
+  > = (~name, ~channelSpecs, ~runtime, ~opts as _) => {
+    // Register handler in Bus once resolved — allows makePlatform to wire cross-plugin
+    // Extension → EP EventTopic subscriptions after all plugins are built.
+    let _reg =
+      runtime.parts.handlerDeferred
+      ->Deferred.await_
+      ->Effect.flatMap(handler => Effect.sync(() => Bus.registerEventCollectorHandler(name, handler)))
+      ->Effect.runPromise
+      ->ignore
+
+    channelSpecs->Array.forEach(({eventTopics}: ReventlessCore.EventCollector_Adapter.channelSpec<
+      callbackEvent,
+      'context,
+      channelParts,
+    >) => {
+      eventTopics
+      ->Dict.valuesToArray
+      ->Array.forEach((topicOutputs: ReventlessCore.EventTopic.outputs) => {
+        topicOutputs.resources->Array.forEach(resource => {
+          // resource.name is the bus topic key set by LocalEventTopicPublisher
+          let _ = resource.name->Pulumi.Output.apply(topicName => {
+            // Stream-based drain: subscribeToEventStream returns a scoped Effect that
+            // yields Stream<queuedEvent>. done_ is run explicitly after each handler call
+            // to unblock publishEvent.
+            let drainEffect = Effect.scoped(
+              Bus.subscribeToEventStream(topicName)
+              ->Effect.flatMap(stream =>
+                stream->Stream.runForEach(msg =>
+                  Effect.promise(async () => {
+                    let handler =
+                      await runtime.parts.handlerDeferred->Deferred.await_->Effect.runPromise
+                    await handler(msg.json, ())
+                  })
+                  ->Effect.zipRight(msg.done_)
+                )
+              ),
+            )
+            let _ = Effect.runFork(drainEffect)
+            // Signal that this topic's subscription is registered.
+            // Latch.open_ is idempotent — calling it for multiple topics is safe.
+            runtime.parts.subscriptionLatch->Latch.open_->Effect.runPromise->ignore
+          })
+        })
+      })
+    })
+    []
+  }
+}

package/src/adapter/EventCollector/LocalEventCollectorChannel.res.mjs

@@ -0,0 +1,45 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Effect from "effect/Effect";
+import * as Stream from "effect/Stream";
+import * as Pulumi from "@pulumi/pulumi";
+import * as Deferred from "effect/Deferred";
+
+function Make(Bus) {
+  let make = (param, eventTopics, param$1) => {
+    let eventTopicResources = Object.values(eventTopics).flatMap(outputs => outputs.resources);
+    return {
+      parts: undefined,
+      resources: eventTopicResources,
+      enqueueEvent: Pulumi.output((param, param$1, param$2) => Promise.resolve()),
+      handleChannelEvent: handleEvents => Pulumi.output((json, _ctx) => Effect.map(handleEvents(Stream.fromIterable([json])), () => {}))
+    };
+  };
+  let connect = (name, channelSpecs, runtime, param) => {
+    Effect.runPromise(Effect.flatMap(Deferred.await(runtime.parts.handlerDeferred), handler => Effect.sync(() => Bus.registerEventCollectorHandler(name, handler))));
+    channelSpecs.forEach(param => {
+      Object.values(param.eventTopics).forEach(topicOutputs => {
+        topicOutputs.resources.forEach(resource => {
+          resource.name.apply(topicName => {
+            let drainEffect = Effect.scoped(Effect.flatMap(Bus.subscribeToEventStream(topicName), stream => Stream.runForEach(stream, msg => Effect.zipRight(Effect.promise(async () => {
+              let handler = await Effect.runPromise(Deferred.await(runtime.parts.handlerDeferred));
+              return await handler(msg.json, undefined);
+            }), msg.done_))));
+            Effect.runFork(drainEffect);
+            Effect.runPromise(runtime.parts.subscriptionLatch.open);
+          });
+        });
+      });
+    });
+    return [];
+  };
+  return {
+    make: make,
+    connect: connect
+  };
+}
+
+export {
+  Make,
+}
+/* effect/Effect Not a pure module */

package/src/adapter/EventLog/EventLogStorage_InMemory.res

@@ -0,0 +1,105 @@
+// In-memory event log storage.
+// Uses Stm.TRef for transactional state management, preparing for future
+// atomic append+publish spanning storage and the event bus.
+//
+// When BackendState is set to Sqlite, the `Make(Bus)` functor delegates to
+// EventLogStorage_Sqlite at `make` time so the same builder wiring serves
+// both backends.
+
+let makeMemoryStorage = (~name as _name, ~opts as _) => {
+  let eventsRef =
+    Stm.TRef.make(Dict.make())
+    ->Stm.commit
+    ->Effect.runSync
+
+  let append: ReventlessCore.EventLog.append<string, JSON.t> = (seqNr, id, jsons) =>
+    Stm.TRef.modify(eventsRef, events => {
+      let existing = events->Dict.get(id)->Option.getOr([])
+      let currentCount = existing->Array.length
+      if seqNr != currentCount {
+        (Error("conflict"), events)
+      } else {
+        events->Dict.set(id, existing->Array.concat(jsons))
+        (Ok(), events)
+      }
+    })
+    ->Stm.commit
+    ->Effect.runPromise
+
+  // The in-memory array is already resident; expose it as a stream for API uniformity.
+  // The real performance gain from streaming comes from the DynamoDB adapter.
+  let replayStream: string => Stream.t<JSON.t, string, unit> = id =>
+    Stm.TRef.get(eventsRef)
+    ->Stm.commit
+    ->Effect.map(events => events->Dict.get(id)->Option.getOr([]))
+    ->Stream.fromEffect
+    ->Stream.flatMap(arr => Stream.fromIterable(arr))
+
+  // Eager replay derived from replayStream.
+  let replay: ReventlessCore.EventLog.replay<string, JSON.t> = id =>
+    replayStream(id)->Stream.runCollect->Effect.runPromise
+
+  // Appends each stream item sequentially to storage.
+  // Node.js is single-threaded so a plain ref is safe for the seqNr counter.
+  let appendStream: ReventlessCore.EventLog.appendStream<string, JSON.t> = (startingSeqNr, id, stream) => {
+    let seqNrRef = ref(startingSeqNr)
+    stream->Stream.runForEach(json =>
+      Stm.TRef.modify(eventsRef, events => {
+        let existing = events->Dict.get(id)->Option.getOr([])
+        let currentCount = existing->Array.length
+        if seqNrRef.contents != currentCount {
+          (Error("conflict"), events)
+        } else {
+          events->Dict.set(id, existing->Array.concat([json]))
+          (Ok(), events)
+        }
+      })
+      ->Stm.commit
+      ->Effect.flatMap(result =>
+        switch result {
+        | Ok() =>
+          seqNrRef := seqNrRef.contents + 1
+          Effect.succeed(())
+        | Error(msg) => Effect.fail(msg)
+        }
+      )
+    )
+  }
+
+  (
+    _name,
+    replay,
+    {
+      ReventlessCore.EventLog_Adapter.resources: [],
+      operations: Pulumi.Output.make({
+        ReventlessCore.EventLog_Adapter.append,
+        replay,
+        replayStream,
+        appendStream,
+      }),
+    },
+  )
+}
+
+// Alias retained for tests that still want the pure-memory implementation.
+let makeStorage = makeMemoryStorage
+
+let make: ReventlessCore.EventLog_Adapter.storageMaker = (~name, ~opts) => {
+  let (_, _, storage) = makeMemoryStorage(~name, ~opts)
+  storage
+}
+
+module Make = (Bus: LocalBus.T) => {
+  let make: ReventlessCore.EventLog_Adapter.storageMaker = (~name, ~opts) => {
+    switch BackendState.getDb() {
+    | Some(db) =>
+      let (storageName, replay, storage) = EventLogStorage_Sqlite.makeStorage(~db, ~name, ~opts)
+      Bus.registerEventLogReplay(storageName, replay)
+      storage
+    | None =>
+      let (storageName, replay, storage) = makeMemoryStorage(~name, ~opts)
+      Bus.registerEventLogReplay(storageName, replay)
+      storage
+    }
+  }
+}