@frontman-ai/vite 0.1.0

package/dist/index.d.ts

@@ -0,0 +1,465 @@
+import * as Stdlib_Option from '@rescript/runtime/lib/es6/Stdlib_Option.js';
+import * as Stdlib_JsError from '@rescript/runtime/lib/es6/Stdlib_JsError.js';
+import * as Stdlib_JsExn from '@rescript/runtime/lib/es6/Stdlib_JsExn.js';
+import * as Stdlib_Promise from '@rescript/runtime/lib/es6/Stdlib_Promise.js';
+import * as Primitive_option from '@rescript/runtime/lib/es6/Primitive_option.js';
+import * as Stdlib_Dict from '@rescript/runtime/lib/es6/Stdlib_Dict.js';
+import * as Stdlib_String from '@rescript/runtime/lib/es6/Stdlib_String.js';
+import * as S from 'sury/src/S.res.mjs';
+import * as Web from 'stream/web';
+import * as Stdlib_JSON from '@rescript/runtime/lib/es6/Stdlib_JSON.js';
+import * as Primitive_exceptions from '@rescript/runtime/lib/es6/Primitive_exceptions.js';
+import * as FrontmanCore__SSE$FrontmanFrontmanCore from '@frontman/frontman-core/src/FrontmanCore__SSE.res.mjs';
+import * as Server$1 from 'dom-element-to-component-source/server';
+import * as FrontmanCore__Server$FrontmanFrontmanCore from '@frontman/frontman-core/src/FrontmanCore__Server.res.mjs';
+import * as FrontmanCore__PathContext$FrontmanFrontmanCore from '@frontman/frontman-core/src/FrontmanCore__PathContext.res.mjs';
+import * as FrontmanProtocol__MCP$FrontmanFrontmanProtocol from '@frontman/frontman-protocol/src/FrontmanProtocol__MCP.res.mjs';
+import * as FrontmanProtocol__Relay$FrontmanFrontmanProtocol from '@frontman/frontman-protocol/src/FrontmanProtocol__Relay.res.mjs';
+import * as FrontmanCore__ToolRegistry$FrontmanFrontmanCore from '@frontman/frontman-core/src/FrontmanCore__ToolRegistry.res.mjs';
+
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let host = process.env["FRONTMAN_HOST"];
+
+let defaultHost = host !== undefined ? host : "frontman.local:4000";
+
+function makeFromObject(config) {
+  let isDev = Stdlib_Option.getOr(config.isDev, Stdlib_Option.mapOr(process.env["NODE_ENV"], true, env => env === "development"));
+  let projectRoot = Stdlib_Option.getOr(Stdlib_Option.orElse(config.projectRoot, Stdlib_Option.orElse(process.env["PROJECT_ROOT"], process.env["PWD"])), ".");
+  let sourceRoot = Stdlib_Option.getOr(config.sourceRoot, projectRoot);
+  let basePath = Stdlib_Option.getOr(config.basePath, "frontman");
+  let serverName = Stdlib_Option.getOr(config.serverName, "frontman-vite");
+  let serverVersion = Stdlib_Option.getOr(config.serverVersion, "1.0.0");
+  let host = Stdlib_Option.getOr(config.host, defaultHost);
+  let isLightTheme = Stdlib_Option.getOr(config.isLightTheme, false);
+  let baseUrl = Stdlib_Option.getOr(process.env["FRONTMAN_CLIENT_URL"], isDev ? "http://localhost:5173/src/Main.res.mjs" : "https://frontman.dev/frontman.es.js");
+  let url = new URL(baseUrl);
+  let clientUrl = Stdlib_Option.getOr(config.clientUrl, (url.searchParams.set("clientName", "vite"), url.searchParams.set("host", host), url.href));
+  let parsedUrl = new URL(clientUrl);
+  if (!parsedUrl.searchParams.has("host")) {
+    Stdlib_JsError.throwWithMessage(`[frontman-vite] clientUrl must include a "host" query parameter. Got: ` + clientUrl);
+  }
+  return {
+    isDev: isDev,
+    projectRoot: projectRoot,
+    sourceRoot: sourceRoot,
+    basePath: basePath,
+    serverName: serverName,
+    serverVersion: serverVersion,
+    host: host,
+    clientUrl: clientUrl,
+    clientCssUrl: config.clientCssUrl,
+    entrypointUrl: config.entrypointUrl,
+    isLightTheme: isLightTheme
+  };
+}
+/* host Not a pure module */
+
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function handleGetTools(registry, config) {
+  let response = FrontmanCore__Server$FrontmanFrontmanCore.getToolsResponse(registry, config.serverName, config.serverVersion);
+  let json = S.reverseConvertToJsonOrThrow(response, FrontmanProtocol__Relay$FrontmanFrontmanProtocol.toolsResponseSchema);
+  let headers = Object.fromEntries([[
+      "Content-Type",
+      "application/json"
+    ]]);
+  return Response.json(json, {
+    headers: Primitive_option.some(headers)
+  });
+}
+
+async function handleToolCall(registry, config, req) {
+  let body = await req.json();
+  let request;
+  try {
+    request = {
+      TAG: "Ok",
+      _0: S.parseOrThrow(body, FrontmanProtocol__Relay$FrontmanFrontmanProtocol.toolCallRequestSchema)
+    };
+  } catch (raw_e) {
+    let e = Primitive_exceptions.internalToException(raw_e);
+    if (e.RE_EXN_ID === S.$$Error) {
+      request = {
+        TAG: "Error",
+        _0: e._1.message
+      };
+    } else {
+      throw e;
+    }
+  }
+  if (request.TAG === "Ok") {
+    let request$1 = request._0;
+    let ctx_projectRoot = config.projectRoot;
+    let ctx_sourceRoot = config.sourceRoot;
+    let ctx = {
+      projectRoot: ctx_projectRoot,
+      sourceRoot: ctx_sourceRoot,
+      onProgress: undefined
+    };
+    let resultPromise = FrontmanCore__Server$FrontmanFrontmanCore.executeTool(registry, ctx, request$1.name, request$1.arguments);
+    let encoder = new TextEncoder();
+    let stream = new Web.ReadableStream({
+      start: controller => {
+        resultPromise.then(result => {
+          let mcpResult = FrontmanCore__Server$FrontmanFrontmanCore.resultToMCP(result);
+          let match = mcpResult.isError;
+          let eventData = match !== undefined && match ? FrontmanCore__SSE$FrontmanFrontmanCore.errorEvent(mcpResult) : FrontmanCore__SSE$FrontmanFrontmanCore.resultEvent(mcpResult);
+          controller.enqueue(encoder.encode(eventData));
+          controller.close();
+          return Promise.resolve();
+        });
+      }
+    });
+    return new Response(stream, {
+      headers: Primitive_option.some(FrontmanCore__SSE$FrontmanFrontmanCore.headers())
+    });
+  }
+  let errorResult_content = [{
+      type: "text",
+      text: `Invalid request: ` + request._0
+    }];
+  let errorResult_isError = true;
+  let errorResult = {
+    content: errorResult_content,
+    isError: errorResult_isError
+  };
+  let json = S.reverseConvertToJsonOrThrow(errorResult, FrontmanProtocol__MCP$FrontmanFrontmanProtocol.callToolResultSchema);
+  return Response.json(json, {
+    status: 400
+  });
+}
+
+async function handleResolveSourceLocation(config, req) {
+  let body = await req.json();
+  let requestObj = Stdlib_JSON.Decode.object(body);
+  if (requestObj === undefined) {
+    return Response.json(Object.fromEntries([[
+        "error",
+        "Invalid request body"
+      ]]), {
+      status: 400
+    });
+  }
+  let componentName = Stdlib_Option.flatMap(requestObj["componentName"], Stdlib_JSON.Decode.string);
+  let file = Stdlib_Option.flatMap(requestObj["file"], Stdlib_JSON.Decode.string);
+  let line = Stdlib_Option.flatMap(requestObj["line"], Stdlib_JSON.Decode.float);
+  let column = Stdlib_Option.flatMap(requestObj["column"], Stdlib_JSON.Decode.float);
+  if (componentName !== undefined && file !== undefined && line !== undefined && column !== undefined) {
+    try {
+      let sourceLocation_line = line | 0;
+      let sourceLocation_column = column | 0;
+      let sourceLocation = {
+        componentName: componentName,
+        file: file,
+        line: sourceLocation_line,
+        column: sourceLocation_column,
+        componentProps: undefined,
+        parent: undefined
+      };
+      let resolved = await Server$1.resolveSourceLocationInServer(sourceLocation);
+      let relativeFile = FrontmanCore__PathContext$FrontmanFrontmanCore.toRelativePath(config.sourceRoot, resolved.file);
+      let responseJson = Object.fromEntries([
+        [
+          "componentName",
+          resolved.componentName
+        ],
+        [
+          "file",
+          relativeFile
+        ],
+        [
+          "line",
+          resolved.line
+        ],
+        [
+          "column",
+          resolved.column
+        ]
+      ]);
+      let headers = Object.fromEntries([[
+          "Content-Type",
+          "application/json"
+        ]]);
+      return Response.json(responseJson, {
+        headers: Primitive_option.some(headers)
+      });
+    } catch (raw_exn) {
+      let exn = Primitive_exceptions.internalToException(raw_exn);
+      let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(exn), Stdlib_JsExn.message), "Unknown error");
+      return Response.json(Object.fromEntries([
+        [
+          "error",
+          "Failed to resolve source location"
+        ],
+        [
+          "details",
+          msg
+        ]
+      ]), {
+        status: 500
+      });
+    }
+  }
+  return Response.json(Object.fromEntries([[
+      "error",
+      "Missing required fields: componentName, file, line, column"
+    ]]), {
+    status: 400
+  });
+}
+/* S Not a pure module */
+
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+function make() {
+  return FrontmanCore__ToolRegistry$FrontmanFrontmanCore.coreTools();
+}
+/* FrontmanCore__ToolRegistry-FrontmanFrontmanCore Not a pure module */
+
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let corsHeaders = Object.fromEntries([
+  [
+    "Access-Control-Allow-Origin",
+    "*"
+  ],
+  [
+    "Access-Control-Allow-Methods",
+    "GET, POST, OPTIONS"
+  ],
+  [
+    "Access-Control-Allow-Headers",
+    "Content-Type"
+  ]
+]);
+
+function withCors(response) {
+  let headers = response.headers;
+  Stdlib_Dict.forEachWithKey(corsHeaders, (value, key) => {
+    headers.set(key, value);
+  });
+  return response;
+}
+
+function handlePreflight() {
+  return new Response(null, {
+    status: 204,
+    headers: Primitive_option.some(corsHeaders)
+  });
+}
+
+function handleUI(config) {
+  let clientCssTag = Stdlib_Option.mapOr(config.clientCssUrl, "", url => `<link rel="stylesheet" href="` + url + `">`);
+  let entrypointTemplate = Stdlib_Option.mapOr(config.entrypointUrl, "", url => `<script type="template" id="frontman-entrypoint-url">` + url + `</script>`);
+  let themeClass = config.isLightTheme ? "" : "dark";
+  let openrouterKey = Stdlib_Option.flatMap(process.env["OPENROUTER_API_KEY"], key => {
+    if (key !== "") {
+      return key;
+    }
+  });
+  let configObj = Object.fromEntries([[
+      "framework",
+      "Vite"
+    ]]);
+  Stdlib_Option.forEach(openrouterKey, key => {
+    configObj["openrouterKeyValue"] = key;
+  });
+  let payload = JSON.stringify(configObj);
+  let runtimeConfigScript = `<script>window.__frontmanRuntime=` + payload + `</script>`;
+  let html = `<!DOCTYPE html>
+<html lang="en" class="` + themeClass + `">
+<head>
+    <meta charset="UTF-8">
+    <meta name="viewport" content="width=device-width, initial-scale=1.0">
+    <title>Frontman</title>
+    ` + entrypointTemplate + `
+    ` + clientCssTag + `
+</head>
+<body>
+    <div id="root"></div>
+    ` + runtimeConfigScript + `
+    <script type="module" src="` + config.clientUrl + `"></script>
+</body>
+</html>`;
+  let headers = Object.fromEntries([[
+      "Content-Type",
+      "text/html"
+    ]]);
+  return new Response(html, {
+    headers: Primitive_option.some(headers)
+  });
+}
+
+function createMiddleware$1(config) {
+  let registry = make();
+  return async req => {
+    let method = req.method.toLowerCase();
+    let pathname = URL.parse(req.url).pathname;
+    let path = pathname.split("/").filter(p => !Stdlib_String.isEmpty(p)).join("/").toLowerCase();
+    let toolsPath = config.basePath.toLowerCase() + "/tools";
+    let toolsCallPath = config.basePath.toLowerCase() + "/tools/call";
+    let resolveSourceLocationPath = config.basePath.toLowerCase() + "/resolve-source-location";
+    let uiPath = config.basePath.toLowerCase();
+    let isFrontmanRoute = path === toolsPath || path === toolsCallPath || path === resolveSourceLocationPath || path === uiPath;
+    switch (method) {
+      case "get" :
+        if (path === uiPath) {
+          return withCors(handleUI(config));
+        } else if (path === toolsPath) {
+          return withCors(handleGetTools(registry, config));
+        } else {
+          return;
+        }
+      case "options" :
+        if (isFrontmanRoute) {
+          return handlePreflight();
+        } else {
+          return;
+        }
+      case "post" :
+        if (path === toolsCallPath) {
+          return withCors(await handleToolCall(registry, config, req));
+        } else if (path === resolveSourceLocationPath) {
+          return withCors(await handleResolveSourceLocation(config, req));
+        } else {
+          return;
+        }
+      default:
+        return;
+    }
+  };
+}
+/* corsHeaders Not a pure module */
+
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let headersToDict = (function headersToDict(headers) {
+    const dict = {};
+    headers.forEach(function(value, key) {
+      dict[key] = value;
+    });
+    return dict;
+  });
+
+let collectBody = (async function collectBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+      chunks.push(chunk);
+    }
+    return Buffer.concat(chunks);
+  });
+
+let pipeStreamToResponse = (async function pipeStreamToResponse(stream, res) {
+    const reader = stream.getReader();
+    try {
+      while (true) {
+        const { done, value } = await reader.read();
+        if (done) break;
+        res.write(value);
+      }
+    } finally {
+      reader.releaseLock();
+    }
+  });
+
+function adaptMiddlewareToVite(middleware) {
+  return async (req, res, next) => {
+    let bodyBuffer = await collectBody(req);
+    let host = Stdlib_Option.getOr(req.headers["host"], "localhost");
+    let reqUrl = Stdlib_Option.getOr(Primitive_option.fromNull(req.url), "/");
+    let url = `http://` + host + reqUrl;
+    let method = Stdlib_Option.getOr(Primitive_option.fromNull(req.method), "GET");
+    let headers = req.headers;
+    let hasBody = bodyBuffer.length > 0;
+    let body = hasBody ? Primitive_option.some(bodyBuffer) : undefined;
+    let webRequest = new Request(url, {
+      method: method,
+      headers: Primitive_option.some(headers),
+      body: body
+    });
+    let responseOption = await middleware(webRequest);
+    if (responseOption === undefined) {
+      return next();
+    }
+    res.statusCode = responseOption.status;
+    let headerDict = headersToDict(responseOption.headers);
+    res.writeHead(responseOption.status, headerDict);
+    let stream = responseOption.body;
+    if (stream !== null) {
+      await pipeStreamToResponse(stream, res);
+    }
+    res.end();
+  };
+}
+
+function frontmanPlugin$1(options) {
+  let opts = Stdlib_Option.getOr(options, {});
+  return {
+    name: "frontman",
+    configureServer: server => {
+      let isDev = opts.isDev;
+      let basePath = opts.basePath;
+      let clientUrl = opts.clientUrl;
+      let clientCssUrl = opts.clientCssUrl;
+      let entrypointUrl = opts.entrypointUrl;
+      let isLightTheme = opts.isLightTheme;
+      let projectRoot = opts.projectRoot;
+      let sourceRoot = opts.sourceRoot;
+      let host = opts.host;
+      let configInput = {
+        isDev: isDev,
+        projectRoot: projectRoot,
+        sourceRoot: sourceRoot,
+        basePath: basePath,
+        host: host,
+        clientUrl: clientUrl,
+        clientCssUrl: clientCssUrl,
+        entrypointUrl: entrypointUrl,
+        isLightTheme: isLightTheme
+      };
+      let config = makeFromObject(configInput);
+      let middleware = createMiddleware$1(config);
+      let adaptedMiddleware = adaptMiddlewareToVite(middleware);
+      server.middlewares.use((req, res, next) => {
+        Stdlib_Promise.$$catch(adaptedMiddleware(req, res, next), error => {
+          let msg = Stdlib_Option.getOr(Stdlib_Option.flatMap(Stdlib_JsExn.fromException(error), Stdlib_JsExn.message), "Unknown error");
+          console.error("Frontman middleware error:", msg);
+          res.statusCode = 500;
+          res.end("Internal Server Error");
+          return Promise.resolve();
+        });
+      });
+    }
+  };
+}
+/* collectBody Not a pure module */
+
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let Config;
+
+let Middleware;
+
+let Server;
+
+let ToolRegistry;
+
+let Plugin;
+
+let SSE;
+
+let createMiddleware = createMiddleware$1;
+
+let makeConfig = makeFromObject;
+
+let frontmanPlugin = frontmanPlugin$1;
+/* FrontmanVite__Config-FrontmanAiVite Not a pure module */
+
+export { Config, Middleware, Plugin, SSE, Server, ToolRegistry, createMiddleware, frontmanPlugin, makeConfig };