@frontman-ai/astro 0.1.0

package/package.json

@@ -0,0 +1,66 @@
+{
+	"name": "@frontman-ai/astro",
+	"version": "0.1.0",
+	"description": "Astro integration for Frontman",
+	"license": "Apache-2.0",
+	"author": "Frontman AI",
+	"repository": {
+		"type": "git",
+		"url": "https://github.com/frontman-ai/frontman.git",
+		"directory": "libs/frontman-astro"
+	},
+	"homepage": "https://frontman.sh",
+	"bugs": {
+		"url": "https://github.com/frontman-ai/frontman/issues"
+	},
+	"keywords": [
+		"frontman",
+		"astro",
+		"ai",
+		"development"
+	],
+	"type": "module",
+	"main": "./src/FrontmanAstro.res.mjs",
+	"exports": {
+		".": {
+			"import": "./src/FrontmanAstro.res.mjs",
+			"default": "./src/FrontmanAstro.res.mjs"
+		},
+		"./integration": {
+			"import": "./src/FrontmanAstro__Integration.res.mjs",
+			"default": "./src/FrontmanAstro__Integration.res.mjs"
+		},
+		"./toolbar": {
+			"import": "./src/FrontmanAstro__ToolbarApp.res.mjs",
+			"default": "./src/FrontmanAstro__ToolbarApp.res.mjs"
+		}
+	},
+	"bin": {
+		"frontman-ai-astro": "./dist/cli.js"
+	},
+	"files": [
+		"src",
+		"dist"
+	],
+	"scripts": {
+		"build": "rescript build",
+		"build:cli": "tsup",
+		"prepublishOnly": "yarn build && yarn build:cli"
+	},
+	"peerDependencies": {
+		"astro": "^5.0.0"
+	},
+	"publishConfig": {
+		"access": "public"
+	},
+	"devDependencies": {
+		"@rescript/webapi": "catalog:",
+		"@vitest/ui": "catalog:",
+		"rescript": "catalog:",
+		"rescript-vitest": "catalog:",
+		"sury": "catalog:",
+		"tsup": "^8.0.0",
+		"vite": "catalog:",
+		"vitest": "catalog:"
+	}
+}

package/src/FrontmanAstro.res

@@ -0,0 +1,20 @@
+// Frontman Astro Integration - exposes framework tools via HTTP
+// Used by FrontmanClient__Relay to execute file system operations
+
+module Config = FrontmanAstro__Config
+module Middleware = FrontmanAstro__Middleware
+module Server = FrontmanAstro__Server
+module ToolRegistry = FrontmanAstro__ToolRegistry
+module Integration = FrontmanAstro__Integration
+
+// Re-export core SSE for convenience
+module SSE = FrontmanFrontmanCore.FrontmanCore__SSE
+
+// Re-export for convenience
+let createMiddleware = Middleware.createMiddleware
+// makeConfig accepts an object with optional fields - JS-friendly API
+let makeConfig = Config.makeFromObject
+type config = Config.t
+
+// Integration export
+let frontmanIntegration = Integration.make

package/src/FrontmanAstro.res.mjs

@@ -0,0 +1,36 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as FrontmanAstro__Config$FrontmanAiAstro from "./FrontmanAstro__Config.res.mjs";
+import * as FrontmanAstro__Middleware$FrontmanAiAstro from "./FrontmanAstro__Middleware.res.mjs";
+import * as FrontmanAstro__Integration$FrontmanAiAstro from "./FrontmanAstro__Integration.res.mjs";
+
+let Config;
+
+let Middleware;
+
+let Server;
+
+let ToolRegistry;
+
+let Integration;
+
+let SSE;
+
+let createMiddleware = FrontmanAstro__Middleware$FrontmanAiAstro.createMiddleware;
+
+let makeConfig = FrontmanAstro__Config$FrontmanAiAstro.makeFromObject;
+
+let frontmanIntegration = FrontmanAstro__Integration$FrontmanAiAstro.make;
+
+export {
+  Config,
+  Middleware,
+  Server,
+  ToolRegistry,
+  Integration,
+  SSE,
+  createMiddleware,
+  makeConfig,
+  frontmanIntegration,
+}
+/* FrontmanAstro__Config-FrontmanAiAstro Not a pure module */

package/src/FrontmanAstro__AstroBindings.res

@@ -0,0 +1,46 @@
+// Astro Integration API bindings
+
+// Dev toolbar app configuration
+// entrypoint: file path to the toolbar app module (string | URL supported, using string for simplicity)
+type devToolbarAppConfig = {
+  id: string,
+  name: string,
+  icon: string,
+  entrypoint: string,
+}
+
+// Astro command type
+type astroCommand = [#dev | #build | #preview | #sync]
+
+// Hook context for astro:config:setup
+type configSetupHookContext = {
+  addDevToolbarApp: devToolbarAppConfig => unit,
+  config: {root: string},
+  command: astroCommand,
+}
+
+// Astro integration hooks
+type astroHooks = {
+  @as("astro:config:setup")
+  configSetup?: configSetupHookContext => unit,
+}
+
+// Astro integration type
+type astroIntegration = {
+  name: string,
+  hooks: astroHooks,
+}
+
+// Toolbar app types
+type toolbarCanvas // opaque
+type toolbarApp // opaque
+type toolbarServer // opaque
+type toolbarAppDefinition // opaque - returned by defineToolbarApp
+
+type toolbarAppConfig = {
+  init: (toolbarCanvas, toolbarApp, toolbarServer) => unit,
+}
+
+// defineToolbarApp binding - returns an object that should be export default'd
+@module("astro/toolbar")
+external defineToolbarApp: toolbarAppConfig => toolbarAppDefinition = "defineToolbarApp"

package/src/FrontmanAstro__AstroBindings.res.mjs

@@ -0,0 +1,2 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+/* This output is empty. Its source's type definitions, externals and/or unused code got optimized away. */

package/src/FrontmanAstro__Config.res

@@ -0,0 +1,85 @@
+// Astro configuration for Frontman
+
+module Bindings = FrontmanBindings
+
+// Default host can be overridden via FRONTMAN_HOST env var for remote development
+let defaultHost = switch Bindings.Process.env->Dict.get("FRONTMAN_HOST") {
+| Some(host) => host
+| None => "frontman.local:4000"
+}
+
+type t = {
+  projectRoot: string,
+  // sourceRoot: root for resolving file paths from Astro's data-astro-source-file attributes
+  // In a monorepo, this is typically the monorepo root. Defaults to projectRoot.
+  sourceRoot: string,
+  basePath: string,
+  serverName: string,
+  serverVersion: string,
+  host: string,
+  clientUrl: string,
+  isLightTheme: bool,
+}
+
+// JS-friendly type for config input
+type jsConfigInput = {
+  projectRoot?: string,
+  sourceRoot?: string,
+  basePath?: string,
+  serverName?: string,
+  serverVersion?: string,
+  host?: string,
+  clientUrl?: string,
+  isLightTheme?: bool,
+}
+
+// JS-friendly function that accepts a config object
+// Use this from JavaScript/TypeScript: makeConfig({ projectRoot: "..." })
+let makeFromObject = (config: jsConfigInput): t => {
+  let projectRoot =
+    config.projectRoot
+    ->Option.orElse(
+      Bindings.Process.env
+      ->Dict.get("PROJECT_ROOT")
+      ->Option.orElse(Bindings.Process.env->Dict.get("PWD")),
+    )
+    ->Option.getOr(".")
+
+  let sourceRoot = config.sourceRoot->Option.getOr(projectRoot)
+  let basePath = config.basePath->Option.getOr("frontman")
+  let serverName = config.serverName->Option.getOr("frontman-astro")
+  let serverVersion = config.serverVersion->Option.getOr("1.0.0")
+  let isLightTheme = config.isLightTheme->Option.getOr(false)
+  let host = config.host->Option.getOr(defaultHost)
+
+  let clientUrl = config.clientUrl->Option.getOr({
+    let baseUrl =
+      Bindings.Process.env
+      ->Dict.get("FRONTMAN_CLIENT_URL")
+      ->Option.getOr("http://localhost:5173/src/Main.res.mjs")
+    // Use URL API to properly append params (handles base URLs that already have query strings)
+    let url = WebAPI.URL.make(~url=baseUrl)
+    url.searchParams->WebAPI.URLSearchParams.set(~name="clientName", ~value="astro")
+    url.searchParams->WebAPI.URLSearchParams.set(~name="host", ~value=host)
+    url.href
+  })
+
+  // Assert clientUrl contains the required "host" query param that the client reads from import.meta.url
+  let parsedUrl = WebAPI.URL.make(~url=clientUrl)
+  if !(parsedUrl.searchParams->WebAPI.URLSearchParams.has(~name="host")) {
+    JsError.throwWithMessage(
+      `[frontman-astro] clientUrl must include a "host" query parameter. Got: ${clientUrl}`,
+    )
+  }
+
+  {
+    projectRoot,
+    sourceRoot,
+    basePath,
+    serverName,
+    serverVersion,
+    host,
+    clientUrl,
+    isLightTheme,
+  }
+}

package/src/FrontmanAstro__Config.res.mjs

@@ -0,0 +1,44 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Stdlib_JsError from "@rescript/runtime/lib/es6/Stdlib_JsError.js";
+
+let host = process.env["FRONTMAN_HOST"];
+
+let defaultHost = host !== undefined ? host : "frontman.local:4000";
+
+function makeFromObject(config) {
+  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-astro");
+  let serverVersion = Stdlib_Option.getOr(config.serverVersion, "1.0.0");
+  let isLightTheme = Stdlib_Option.getOr(config.isLightTheme, false);
+  let host = Stdlib_Option.getOr(config.host, defaultHost);
+  let baseUrl = Stdlib_Option.getOr(process.env["FRONTMAN_CLIENT_URL"], "http://localhost:5173/src/Main.res.mjs");
+  let url = new URL(baseUrl);
+  let clientUrl = Stdlib_Option.getOr(config.clientUrl, (url.searchParams.set("clientName", "astro"), url.searchParams.set("host", host), url.href));
+  let parsedUrl = new URL(clientUrl);
+  if (!parsedUrl.searchParams.has("host")) {
+    Stdlib_JsError.throwWithMessage(`[frontman-astro] clientUrl must include a "host" query parameter. Got: ` + clientUrl);
+  }
+  return {
+    projectRoot: projectRoot,
+    sourceRoot: sourceRoot,
+    basePath: basePath,
+    serverName: serverName,
+    serverVersion: serverVersion,
+    host: host,
+    clientUrl: clientUrl,
+    isLightTheme: isLightTheme
+  };
+}
+
+let Bindings;
+
+export {
+  Bindings,
+  defaultHost,
+  makeFromObject,
+}
+/* host Not a pure module */

package/src/FrontmanAstro__Integration.res

@@ -0,0 +1,35 @@
+// Frontman Astro Integration
+
+module Bindings = FrontmanAstro__AstroBindings
+
+// SVG icon for the toolbar
+let icon = `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><circle cx="12" cy="12" r="3"/></svg>`
+
+// Get the path to the toolbar app entrypoint
+// Uses import.meta.url to resolve relative to this file
+@val @scope(("import", "meta"))
+external importMetaUrl: string = "url"
+
+// Helper to create URL and get pathname
+let getToolbarAppPath = () => {
+  let url = WebAPI.URL.make(~url="./FrontmanAstro__ToolbarApp.res.mjs", ~base=importMetaUrl)
+  url.pathname
+}
+
+// Create the Astro integration
+let make = (): Bindings.astroIntegration => {
+  name: "frontman",
+  hooks: {
+    configSetup: ?Some(ctx => {
+      // Only add dev toolbar app in dev mode
+      if ctx.command == #dev {
+        ctx.addDevToolbarApp({
+          id: "frontman:toolbar",
+          name: "Frontman",
+          icon,
+          entrypoint: getToolbarAppPath(),
+        })
+      }
+    }),
+  },
+}

package/src/FrontmanAstro__Integration.res.mjs

@@ -0,0 +1,36 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+
+let icon = `<svg xmlns="http://www.w3.org/2000/svg" width="16" height="16" viewBox="0 0 24 24" fill="none" stroke="currentColor" stroke-width="2"><circle cx="12" cy="12" r="10"/><circle cx="12" cy="12" r="3"/></svg>`;
+
+function getToolbarAppPath() {
+  return new URL("./FrontmanAstro__ToolbarApp.res.mjs", import.meta.url).pathname;
+}
+
+function make() {
+  return {
+    name: "frontman",
+    hooks: {
+      "astro:config:setup": ctx => {
+        if (ctx.command === "dev") {
+          return ctx.addDevToolbarApp({
+            id: "frontman:toolbar",
+            name: "Frontman",
+            icon: icon,
+            entrypoint: getToolbarAppPath()
+          });
+        }
+      }
+    }
+  };
+}
+
+let Bindings;
+
+export {
+  Bindings,
+  icon,
+  getToolbarAppPath,
+  make,
+}
+/* No side effect */

package/src/FrontmanAstro__Middleware.res

@@ -0,0 +1,149 @@
+// Astro middleware for Frontman
+
+module Config = FrontmanAstro__Config
+module Server = FrontmanAstro__Server
+module ToolRegistry = FrontmanAstro__ToolRegistry
+
+// Annotation capture script - injected before </body>
+// Stores paths exactly as Astro provides them (should be absolute paths)
+let annotationCaptureScript = `
+<script>
+(function() {
+  var annotations = new Map();
+  document.querySelectorAll('[data-astro-source-file]').forEach(function(el) {
+    annotations.set(el, {
+      file: el.getAttribute('data-astro-source-file'),
+      loc: el.getAttribute('data-astro-source-loc')
+    });
+  });
+  window.__frontman_annotations__ = {
+    _map: annotations,
+    get: function(el) { return annotations.get(el); },
+    has: function(el) { return annotations.has(el); },
+    size: function() { return annotations.size; }
+  };
+  console.log('[Frontman] Captured ' + annotations.size + ' elements');
+})();
+</script>
+`
+
+// Helper to inject script into HTML response
+let injectAnnotationScript = async (response: WebAPI.FetchAPI.response): WebAPI.FetchAPI.response => {
+  let contentType = response.headers->WebAPI.Headers.get("content-type")->Null.toOption
+
+  switch contentType {
+  | Some(ct) if ct->String.includes("text/html") =>
+    let html = await response->WebAPI.Response.text
+    let injectedHtml = html->String.replace("</body>", `${annotationCaptureScript}</body>`)
+
+    WebAPI.Response.fromString(
+      injectedHtml,
+      ~init={
+        status: response.status,
+        headers: WebAPI.HeadersInit.fromHeaders(response.headers),
+      },
+    )
+  | _ => response
+  }
+}
+
+// HTML template for the Frontman UI
+let uiHtml = (~clientUrl: string, ~isLightTheme: bool) => {
+  // Get the raw env var and filter out empty strings
+  let openrouterKey =
+    FrontmanBindings.Process.env
+    ->Dict.get("OPENROUTER_API_KEY")
+    ->Option.flatMap(key => key != "" ? Some(key) : None)
+  // Build JSON payload using proper JSON encoding to handle special characters
+  let configObj = Dict.fromArray([("framework", JSON.Encode.string("Astro"))])
+  openrouterKey->Option.forEach(key => {
+    configObj->Dict.set("openrouterKeyValue", JSON.Encode.string(key))
+  })
+  let runtimeConfig = JSON.stringify(JSON.Encode.object(configObj))
+  let themeClass = isLightTheme ? "" : "dark"
+  `<!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>
+  <style>
+    html, body, #root {
+      margin: 0;
+      padding: 0;
+      height: 100%;
+      width: 100%;
+    }
+  </style>
+</head>
+<body>
+  <div id="root"></div>
+  <script>window.__frontmanRuntime=${runtimeConfig}</script>
+  <script type="module" src="${clientUrl}"></script>
+</body>
+</html>`
+}
+
+// Serve UI HTML
+let serveUI = (config: Config.t): WebAPI.FetchAPI.response => {
+  let html = uiHtml(~clientUrl=config.clientUrl, ~isLightTheme=config.isLightTheme)
+  let headers = WebAPI.HeadersInit.fromDict(Dict.fromArray([("Content-Type", "text/html")]))
+  WebAPI.Response.fromString(html, ~init={headers: headers})
+}
+
+// Type for Astro URL object (subset we need)
+type astroUrl = {pathname: string}
+
+// Type for Astro middleware context (subset of APIContext we actually use)
+type astroContext = {
+  request: WebAPI.FetchAPI.request,
+  url: astroUrl,
+}
+
+// Type for Astro next function
+type astroNext = unit => promise<WebAPI.FetchAPI.response>
+
+// Create middleware handler
+// Returns a function that can be used directly as Astro middleware
+let createMiddleware = (config: Config.t) => {
+  let registry = ToolRegistry.make()
+
+  async (context: astroContext, next: astroNext): WebAPI.FetchAPI.response => {
+    let pathname = context.url.pathname
+    let method = context.request.method
+
+    let basePath = `/${config.basePath}`
+
+    // Check if this is a frontman route (exact match or subpath)
+    if !(pathname == basePath || pathname->String.startsWith(`${basePath}/`)) {
+      // Not a frontman route - pass through but inject script into HTML
+      let response = await next()
+      await injectAnnotationScript(response)
+    } else if method == "OPTIONS" {
+      // Handle CORS preflight
+      Server.handleCORS()
+    } else {
+      // Route handling
+      switch pathname {
+      | p if p == basePath || p == `${basePath}/` =>
+        serveUI(config)
+
+      | p if p == `${basePath}/tools` && method == "GET" =>
+        Server.handleGetTools(~registry, ~config)
+
+      | p if p == `${basePath}/tools/call` && method == "POST" =>
+        await Server.handleToolCall(~registry, ~config, context.request)
+
+      | p if p == `${basePath}/resolve-source-location` && method == "POST" =>
+        await Server.handleResolveSourceLocation(~config, context.request)
+
+      | _ =>
+        // Unknown frontman route
+        WebAPI.Response.jsonR(
+          ~data=JSON.Encode.object(Dict.fromArray([("error", JSON.Encode.string("Not found"))])),
+          ~init={status: 404},
+        )
+      }
+    }
+  }
+}

package/src/FrontmanAstro__Middleware.res.mjs

@@ -0,0 +1,141 @@
+// Generated by ReScript, PLEASE EDIT WITH CARE
+
+import * as Stdlib_Option from "@rescript/runtime/lib/es6/Stdlib_Option.js";
+import * as Primitive_option from "@rescript/runtime/lib/es6/Primitive_option.js";
+import * as FrontmanAstro__Server$FrontmanAiAstro from "./FrontmanAstro__Server.res.mjs";
+import * as FrontmanAstro__ToolRegistry$FrontmanAiAstro from "./FrontmanAstro__ToolRegistry.res.mjs";
+
+let annotationCaptureScript = `
+<script>
+(function() {
+  var annotations = new Map();
+  document.querySelectorAll('[data-astro-source-file]').forEach(function(el) {
+    annotations.set(el, {
+      file: el.getAttribute('data-astro-source-file'),
+      loc: el.getAttribute('data-astro-source-loc')
+    });
+  });
+  window.__frontman_annotations__ = {
+    _map: annotations,
+    get: function(el) { return annotations.get(el); },
+    has: function(el) { return annotations.has(el); },
+    size: function() { return annotations.size; }
+  };
+  console.log('[Frontman] Captured ' + annotations.size + ' elements');
+})();
+</script>
+`;
+
+async function injectAnnotationScript(response) {
+  let contentType = response.headers.get("content-type");
+  if (contentType === null) {
+    return response;
+  }
+  if (!contentType.includes("text/html")) {
+    return response;
+  }
+  let html = await response.text();
+  let injectedHtml = html.replace("</body>", annotationCaptureScript + `</body>`);
+  return new Response(injectedHtml, {
+    status: response.status,
+    headers: Primitive_option.some(response.headers)
+  });
+}
+
+function uiHtml(clientUrl, isLightTheme) {
+  let openrouterKey = Stdlib_Option.flatMap(process.env["OPENROUTER_API_KEY"], key => {
+    if (key !== "") {
+      return key;
+    }
+  });
+  let configObj = Object.fromEntries([[
+      "framework",
+      "Astro"
+    ]]);
+  Stdlib_Option.forEach(openrouterKey, key => {
+    configObj["openrouterKeyValue"] = key;
+  });
+  let runtimeConfig = JSON.stringify(configObj);
+  let themeClass = isLightTheme ? "" : "dark";
+  return `<!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>
+  <style>
+    html, body, #root {
+      margin: 0;
+      padding: 0;
+      height: 100%;
+      width: 100%;
+    }
+  </style>
+</head>
+<body>
+  <div id="root"></div>
+  <script>window.__frontmanRuntime=` + runtimeConfig + `</script>
+  <script type="module" src="` + clientUrl + `"></script>
+</body>
+</html>`;
+}
+
+function serveUI(config) {
+  let html = uiHtml(config.clientUrl, config.isLightTheme);
+  let headers = Object.fromEntries([[
+      "Content-Type",
+      "text/html"
+    ]]);
+  return new Response(html, {
+    headers: Primitive_option.some(headers)
+  });
+}
+
+function createMiddleware(config) {
+  let registry = FrontmanAstro__ToolRegistry$FrontmanAiAstro.make();
+  return async (context, next) => {
+    let pathname = context.url.pathname;
+    let method = context.request.method;
+    let basePath = `/` + config.basePath;
+    if (pathname === basePath || pathname.startsWith(basePath + `/`)) {
+      if (method === "OPTIONS") {
+        return FrontmanAstro__Server$FrontmanAiAstro.handleCORS();
+      } else if (pathname === basePath || pathname === basePath + `/`) {
+        return serveUI(config);
+      } else if (pathname === basePath + `/tools` && method === "GET") {
+        return FrontmanAstro__Server$FrontmanAiAstro.handleGetTools(registry, config);
+      } else if (pathname === basePath + `/tools/call` && method === "POST") {
+        return await FrontmanAstro__Server$FrontmanAiAstro.handleToolCall(registry, config, context.request);
+      } else if (pathname === basePath + `/resolve-source-location` && method === "POST") {
+        return await FrontmanAstro__Server$FrontmanAiAstro.handleResolveSourceLocation(config, context.request);
+      } else {
+        return Response.json(Object.fromEntries([[
+            "error",
+            "Not found"
+          ]]), {
+          status: 404
+        });
+      }
+    }
+    let response = await next();
+    return await injectAnnotationScript(response);
+  };
+}
+
+let Config;
+
+let Server;
+
+let ToolRegistry;
+
+export {
+  Config,
+  Server,
+  ToolRegistry,
+  annotationCaptureScript,
+  injectAnnotationScript,
+  uiHtml,
+  serveUI,
+  createMiddleware,
+}
+/* FrontmanAstro__Server-FrontmanAiAstro Not a pure module */