npm - @maintainer-pro/ai-bridge - Versions diffs - 0.1.0 → 0.1.1 - Mend

@maintainer-pro/ai-bridge 0.1.0 → 0.1.1

This diff represents the content of publicly available package versions that have been released to one of the supported registries. The information contained in this diff is provided for informational purposes only and reflects changes between package versions as they appear in their respective public registries.

Files changed (3) hide show

package/README.md CHANGED Viewed

@@ -14,7 +14,14 @@ npx --yes @maintainer-pro/ai-bridge --pair AB12-CD34 --admin-url https://your-ad
 Credentials are stored in `~/.maintainer-pro/bridge.json` (not the cwd).
 3. Keep the bridge running (`npx @maintainer-pro/ai-bridge`). It advertises the current folder (and any `--offer-folder` paths).
-4. In admin → Bridges: pick a reported folder + client sandbox → **Setup sandbox in folder**. The bridge writes `.env`, starts `ai-server` on an assigned port, and marks the sandbox setup complete.
+4. In admin → Bridges: pick a reported folder + client sandbox → **Setup sandbox in folder**.
+For **empty / new** folders the bridge:
+- Writes `.env` (server + client keys)
+- Scaffolds `index.html` with the chat widget (served by `ai-server`)
+- Starts `ai-server` and marks the sandbox Online
+For **existing** apps it injects the widget / Next env when possible. Use **Client setup** on the Bridges form for manual overrides (`empty`, `existing`, or keys-only).
 One bridge process can run many sandboxes (different folders / ports) for different clients.

package/package.json CHANGED Viewed

@@ -1,6 +1,6 @@
 {
   "name": "@maintainer-pro/ai-bridge",
-  "version": "0.1.0",
+  "version": "0.1.1",
   "description": "Local bridge daemon that pairs a machine to Maintainer Pro and configures multiple client sandboxes.",
   "keywords": [
     "maintainer-pro",

package/src/daemon.mjs CHANGED Viewed

@@ -256,6 +256,401 @@ function mergeEnvFile(file, values) {
   fs.writeFileSync(file, body + "\n", "utf8");
 }
+const IGNORE_NAMES = new Set([
+  ".git",
+  ".DS_Store",
+  "Thumbs.db",
+  "node_modules",
+  ".maintainer-pro",
+  ".maintainer-pro-bridge.json",
+  ".cloudflare-tunnel-url",
+]);
+function isIgnorableEntry(name) {
+  if (IGNORE_NAMES.has(name)) return true;
+  if (name.startsWith(".env")) return true;
+  return false;
+}
+/**
+ * Detect project shape in a folder.
+ * @returns {"empty"|"next"|"html"|"other"}
+ */
+function detectProjectKind(dir) {
+  if (!fs.existsSync(dir)) return "empty";
+  const names = fs.readdirSync(dir).filter((n) => !isIgnorableEntry(n));
+  if (names.length === 0) return "empty";
+  const has = (n) => names.includes(n) || fs.existsSync(path.join(dir, n));
+  if (
+    has("next.config.js") ||
+    has("next.config.mjs") ||
+    has("next.config.ts") ||
+    has("app") ||
+    has("pages")
+  ) {
+    // package.json with next is a stronger signal
+    try {
+      const pkg = JSON.parse(
+        fs.readFileSync(path.join(dir, "package.json"), "utf8")
+      );
+      if (pkg.dependencies?.next || pkg.devDependencies?.next) return "next";
+    } catch {
+      /* fall through */
+    }
+    if (has("next.config.js") || has("next.config.mjs") || has("next.config.ts")) {
+      return "next";
+    }
+  }
+  if (has("index.html") || has(path.join("public", "index.html"))) {
+    return "html";
+  }
+  // Only README / license → treat as empty scaffold target
+  const meaningful = names.filter(
+    (n) =>
+      !/^readme/i.test(n) &&
+      !/^license/i.test(n) &&
+      n !== "package.json"
+  );
+  if (meaningful.length === 0 && !has("package.json")) return "empty";
+  return "other";
+}
+function escapeHtml(value) {
+  return String(value)
+    .replaceAll("&", "&amp;")
+    .replaceAll("<", "&lt;")
+    .replaceAll(">", "&gt;")
+    .replaceAll('"', "&quot;");
+}
+function emptyProjectIndexHtml(appName) {
+  return `<!doctype html>
+<html lang="en">
+  <head>
+    <meta charset="utf-8" />
+    <meta name="viewport" content="width=device-width, initial-scale=1" />
+    <title>${escapeHtml(appName)}</title>
+    <style>
+      body { font-family: system-ui, sans-serif; margin: 2rem; color: #1a2330; }
+      p { color: #5c6b7a; }
+    </style>
+  </head>
+  <body>
+    <h1>${escapeHtml(appName)}</h1>
+    <p>Ask the assistant to change this page.</p>
+    <script src="/embed-config.js"></script>
+    <script src="/ai-ui.iife.js"></script>
+    <script>
+      (function () {
+        var cfg = window.__MAINTAINER_PRO__ || {};
+        AiUi.init({
+          apiUrl: cfg.apiUrl || "/api/chat",
+          title: "AI Assistant",
+          maintainerProUrl: cfg.maintainerProUrl || undefined,
+          maintainerProApiKey: cfg.maintainerProApiKey || undefined,
+        });
+      })();
+    </script>
+  </body>
+</html>
+`;
+}
+const WIDGET_MARKER = "AiUi.init";
+function injectHtmlWidget(html, aiServerUrl) {
+  if (html.includes(WIDGET_MARKER) || html.includes("ai-ui.iife.js")) {
+    return { html, injected: false };
+  }
+  const snippet = `
+<script src="${aiServerUrl}/embed-config.js"></script>
+<script src="${aiServerUrl}/ai-ui.iife.js"></script>
+<script>
+  (function () {
+    var cfg = window.__MAINTAINER_PRO__ || {};
+    if (!cfg.apiUrl) {
+      console.error("Maintainer Pro: embed-config.js missing apiUrl (is ai-server running?)");
+      return;
+    }
+    AiUi.init({
+      apiUrl: cfg.apiUrl,
+      title: "AI Assistant",
+      maintainerProUrl: cfg.maintainerProUrl || undefined,
+      maintainerProApiKey: cfg.maintainerProApiKey || undefined,
+    });
+  })();
+</script>
+`;
+  if (/<\/body>/i.test(html)) {
+    return {
+      html: html.replace(/<\/body>/i, `${snippet}</body>`),
+      injected: true,
+    };
+  }
+  return { html: html + snippet, injected: true };
+}
+function nextWidgetComponentSource() {
+  return `"use client";
+import { useEffect } from "react";
+declare global {
+  interface Window {
+    AiUi?: { init: (opts: Record<string, unknown>) => void; destroy?: () => void };
+    __MAINTAINER_PRO__?: {
+      aiServerUrl?: string;
+      apiUrl?: string;
+      maintainerProUrl?: string;
+      maintainerProApiKey?: string;
+    };
+  }
+}
+const AI_SERVER_URL = (process.env.NEXT_PUBLIC_AI_SERVER_URL || "").replace(/\\/$/, "");
+export function MaintainerProWidget() {
+  useEffect(() => {
+    if (!AI_SERVER_URL) {
+      console.error("Set NEXT_PUBLIC_AI_SERVER_URL to the ai-server origin");
+      return;
+    }
+    let cancelled = false;
+    const start = (cfg: {
+      apiUrl?: string;
+      maintainerProUrl?: string;
+      maintainerProApiKey?: string;
+    }) => {
+      if (cancelled) return;
+      const AiUi = window.AiUi;
+      if (!AiUi?.init) {
+        setTimeout(() => start(cfg), 40);
+        return;
+      }
+      AiUi.init({
+        apiUrl: cfg.apiUrl || \`\${AI_SERVER_URL}/api/chat\`,
+        title: "AI Assistant",
+        maintainerProUrl: cfg.maintainerProUrl,
+        maintainerProApiKey: cfg.maintainerProApiKey,
+      });
+    };
+    const ensureScript = (src: string) =>
+      new Promise<void>((resolve, reject) => {
+        const existing = document.querySelector<HTMLScriptElement>(\`script[src="\${src}"]\`);
+        if (existing) {
+          if (existing.dataset.loaded === "1") resolve();
+          else existing.addEventListener("load", () => resolve(), { once: true });
+          return;
+        }
+        const script = document.createElement("script");
+        script.src = src;
+        script.async = true;
+        script.onload = () => {
+          script.dataset.loaded = "1";
+          resolve();
+        };
+        script.onerror = () => reject(new Error(\`Failed to load \${src}\`));
+        document.body.appendChild(script);
+      });
+    void (async () => {
+      try {
+        await ensureScript(\`\${AI_SERVER_URL}/embed-config.js\`);
+        await ensureScript(\`\${AI_SERVER_URL}/ai-ui.iife.js\`);
+        start(window.__MAINTAINER_PRO__ || {});
+      } catch (err) {
+        console.error(err);
+      }
+    })();
+    return () => {
+      cancelled = true;
+      window.AiUi?.destroy?.();
+    };
+  }, []);
+  return null;
+}
+`;
+}
+function tryMountNextWidget(dir) {
+  const candidates = [
+    path.join(dir, "app", "layout.tsx"),
+    path.join(dir, "app", "layout.jsx"),
+    path.join(dir, "src", "app", "layout.tsx"),
+    path.join(dir, "src", "app", "layout.jsx"),
+  ];
+  for (const layout of candidates) {
+    if (!fs.existsSync(layout)) continue;
+    let text = fs.readFileSync(layout, "utf8");
+    if (text.includes("MaintainerProWidget")) {
+      return { mounted: false, reason: "already mounted" };
+    }
+    const fromAppRoot =
+      /[/\\]app[/\\]layout\.(t|j)sx$/.test(layout) &&
+      !/[/\\]src[/\\]app[/\\]/.test(layout);
+    const imp = fromAppRoot
+      ? "../components/MaintainerProWidget"
+      : "@/components/MaintainerProWidget";
+    text = `import { MaintainerProWidget } from "${imp}";\n` + text;
+    if (/\{children\}/.test(text)) {
+      text = text.replace(
+        /\{children\}/,
+        "{children}\n        <MaintainerProWidget />"
+      );
+      fs.writeFileSync(layout, text, "utf8");
+      return { mounted: true, layout };
+    }
+  }
+  return { mounted: false, reason: "no layout found" };
+}
+/**
+ * Configure client files for a workspace.
+ */
+function configureClient(opts) {
+  const {
+    dir,
+    port,
+    appName,
+    mode, // auto | empty | existing | skip
+    hostAppUrl,
+  } = opts;
+  const aiOrigin = `http://localhost:${port}`;
+  /** @type {string[]} */
+  const notes = [];
+  /** @type {string[]} */
+  const filesWritten = [];
+  let kind = detectProjectKind(dir);
+  if (mode === "empty") kind = "empty";
+  if (mode === "existing") {
+    if (kind === "empty") kind = "other";
+  }
+  if (mode === "skip") {
+    return {
+      kind: "skipped",
+      notes: ["Client scaffolding skipped (manual)."],
+      filesWritten,
+      corsOrigin: hostAppUrl || null,
+      appUrl: hostAppUrl || null,
+      sameOrigin: false,
+    };
+  }
+  if (kind === "empty" || mode === "empty") {
+    const indexPath = path.join(dir, "index.html");
+    if (!fs.existsSync(indexPath)) {
+      fs.writeFileSync(indexPath, emptyProjectIndexHtml(appName), "utf8");
+      filesWritten.push("index.html");
+      notes.push("Created index.html (served by ai-server).");
+    } else {
+      notes.push("index.html already present.");
+    }
+    return {
+      kind: "empty",
+      notes,
+      filesWritten,
+      corsOrigin: aiOrigin,
+      appUrl: hostAppUrl || aiOrigin,
+      sameOrigin: true,
+    };
+  }
+  if (kind === "html") {
+    const candidates = [
+      path.join(dir, "index.html"),
+      path.join(dir, "public", "index.html"),
+    ];
+    for (const htmlPath of candidates) {
+      if (!fs.existsSync(htmlPath)) continue;
+      const raw = fs.readFileSync(htmlPath, "utf8");
+      const { html, injected } = injectHtmlWidget(raw, aiOrigin);
+      if (injected) {
+        fs.writeFileSync(htmlPath, html, "utf8");
+        filesWritten.push(path.relative(dir, htmlPath));
+        notes.push(`Injected widget into ${path.relative(dir, htmlPath)}.`);
+      } else {
+        notes.push(`Widget already present in ${path.relative(dir, htmlPath)}.`);
+      }
+      break;
+    }
+    const origin = hostAppUrl || "http://localhost:3000";
+    return {
+      kind: "html",
+      notes,
+      filesWritten,
+      corsOrigin: origin,
+      appUrl: origin,
+      sameOrigin: false,
+    };
+  }
+  if (kind === "next") {
+    const envLocal = path.join(dir, ".env.local");
+    mergeEnvFile(envLocal, {
+      NEXT_PUBLIC_AI_SERVER_URL: aiOrigin,
+    });
+    filesWritten.push(".env.local");
+    notes.push("Set NEXT_PUBLIC_AI_SERVER_URL in .env.local.");
+    const useSrc = fs.existsSync(path.join(dir, "src", "app"));
+    const compDir = useSrc
+      ? path.join(dir, "src", "components")
+      : path.join(dir, "components");
+    fs.mkdirSync(compDir, { recursive: true });
+    const widgetPath = path.join(compDir, "MaintainerProWidget.tsx");
+    if (!fs.existsSync(widgetPath)) {
+      fs.writeFileSync(widgetPath, nextWidgetComponentSource(), "utf8");
+      filesWritten.push(path.relative(dir, widgetPath));
+      notes.push("Added MaintainerProWidget.tsx.");
+    }
+    const mount = tryMountNextWidget(dir);
+    if (mount.mounted) {
+      notes.push(`Mounted widget in ${path.relative(dir, mount.layout)}.`);
+    } else {
+      notes.push(
+        "Add <MaintainerProWidget /> to your root layout if it is not mounted yet."
+      );
+    }
+    const origin = hostAppUrl || "http://localhost:3000";
+    return {
+      kind: "next",
+      notes,
+      filesWritten,
+      corsOrigin: origin,
+      appUrl: origin,
+      sameOrigin: false,
+    };
+  }
+  // other — write host env hints only
+  const origin = hostAppUrl || "http://localhost:3000";
+  mergeEnvFile(path.join(dir, ".env"), {
+    AI_SERVER_URL: aiOrigin,
+    NEXT_PUBLIC_AI_SERVER_URL: aiOrigin,
+  });
+  notes.push(
+    "Existing project detected. Set AI_SERVER_URL / mount the widget manually if needed."
+  );
+  return {
+    kind: "other",
+    notes,
+    filesWritten,
+    corsOrigin: origin,
+    appUrl: origin,
+    sameOrigin: false,
+  };
+}
 function collectOfferedFolders(cfg) {
   /** @type {string[]} */
   const folders = [];
@@ -344,6 +739,13 @@ async function setupWorkspace(cfg, action) {
     action.sandboxId || action.payload?.sandboxId || ""
   );
   const port = Number(action.payload?.port) || 3100;
+  const clientMode = String(action.payload?.clientMode || "auto"); // auto|empty|existing|skip
+  const hostAppUrl =
+    typeof action.payload?.hostAppUrl === "string" &&
+    action.payload.hostAppUrl.trim()
+      ? action.payload.hostAppUrl.trim().replace(/\/$/, "")
+      : null;
   if (!folderPath || !sandboxId) {
     throw new Error("setup_workspace requires folderPath and sandboxId");
   }
@@ -357,13 +759,34 @@ async function setupWorkspace(cfg, action) {
     `/api/v1/bridge/machine/sandboxes/${sandboxId}/setup-config?port=${port}`
   );
+  const appName =
+    config.sandbox?.applicationName ||
+    config.sandbox?.name ||
+    "Maintainer Pro App";
+  const client = configureClient({
+    dir: resolved,
+    port,
+    appName,
+    mode: clientMode,
+    hostAppUrl,
+  });
+  const aiOrigin = `http://localhost:${port}`;
+  const corsOrigin = client.corsOrigin || aiOrigin;
+  const appUrl = client.appUrl || corsOrigin;
   const envPath = path.join(resolved, ".env");
   const envValues = {
     ...config.env,
     AI_CLI_WORKSPACE: ".",
-    AI_SERVER_UI: ".",
-    CORS_ORIGIN: process.env.CORS_ORIGIN || `http://localhost:${port}`,
-    APP_URL: process.env.APP_URL || `http://localhost:3000`,
+    AI_SERVER_UI: client.sameOrigin || client.kind === "empty" ? "." : ".",
+    PORT: String(port),
+    AI_SERVER_URL: aiOrigin,
+    NEXT_PUBLIC_AI_SERVER_URL: aiOrigin,
+    CORS_ORIGIN: corsOrigin,
+    APP_URL: appUrl,
+    AI_SERVER_PRODUCT_DESCRIPTION: appName,
   };
   mergeEnvFile(envPath, envValues);
@@ -375,6 +798,7 @@ async function setupWorkspace(cfg, action) {
     port,
     sandboxName: config.sandbox?.name,
     applicationName: config.sandbox?.applicationName,
+    clientKind: client.kind,
   };
   if (existing >= 0) cfg.workspaces[existing] = entry;
   else cfg.workspaces.push(entry);
@@ -384,16 +808,25 @@ async function setupWorkspace(cfg, action) {
   if (!cfg.noAiServer) {
     startAiServerForWorkspace(entry);
-    await new Promise((r) => setTimeout(r, 1200));
+    await new Promise((r) => setTimeout(r, 1500));
   }
+  const aiServerUp = await probeUrl(`${aiOrigin.replace("localhost", "127.0.0.1")}/embed-config.js`);
+  for (const note of client.notes) log(note);
   return {
     sandboxId,
     folderPath: resolved,
     port,
-    appUrl: envValues.APP_URL || null,
-    origins: envValues.CORS_ORIGIN ? [envValues.CORS_ORIGIN] : [],
+    appUrl,
+    origins: [corsOrigin, aiOrigin].filter(Boolean),
     wroteEnv: true,
+    clientKind: client.kind,
+    clientFiles: client.filesWritten,
+    clientNotes: client.notes,
+    aiServerUp,
+    openUrl: client.sameOrigin ? aiOrigin : appUrl,
   };
 }