@reventlessdev/reventless-local 3.0.0-alpha.113

package/src/adapter/MCP_ServerInstance.res.mjs

@@ -0,0 +1,313 @@
+// 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 debug = Stdlib_Option.isSome(process.env["MCP_DEBUG"]);
+
+function make(labelOpt) {
+  let label = labelOpt !== undefined ? labelOpt : "MCP";
+  let tools = {
+    contents: {}
+  };
+  let resources = {
+    contents: {}
+  };
+  let resourceTemplates = {
+    contents: {}
+  };
+  let activeServer = {
+    contents: undefined
+  };
+  let registerTool = (name, definition, handler) => {
+    tools.contents[name] = {
+      definition: definition,
+      handler: handler
+    };
+  };
+  let registerResource = (name, definition, handler) => {
+    resources.contents[name] = {
+      definition: definition,
+      handler: handler
+    };
+  };
+  let registerResourceTemplate = (name, definition, handler) => {
+    resourceTemplates.contents[name] = {
+      definition: definition,
+      handler: handler
+    };
+  };
+  let 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);
+    });
+  };
+  let 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);
+      }
+    });
+  };
+  let 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 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;
+    }
+  };
+  let createServerInstance = identity => {
+    let server = new IndexJs.Server({
+      name: `reventless-` + label.toLowerCase(),
+      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(label, 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(label, undefined, `resources/read: ` + uri);
+      }
+      let matchedResource = Object.values(resources.contents).find(param => uri.includes(param.definition.name));
+      if (matchedResource !== undefined) {
+        if (debug) {
+          log.debug(label, 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(label, undefined, `matched template: ` + matchedTemplate.definition.name);
+        }
+        return await matchedTemplate.handler(uri);
+      } else {
+        return {
+          contents: [{
+              uri: uri,
+              text: `{"error": "Resource not found: ` + uri + `"}`
+            }]
+        };
+      }
+    });
+    return server;
+  };
+  let 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(label + ` 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(label, undefined, `listening on http://localhost:` + port.toString() + `/mcp`));
+    activeServer.contents = Primitive_option.some(httpServer);
+  };
+  let stop = () => {
+    let server = activeServer.contents;
+    if (server !== undefined) {
+      Primitive_option.valFromOption(server).close(() => {});
+      activeServer.contents = undefined;
+      return;
+    }
+  };
+  let reset = () => {
+    tools.contents = {};
+    resources.contents = {};
+    resourceTemplates.contents = {};
+  };
+  let 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)
+    };
+  };
+  let printDiagnostics = () => {
+    let d = diagnostics();
+    log.info(label, undefined, "diagnostics");
+    log.info(label, undefined, `  tools (` + d.toolCount.toString() + `):`);
+    d.registeredTools.forEach(t => log.info(label, undefined, `    - ` + t));
+    log.info(label, undefined, `  resources (` + d.resourceCount.toString() + `):`);
+    d.registeredResources.forEach(r => log.info(label, undefined, `    - ` + r));
+    log.info(label, undefined, `  server running: ` + (
+      d.serverRunning ? "yes" : "no"
+    ));
+  };
+  return {
+    registerTool: registerTool,
+    registerResource: registerResource,
+    registerResourceTemplate: registerResourceTemplate,
+    registerToolsFromEntries: registerToolsFromEntries,
+    registerResourcesFromEntries: registerResourcesFromEntries,
+    registerEventHistoryResourcesFromEntries: registerEventHistoryResourcesFromEntries,
+    start: start,
+    stop: stop,
+    reset: reset,
+    diagnostics: diagnostics,
+    printDiagnostics: printDiagnostics
+  };
+}
+
+export {
+  log,
+  debug,
+  make,
+}
+/* log Not a pure module */

package/src/adapter/PlatformGraphQL_Server.res

@@ -0,0 +1,75 @@
+// Platform (admin-facing) in-memory GraphQL server — singleton.
+// Serves admin/core operations on a separate port in split mode (port 4001).
+//
+// Uses the same GraphQL_ServerInstance factory as the generic instance,
+// but is exposed as a named singleton so Platform.res can reference it
+// directly (mirroring the AWS PlatformAPI resource pattern).
+//
+// Does NOT include Relay-specific features (encodeGlobalId, node resolver)
+// since admin queries are not Relay-paginated.
+//
+// Authorization: every query AND mutation resolver registered here is
+// wrapped with `Auth_GraphqlContext.requireGroup(~group="Admin")` so
+// non-Admin identities raise an `UNAUTHORIZED` GraphQLError before the
+// underlying resolver runs. Mirrors AppSync's
+// `@aws_auth(cognito_groups: ["Admin"])` directive that gates Platform_*
+// fields in the AWS adapter.
+//
+// Mutations are wrapped (in addition to their per-command
+// `commandAuthorization` rule inside `CommandGeneratorResolvers_GraphQL.register`)
+// because the per-command rule defaults to `AllowAuthenticated` and the
+// in-memory adapter falls back to `defaultUser` on missing-bearer requests
+// — without the wrapper, anonymous callers could trigger admin mutations
+// (Plugin_Activate / _Deactivate, etc.) just by hitting the platform port.
+
+let instance: GraphQL_ServerInstance.t = GraphQL_ServerInstance.make(~label="GraphQL:Platform")
+
+// Wrap a resolver dict so every value enforces the Admin group. Keys are
+// preserved; resolvers fall through to the underlying instance once the
+// group check passes.
+let wrapAdmin = (
+  resolvers: dict<GraphQL_ServerInstance.resolverFn>,
+): dict<GraphQL_ServerInstance.resolverFn> => {
+  let wrapped = Dict.make()
+  resolvers->Dict.toArray->Array.forEach(((k, v)) =>
+    wrapped->Dict.set(k, Auth_GraphqlContext.requireGroup(~group="Admin", v))
+  )
+  wrapped
+}
+
+let registerMutations = (~sdlFields, ~resolvers) =>
+  instance.registerMutations(~sdlFields, ~resolvers=wrapAdmin(resolvers))
+let registerQueries = (~sdlFields, ~resolvers) =>
+  instance.registerQueries(~sdlFields, ~resolvers=wrapAdmin(resolvers))
+let registerSubscriptions = instance.registerSubscriptions
+let registerTypes = instance.registerTypes
+let getMutationResolver = instance.getMutationResolver
+let getQueryResolver = instance.getQueryResolver
+let start = instance.start
+let stop = instance.stop
+let reset = instance.reset
+let buildSdl = instance.buildSdl
+let getFullSdl = instance.getFullSdl
+let getSchema = instance.getSchema
+let diagnostics = instance.diagnostics
+let printDiagnostics = instance.printDiagnostics
+
+// Expose as GraphQL_ServerInstance.t for resolveTargetGraphQL() in Platform.res.
+// `registerQueries` is the wrapped version so admin auth fires regardless of
+// whether callers reach the singleton directly or through `asInterface`.
+let asInterface: GraphQL_ServerInstance.t = {
+  registerMutations,
+  registerQueries,
+  registerSubscriptions,
+  registerTypes,
+  getMutationResolver,
+  getQueryResolver,
+  start,
+  stop,
+  reset,
+  buildSdl,
+  getFullSdl,
+  getSchema,
+  diagnostics,
+  printDiagnostics,
+}

package/src/adapter/PlatformGraphQL_Server.res.mjs

@@ -0,0 +1,84 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Auth_GraphqlContext$ReventlessLocal from "./Auth/Auth_GraphqlContext.res.mjs";
+import * as GraphQL_ServerInstance$ReventlessLocal from "./GraphQL_ServerInstance.res.mjs";
+
+let instance = GraphQL_ServerInstance$ReventlessLocal.make("GraphQL:Platform");
+
+function wrapAdmin(resolvers) {
+  let wrapped = {};
+  Object.entries(resolvers).forEach(param => {
+    wrapped[param[0]] = Auth_GraphqlContext$ReventlessLocal.requireGroup("Admin", param[1]);
+  });
+  return wrapped;
+}
+
+function registerMutations(sdlFields, resolvers) {
+  instance.registerMutations(sdlFields, wrapAdmin(resolvers));
+}
+
+function registerQueries(sdlFields, resolvers) {
+  instance.registerQueries(sdlFields, wrapAdmin(resolvers));
+}
+
+let registerSubscriptions = instance.registerSubscriptions;
+
+let registerTypes = instance.registerTypes;
+
+let getMutationResolver = instance.getMutationResolver;
+
+let getQueryResolver = instance.getQueryResolver;
+
+let start = instance.start;
+
+let stop = instance.stop;
+
+let reset = instance.reset;
+
+let buildSdl = instance.buildSdl;
+
+let getFullSdl = instance.getFullSdl;
+
+let getSchema = instance.getSchema;
+
+let diagnostics = instance.diagnostics;
+
+let printDiagnostics = instance.printDiagnostics;
+
+let asInterface = {
+  registerMutations: registerMutations,
+  registerQueries: registerQueries,
+  registerSubscriptions: registerSubscriptions,
+  registerTypes: registerTypes,
+  getMutationResolver: getMutationResolver,
+  getQueryResolver: getQueryResolver,
+  start: start,
+  stop: stop,
+  reset: reset,
+  buildSdl: buildSdl,
+  getFullSdl: getFullSdl,
+  getSchema: getSchema,
+  diagnostics: diagnostics,
+  printDiagnostics: printDiagnostics
+};
+
+export {
+  instance,
+  wrapAdmin,
+  registerMutations,
+  registerQueries,
+  registerSubscriptions,
+  registerTypes,
+  getMutationResolver,
+  getQueryResolver,
+  start,
+  stop,
+  reset,
+  buildSdl,
+  getFullSdl,
+  getSchema,
+  diagnostics,
+  printDiagnostics,
+  asInterface,
+}
+/* instance Not a pure module */

package/src/adapter/PlatformMCP_Server.res

@@ -0,0 +1,23 @@
+// Platform (admin-facing) in-memory MCP server — singleton.
+// Serves admin/core operations on a separate port in split mode (port 3002).
+//
+// Uses the MCP_ServerInstance factory with a "MCP:Platform" label so log
+// output is distinguishable from the domain MCP server.
+
+let instance: MCP_ServerInstance.t = MCP_ServerInstance.make(~label="MCP:Platform")
+
+// Re-export all instance functions for module-style access.
+let registerTool = instance.registerTool
+let registerResource = instance.registerResource
+let registerResourceTemplate = instance.registerResourceTemplate
+let registerToolsFromEntries = instance.registerToolsFromEntries
+let registerResourcesFromEntries = instance.registerResourcesFromEntries
+let registerEventHistoryResourcesFromEntries = instance.registerEventHistoryResourcesFromEntries
+let start = instance.start
+let stop = instance.stop
+let reset = instance.reset
+let diagnostics = instance.diagnostics
+let printDiagnostics = instance.printDiagnostics
+
+// Expose as MCP_ServerInstance.t for resolveTargetMCP() in Platform.res.
+let asInterface: MCP_ServerInstance.t = instance

package/src/adapter/PlatformMCP_Server.res.mjs

@@ -0,0 +1,46 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as MCP_ServerInstance$ReventlessLocal from "./MCP_ServerInstance.res.mjs";
+
+let instance = MCP_ServerInstance$ReventlessLocal.make("MCP:Platform");
+
+let registerTool = instance.registerTool;
+
+let registerResource = instance.registerResource;
+
+let registerResourceTemplate = instance.registerResourceTemplate;
+
+let registerToolsFromEntries = instance.registerToolsFromEntries;
+
+let registerResourcesFromEntries = instance.registerResourcesFromEntries;
+
+let registerEventHistoryResourcesFromEntries = instance.registerEventHistoryResourcesFromEntries;
+
+let start = instance.start;
+
+let stop = instance.stop;
+
+let reset = instance.reset;
+
+let diagnostics = instance.diagnostics;
+
+let printDiagnostics = instance.printDiagnostics;
+
+let asInterface = instance;
+
+export {
+  instance,
+  registerTool,
+  registerResource,
+  registerResourceTemplate,
+  registerToolsFromEntries,
+  registerResourcesFromEntries,
+  registerEventHistoryResourcesFromEntries,
+  start,
+  stop,
+  reset,
+  diagnostics,
+  printDiagnostics,
+  asInterface,
+}
+/* instance Not a pure module */