@maintainer-pro/ai-bridge 0.1.2 → 0.1.3

package/package.json

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

package/src/daemon.mjs

@@ -1075,7 +1075,9 @@ function runLauncher(command, args, extra = {}) {
 async function openInNewTerminal(opts) {
   const { title, folder, command, env = {}, launchKey } = opts;
   if (launchKey) {
-    if (recentlyLaunched(launchKey)) return { ok: true, skipped: true };
+    if (!opts.force && recentlyLaunched(launchKey)) {
+      return { ok: true, skipped: true };
+    }
     launchedAt.set(launchKey, Date.now());
   }
   if (!fs.existsSync(folder)) {
@@ -1276,188 +1278,350 @@ function sleep(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
-/** @type {Map<string, { child: import("node:child_process").ChildProcess, url: string | null, localUrl: string }>} */
+/** @type {Map<string, { tunnels: Array<{ role: string, localUrl: string, publicUrl: string | null, logFile: string }> }>} */
 const cloudflareTunnels = new Map();
 
+function stopAllCloudflare() {
+  for (const id of [...cloudflareTunnels.keys()]) stopCloudflare(id);
+}
+
+function parseTryCloudflareUrl(text) {
+  const match = String(text || "").match(
+    /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i
+  );
+  return match ? match[0].replace(/\/$/, "") : null;
+}
+
+function killProcessesByCommand(fragment) {
+  if (!fragment) return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => resolve();
+    if (process.platform === "win32") {
+      const escaped = String(fragment).replace(/'/g, "''");
+      const child = spawn(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-Command",
+          `Get-CimInstance Win32_Process | Where-Object { $_.CommandLine -like '*${escaped}*' } | ForEach-Object { Stop-Process -Id $_.ProcessId -Force -ErrorAction SilentlyContinue }`,
+        ],
+        { windowsHide: true, stdio: "ignore" }
+      );
+      child.on("exit", done);
+      child.on("error", done);
+      setTimeout(done, 8000);
+      return;
+    }
+    const child = spawn("pkill", ["-f", String(fragment)], { stdio: "ignore" });
+    child.on("exit", done);
+    child.on("error", done);
+    setTimeout(done, 4000);
+  });
+}
+
+function killPort(port) {
+  const n = Number(port);
+  if (!n) return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => resolve();
+    if (process.platform === "win32") {
+      const child = spawn(
+        "powershell.exe",
+        [
+          "-NoProfile",
+          "-Command",
+          `$ErrorActionPreference='SilentlyContinue'; $pids=@(); $pids += Get-NetTCPConnection -LocalPort ${n} -State Listen | Select-Object -ExpandProperty OwningProcess; if (-not $pids) { netstat -ano | Select-String ':${n}\\s' | ForEach-Object { if ($_ -match 'LISTENING\\s+(\\d+)') { $pids += [int]$Matches[1] } } }; $pids | Sort-Object -Unique | Where-Object { $_ -gt 0 -and $_ -ne ${process.pid} } | ForEach-Object { Stop-Process -Id $_ -Force }`,
+        ],
+        { windowsHide: true, stdio: "ignore" }
+      );
+      child.on("exit", done);
+      child.on("error", done);
+      setTimeout(done, 8000);
+      return;
+    }
+    const child = spawn(
+      "sh",
+      ["-c", `pids=$(lsof -ti tcp:${n} 2>/dev/null); [ -n "$pids" ] && kill $pids`],
+      { stdio: "ignore" }
+    );
+    child.on("exit", done);
+    child.on("error", done);
+    setTimeout(done, 4000);
+  });
+}
+
 function stopCloudflare(sandboxId) {
   const row = cloudflareTunnels.get(sandboxId);
-  if (row?.child && !row.child.killed) {
+  const files = row?.tunnels?.map((t) => t.logFile).filter(Boolean) ?? [];
+  cloudflareTunnels.delete(sandboxId);
+  return Promise.all(files.map((file) => killProcessesByCommand(file)));
+}
+
+function forgetProcessLaunches(sandboxId) {
+  for (const key of [...launchedAt.keys()]) {
+    if (key === sandboxId || key.startsWith(`${sandboxId}:`)) {
+      launchedAt.delete(key);
+    }
+  }
+}
+
+async function stopWorkspaceApps(ws) {
+  const folder = path.resolve(ws.folderPath || "");
+  const jobs = planHostJobs(folder, null, ws.projectInfo);
+  const ports = new Set();
+  if (ws.port) ports.add(Number(ws.port));
+  for (const job of jobs) {
+    if (job.preferredPort) ports.add(Number(job.preferredPort));
+  }
+  if (ws.appUrl && isLocalAppUrl(ws.appUrl)) {
     try {
-      row.child.kill();
+      const port = Number(new URL(ws.appUrl).port);
+      if (port) ports.add(port);
     } catch {
       /* ignore */
     }
   }
-  cloudflareTunnels.delete(sandboxId);
-}
-
-function stopAllCloudflare() {
-  for (const id of [...cloudflareTunnels.keys()]) stopCloudflare(id);
+  log(`stopping local apps on ports ${[...ports].join(", ") || "(none)"}`);
+  for (const port of ports) {
+    await killPort(port);
+  }
+  forgetProcessLaunches(ws.sandboxId);
+  await sleep(400);
 }
 
-function localUrlForWorkspace(ws) {
-  if (ws.appUrl && isLocalAppUrl(ws.appUrl)) return ws.appUrl;
-  return `http://127.0.0.1:${Number(ws.port) || 3100}`;
+async function waitUntilReachable(url, timeoutMs, label) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (await probeUrl(url)) return true;
+    await sleep(600);
+  }
+  throw new Error(`${label} did not become reachable at ${url}`);
 }
 
-function parseTryCloudflareUrl(text) {
-  const match = String(text || "").match(
-    /https:\/\/[a-z0-9-]+\.trycloudflare\.com/i
+async function waitForUrlInFile(file, timeoutMs = 90_000) {
+  const start = Date.now();
+  while (Date.now() - start < timeoutMs) {
+    if (fs.existsSync(file)) {
+      const url = parseTryCloudflareUrl(fs.readFileSync(file, "utf8"));
+      if (url) return url;
+    }
+    await sleep(500);
+  }
+  throw new Error(
+    `Cloudflare did not publish a URL in time (${path.basename(file)}). Check that terminal.`
   );
-  return match ? match[0].replace(/\/$/, "") : null;
 }
 
-function spawnCloudflared(localUrl) {
-  const args = ["tunnel", "--url", localUrl, "--no-autoupdate"];
-  const trySpawn = (file, argv, extra = {}) =>
-    new Promise((resolve, reject) => {
-      const child = spawn(file, argv, {
-        stdio: ["ignore", "pipe", "pipe"],
-        windowsHide: true,
-        ...extra,
-      });
-      const onError = (err) => reject(err);
-      child.once("error", onError);
-      child.once("spawn", () => {
-        child.off("error", onError);
-        resolve(child);
-      });
-    });
+function cloudflaredCommand(localUrl, logFile) {
+  const run = `npx --yes cloudflared tunnel --url ${localUrl} --no-autoupdate`;
+  if (process.platform === "win32") {
+    const dest = String(logFile).replace(/'/g, "''");
+    return `powershell -NoProfile -Command "${run} 2>&1 | Tee-Object -FilePath '${dest}'"`;
+  }
+  return `${run} 2>&1 | tee ${JSON.stringify(logFile)}`;
+}
 
-  return trySpawn("cloudflared", args).catch(() =>
-    trySpawn(
-      process.platform === "win32" ? "npx.cmd" : "npx",
-      ["--yes", "cloudflared", ...args],
-      { shell: process.platform === "win32" }
-    )
+async function startCloudflareTerminal(ws, role, localUrl) {
+  const folder = path.resolve(ws.folderPath);
+  const logDir = path.join(folder, ".maintainer-pro");
+  fs.mkdirSync(logDir, { recursive: true });
+  const logFile = path.join(
+    logDir,
+    `cf-${String(ws.sandboxId).slice(0, 8)}-${role}.log`
   );
+  try {
+    fs.unlinkSync(logFile);
+  } catch {
+    /* ignore */
+  }
+  const opened = await openInNewTerminal({
+    title: `MP-cf-${role}`,
+    folder,
+    command: cloudflaredCommand(localUrl, logFile),
+    launchKey: `${ws.sandboxId}:cf:${role}`,
+    force: true,
+  });
+  if (!opened.ok) {
+    throw new Error(opened.error || `Could not open a Cloudflare terminal for ${role}`);
+  }
+  const publicUrl = await waitForUrlInFile(logFile);
+  return { role, localUrl, publicUrl, logFile };
 }
 
-function waitForTunnelUrl(child, timeoutMs = 90_000) {
-  return new Promise((resolve, reject) => {
-    let buffer = "";
-    let settled = false;
-    const done = (err, url) => {
-      if (settled) return;
-      settled = true;
-      clearTimeout(timer);
-      if (err) reject(err);
-      else resolve(url);
-    };
-    const onData = (chunk) => {
-      buffer += String(chunk);
-      const url = parseTryCloudflareUrl(buffer);
-      if (url) done(null, url);
-    };
-    child.stdout?.on("data", onData);
-    child.stderr?.on("data", onData);
-    child.once("exit", (code) => {
-      done(
-        new Error(
-          `cloudflared exited ${code ?? "early"} before it published a URL`
-        )
-      );
-    });
-    const timer = setTimeout(() => {
-      done(
-        new Error(
-          "Cloudflare did not publish a URL in time. Is cloudflared installed and online?"
-        )
-      );
-    }, timeoutMs);
-  });
+function uiPublicEnv(tunnels) {
+  /** @type {Record<string, string>} */
+  const env = {};
+  if (tunnels.ai) {
+    env.AI_SERVER_URL = tunnels.ai;
+    env.NEXT_PUBLIC_AI_SERVER_URL = tunnels.ai;
+    env.VITE_AI_SERVER_URL = tunnels.ai;
+  }
+  if (tunnels.backend) {
+    env.API_URL = tunnels.backend;
+    env.API_BASE_URL = tunnels.backend;
+    env.VITE_API_URL = tunnels.backend;
+    env.VITE_API_BASE_URL = tunnels.backend;
+    env.NEXT_PUBLIC_API_URL = tunnels.backend;
+    env.NEXT_PUBLIC_API_BASE_URL = tunnels.backend;
+    env.BACKEND_URL = tunnels.backend;
+  }
+  if (tunnels.ui) {
+    env.APP_URL = tunnels.ui;
+    env.PUBLIC_URL = tunnels.ui;
+    env.CORS_ORIGIN = tunnels.ui;
+  } else if (tunnels.ai) {
+    env.CORS_ORIGIN = tunnels.ai;
+  }
+  return env;
+}
+
+function writeTunnelEnv(ws, tunnels) {
+  const folder = ws.folderPath ? path.resolve(ws.folderPath) : null;
+  if (!folder || !fs.existsSync(folder)) return;
+  const env = uiPublicEnv(tunnels);
+  const lines = Object.entries(tunnels)
+    .filter(([, url]) => url)
+    .map(([role, url]) => `${role}=${url}`);
+  fs.writeFileSync(
+    path.join(folder, ".cloudflare-tunnel-url"),
+    `${lines.join("\n")}\n`,
+    "utf8"
+  );
+  const envPath = path.join(folder, ".env");
+  if (Object.keys(env).length) mergeEnvFile(envPath, env);
+  const localEnv = {};
+  if (env.NEXT_PUBLIC_AI_SERVER_URL) {
+    localEnv.NEXT_PUBLIC_AI_SERVER_URL = env.NEXT_PUBLIC_AI_SERVER_URL;
+  }
+  if (env.NEXT_PUBLIC_API_URL) {
+    localEnv.NEXT_PUBLIC_API_URL = env.NEXT_PUBLIC_API_URL;
+  }
+  if (Object.keys(localEnv).length) {
+    mergeEnvFile(path.join(folder, ".env.local"), localEnv);
+  }
 }
 
 async function configureCloudflareForWorkspace(ws, cfg) {
   const sandboxId = ws.sandboxId;
   const label = ws.sandboxName || "this sandbox";
-  const localUrl = localUrlForWorkspace(ws);
-  const existing = cloudflareTunnels.get(sandboxId);
-  if (existing?.url && existing.localUrl === localUrl && existing.child && !existing.child.killed) {
-    return {
-      sandboxId,
-      folderPath: ws.folderPath,
-      appUrl: existing.url,
-      origins: [existing.url],
-      localUrl,
-      cloudflare: true,
-      reused: true,
-    };
+  const folder = path.resolve(ws.folderPath || "");
+  const reserved = new Set();
+  for (const other of cfg.workspaces || []) {
+    if (other.sandboxId !== sandboxId && other.port) {
+      reserved.add(Number(other.port));
+    }
   }
-  if (existing) stopCloudflare(sandboxId);
 
-  log(`starting Cloudflare tunnel for ${label} → ${localUrl}`);
-  let child;
+  log(`Cloudflare setup for ${label}: stop apps, then tunnel ai-server/backend before UI`);
   try {
-    child = await spawnCloudflared(localUrl);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    recordProcessProblem({
-      sandboxId,
-      code: "cloudflare_launch",
-      role: "tunnel",
-      title: `Could not start Cloudflare (${label})`,
-      message,
-      resolution:
-        "Install cloudflared (https://developers.cloudflare.com/cloudflare-one/connections/connect-networks/downloads/) or allow npx to download it, then try again.",
-      actionCode: "configure_cloudflare",
-    });
-    throw new Error(
-      `Could not start cloudflared. Install it or allow npx to download it. ${message}`
+  await stopCloudflare(sandboxId);
+  await stopWorkspaceApps(ws);
+
+  if (!cfg.noAiServer) {
+    await startAiServerForWorkspace(ws, { reserved, cfg });
+    await waitUntilReachable(
+      `http://127.0.0.1:${ws.port}/embed-config.js`,
+      45_000,
+      "Chat script"
     );
   }
 
-  cloudflareTunnels.set(sandboxId, { child, url: null, localUrl });
-  child.once("exit", () => {
-    const row = cloudflareTunnels.get(sandboxId);
-    if (row?.child === child) cloudflareTunnels.delete(sandboxId);
-  });
+  const jobs = planHostJobs(folder, null, ws.projectInfo);
+  const backendJob = jobs.find((job) => job.role === "backend");
+  const uiJob = jobs.find((job) => job.role === "ui" || job.role === "app");
 
-  const publicUrl = await waitForTunnelUrl(child);
-  cloudflareTunnels.set(sandboxId, { child, url: publicUrl, localUrl });
-  child.unref();
+  if (backendJob) {
+    await ensureHostProcesses(ws, {
+      reserved,
+      cfg,
+      onlyRoles: ["backend"],
+      force: true,
+    });
+    const backendPort = Number(backendJob.preferredPort) || 4100;
+    await waitUntilReachable(
+      `http://127.0.0.1:${backendPort}`,
+      45_000,
+      "Backend"
+    );
+  }
 
-  ws.cloudflareUrl = publicUrl;
-  ws.appUrl = publicUrl;
-  const folder = ws.folderPath ? path.resolve(ws.folderPath) : null;
-  if (folder && fs.existsSync(folder)) {
-    fs.writeFileSync(
-      path.join(folder, ".cloudflare-tunnel-url"),
-      `${publicUrl}\n`,
-      "utf8"
+  /** @type {Record<string, string>} */
+  const tunnels = {};
+  /** @type {Array<{ role: string, localUrl: string, publicUrl: string | null, logFile: string }>} */
+  const started = [];
+
+  const aiLocal = `http://127.0.0.1:${Number(ws.port) || 3100}`;
+  const aiTunnel = await startCloudflareTerminal(ws, "ai", aiLocal);
+  tunnels.ai = aiTunnel.publicUrl;
+  started.push(aiTunnel);
+  log(`Cloudflare chat script: ${aiTunnel.publicUrl}`);
+
+  if (backendJob) {
+    const backendLocal = `http://127.0.0.1:${Number(backendJob.preferredPort) || 4100}`;
+    const backendTunnel = await startCloudflareTerminal(ws, "backend", backendLocal);
+    tunnels.backend = backendTunnel.publicUrl;
+    started.push(backendTunnel);
+    log(`Cloudflare backend: ${backendTunnel.publicUrl}`);
+  }
+
+  writeTunnelEnv(ws, tunnels);
+  const uiEnv = uiPublicEnv(tunnels);
+
+  if (uiJob) {
+    await ensureHostProcesses(ws, {
+      reserved,
+      cfg,
+      onlyRoles: ["ui", "app"],
+      extraEnv: uiEnv,
+      force: true,
+    });
+    const uiPort = Number(uiJob.preferredPort) || 5173;
+    await waitUntilReachable(`http://127.0.0.1:${uiPort}`, 60_000, "App UI");
+    const uiTunnel = await startCloudflareTerminal(
+      ws,
+      "ui",
+      `http://127.0.0.1:${uiPort}`
     );
-    const envPath = path.join(folder, ".env");
-    const envValues = {
-      APP_URL: publicUrl,
-      PUBLIC_URL: publicUrl,
-      CORS_ORIGIN: publicUrl,
-    };
-    if (isAiServerTarget(ws, localUrl)) {
-      envValues.AI_SERVER_URL = publicUrl;
-      envValues.NEXT_PUBLIC_AI_SERVER_URL = publicUrl;
-    }
-    if (fs.existsSync(envPath)) mergeEnvFile(envPath, envValues);
+    tunnels.ui = uiTunnel.publicUrl;
+    started.push(uiTunnel);
+    log(`Cloudflare UI: ${uiTunnel.publicUrl}`);
+    writeTunnelEnv(ws, tunnels);
+    launchedAt.delete(`${sandboxId}:${folder}:ai`);
+    await killPort(ws.port);
+    await sleep(1500);
+    await startAiServerForWorkspace(ws, { reserved, cfg });
   }
+
+  const appUrl = tunnels.ui || tunnels.ai;
+  ws.cloudflareUrl = appUrl;
+  ws.cloudflare = tunnels;
+  ws.appUrl = appUrl;
   persistWorkspaceEntry(cfg, ws);
+  cloudflareTunnels.set(sandboxId, { tunnels: started });
   clearProcessProblem(sandboxId, "cloudflare_launch", "tunnel");
-  log(`Cloudflare URL for ${label}: ${publicUrl}`);
+
   return {
     sandboxId,
     folderPath: ws.folderPath,
-    appUrl: publicUrl,
-    origins: [publicUrl],
-    localUrl,
+    appUrl,
+    origins: Object.values(tunnels).filter(Boolean),
+    tunnels,
     cloudflare: true,
     reused: false,
   };
-}
-
-function isAiServerTarget(ws, localUrl) {
-  try {
-    const port = Number(new URL(localUrl).port);
-    return port === Number(ws.port);
-  } catch {
-    return true;
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    recordProcessProblem({
+      sandboxId,
+      code: "cloudflare_launch",
+      role: "tunnel",
+      title: `Could not start Cloudflare (${label})`,
+      message,
+      resolution:
+        "Install cloudflared or allow npx to download it, then try Share with Cloudflare again.",
+      actionCode: "configure_cloudflare",
+    });
+    throw err;
   }
 }
 
@@ -1466,7 +1630,13 @@ async function ensureHostProcesses(ws, opts = {}) {
   const cfg = opts.cfg || null;
   const folder = path.resolve(ws.folderPath);
   const scripts = readPackageJson(folder)?.scripts || {};
-  const jobs = planHostJobs(folder, ws.appUrl || null, ws.projectInfo);
+  const jobs = planHostJobs(
+    folder,
+    ws.appUrl && isLocalAppUrl(ws.appUrl) ? ws.appUrl : null,
+    ws.projectInfo
+  );
+  const onlyRoles = Array.isArray(opts.onlyRoles) ? new Set(opts.onlyRoles) : null;
+  const extraEnv = opts.extraEnv && typeof opts.extraEnv === "object" ? opts.extraEnv : {};
   const started = [];
   let persisted = false;
   const label = ws.sandboxName || "this sandbox";
@@ -1484,6 +1654,7 @@ async function ensureHostProcesses(ws, opts = {}) {
   }
 
   for (const job of jobs) {
+    if (onlyRoles && !onlyRoles.has(job.role)) continue;
     const preferred = Number(job.preferredPort) || 3000;
     const probe = (job.probeUrl || `http://127.0.0.1:${preferred}`).replace(
       "localhost",
@@ -1497,7 +1668,7 @@ async function ensureHostProcesses(ws, opts = {}) {
       continue;
     }
     const launchKey = `${ws.sandboxId}:${folder}:${job.script}`;
-    if (recentlyLaunched(launchKey)) {
+    if (!opts.force && recentlyLaunched(launchKey)) {
       reserved.add(preferred);
       continue;
     }
@@ -1531,8 +1702,9 @@ async function ensureHostProcesses(ws, opts = {}) {
       title: `MP-${job.role}-${port}`,
       folder,
       command,
-      env: { PORT: String(port) },
+      env: { PORT: String(port), ...extraEnv },
       launchKey,
+      force: Boolean(opts.force),
     });
     if (opened.skipped) continue;
     if (!opened.ok) {
@@ -1563,7 +1735,11 @@ async function ensureHostProcesses(ws, opts = {}) {
 
 async function inspectHostJobs(ws) {
   const folder = path.resolve(ws.folderPath || "");
-  const jobs = planHostJobs(folder, ws.appUrl || null, ws.projectInfo);
+  const jobs = planHostJobs(
+    folder,
+    ws.appUrl && isLocalAppUrl(ws.appUrl) ? ws.appUrl : null,
+    ws.projectInfo
+  );
   const label = ws.sandboxName || "this sandbox";
   const hosts = [];
   for (const job of jobs) {