@maintainer-pro/ai-bridge 0.1.3 → 0.1.5

package/package.json

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

package/src/daemon.mjs

@@ -850,7 +850,65 @@ const launchedAt = new Map();
 /** Last process problems to send on heartbeat. Key: sandboxId::code::role */
 const processProblems = new Map();
 
-function forgetLaunch(sandboxId) {
+/** @type {Map<string, Set<string>>} sandboxId -> CMD/terminal titles we opened */
+const openedTerminalTitles = new Map();
+
+function rememberTerminalTitle(sandboxId, title) {
+  const id = String(sandboxId || "").trim();
+  const name = String(title || "").trim();
+  if (!id || !name) return;
+  let titles = openedTerminalTitles.get(id);
+  if (!titles) {
+    titles = new Set();
+    openedTerminalTitles.set(id, titles);
+  }
+  titles.add(name);
+}
+
+function closeWindowsByTitle(title) {
+  const name = String(title || "").trim();
+  if (!name) return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => resolve();
+    if (process.platform === "win32") {
+      const child = spawn(
+        "taskkill",
+        ["/F", "/T", "/FI", `WINDOWTITLE eq ${name}*`],
+        { windowsHide: true, stdio: "ignore" }
+      );
+      child.on("exit", done);
+      child.on("error", done);
+      setTimeout(done, 4000);
+      return;
+    }
+    if (process.platform === "darwin") {
+      const child = spawn(
+        "osascript",
+        [
+          "-e",
+          `tell application "Terminal" to close (every window whose name contains ${JSON.stringify(name)})`,
+        ],
+        { stdio: "ignore" }
+      );
+      child.on("exit", done);
+      child.on("error", done);
+      setTimeout(done, 4000);
+      return;
+    }
+    done();
+  });
+}
+
+async function closeRememberedTerminals(sandboxId) {
+  const titles = openedTerminalTitles.get(sandboxId);
+  if (!titles) return;
+  for (const title of titles) {
+    await closeWindowsByTitle(title);
+  }
+  openedTerminalTitles.delete(sandboxId);
+}
+
+async function forgetLaunch(sandboxId) {
   for (const key of [...launchedAt.keys()]) {
     if (key === sandboxId || key.startsWith(`${sandboxId}:`)) {
       launchedAt.delete(key);
@@ -859,7 +917,8 @@ function forgetLaunch(sandboxId) {
   for (const key of [...processProblems.keys()]) {
     if (key.startsWith(`${sandboxId}::`)) processProblems.delete(key);
   }
-  stopCloudflare(sandboxId);
+  await closeRememberedTerminals(sandboxId);
+  await stopCloudflare(sandboxId);
 }
 
 function problemKey(sandboxId, code, role = "") {
@@ -1041,6 +1100,7 @@ function runLauncher(command, args, extra = {}) {
       child = spawn(command, args, {
         stdio: ["ignore", "pipe", "pipe"],
         windowsHide: extra.windowsHide,
+        windowsVerbatimArguments: Boolean(extra.windowsVerbatimArguments),
       });
     } catch (err) {
       done({
@@ -1073,7 +1133,7 @@ function runLauncher(command, args, extra = {}) {
 }
 
 async function openInNewTerminal(opts) {
-  const { title, folder, command, env = {}, launchKey } = opts;
+  const { title, folder, command, env = {}, launchKey, sandboxId } = opts;
   if (launchKey) {
     if (!opts.force && recentlyLaunched(launchKey)) {
       return { ok: true, skipped: true };
@@ -1086,6 +1146,13 @@ async function openInNewTerminal(opts) {
     return { ok: false, error };
   }
 
+  await closeWindowsByTitle(title);
+  await sleep(250);
+  rememberTerminalTitle(
+    sandboxId || String(launchKey || "").split(":")[0],
+    title
+  );
+
   const envWin = Object.entries(env)
     .map(([key, value]) => `set ${key}=${value}`)
     .join("&& ");
@@ -1097,18 +1164,16 @@ async function openInNewTerminal(opts) {
 
   try {
     if (process.platform === "win32") {
-      const inner = `cd /d "${folder}" && ${envWin ? `${envWin}&& ` : ""}title ${title}&& ${command}`;
-      const escaped = inner.replace(/'/g, "''");
+      const safeTitle =
+        String(title || "Maintainer Pro").replace(/["&<>|^]/g, " ").trim() ||
+        "Maintainer Pro";
+      const body = [envWin, `title ${safeTitle}`, command]
+        .filter(Boolean)
+        .join("&& ");
       const opened = await runLauncher(
-        "powershell.exe",
-        [
-          "-NoProfile",
-          "-WindowStyle",
-          "Hidden",
-          "-Command",
-          `Start-Process -FilePath $env:ComSpec -WorkingDirectory ${JSON.stringify(folder)} -ArgumentList @('/k', '${escaped}')`,
-        ],
-        { windowsHide: true }
+        process.env.ComSpec || "cmd.exe",
+        ["/d", "/s", "/c", `start "${safeTitle}" /D "${folder}" cmd.exe /k ${body}`],
+        { windowsVerbatimArguments: true }
       );
       if (!opened.ok) {
         return { ok: false, error: friendlyLaunchError(opened.error, title) };
@@ -1255,6 +1320,7 @@ async function startAiServerForWorkspace(ws, opts = {}) {
       NEXT_PUBLIC_AI_SERVER_URL: `http://localhost:${port}`,
     },
     launchKey,
+    sandboxId: ws.sandboxId,
   });
   if (opened.skipped) {
     return { port, up: false, launched: false, starting: true };
@@ -1382,6 +1448,7 @@ async function stopWorkspaceApps(ws) {
     }
   }
   log(`stopping local apps on ports ${[...ports].join(", ") || "(none)"}`);
+  await closeRememberedTerminals(ws.sandboxId);
   for (const port of ports) {
     await killPort(port);
   }
@@ -1413,12 +1480,10 @@ async function waitForUrlInFile(file, timeoutMs = 90_000) {
 }
 
 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)}`;
+  const logArg = JSON.stringify(logFile);
+  const run = `npx --yes cloudflared tunnel --url ${localUrl} --no-autoupdate --logfile ${logArg}`;
+  if (process.platform === "win32") return run;
+  return `${run} 2>&1 | tee ${logArg}`;
 }
 
 async function startCloudflareTerminal(ws, role, localUrl) {
@@ -1439,6 +1504,7 @@ async function startCloudflareTerminal(ws, role, localUrl) {
     folder,
     command: cloudflaredCommand(localUrl, logFile),
     launchKey: `${ws.sandboxId}:cf:${role}`,
+    sandboxId: ws.sandboxId,
     force: true,
   });
   if (!opened.ok) {
@@ -1501,22 +1567,52 @@ function writeTunnelEnv(ws, tunnels) {
   }
 }
 
-async function configureCloudflareForWorkspace(ws, cfg) {
-  const sandboxId = ws.sandboxId;
-  const label = ws.sandboxName || "this sandbox";
-  const folder = path.resolve(ws.folderPath || "");
+function reservedPortsFor(cfg, sandboxId) {
   const reserved = new Set();
   for (const other of cfg.workspaces || []) {
     if (other.sandboxId !== sandboxId && other.port) {
       reserved.add(Number(other.port));
     }
   }
+  return reserved;
+}
 
-  log(`Cloudflare setup for ${label}: stop apps, then tunnel ai-server/backend before UI`);
-  try {
+function appsWanted(ws) {
+  return Boolean(ws?.appsRequested);
+}
+
+async function configureCloudflareForWorkspace(ws, cfg) {
+  const sandboxId = ws.sandboxId;
+  const label = ws.sandboxName || "this sandbox";
+
+  log(`Cloudflare queued for ${label}: stop apps and wait for Start`);
   await stopCloudflare(sandboxId);
   await stopWorkspaceApps(ws);
+  await forgetLaunch(sandboxId);
+  ws.cloudflarePending = true;
+  ws.appsRequested = false;
+  persistWorkspaceEntry(cfg, ws);
 
+  return {
+    sandboxId,
+    folderPath: ws.folderPath,
+    port: ws.port,
+    pending: true,
+    cloudflarePending: true,
+    waitingForStart: true,
+    warning:
+      "Cloudflare is ready in Maintainer Pro. Use Start chat server when you want to launch the apps and create the public URLs.",
+  };
+}
+
+async function launchCloudflareTunnels(ws, cfg) {
+  const sandboxId = ws.sandboxId;
+  const label = ws.sandboxName || "this sandbox";
+  const folder = path.resolve(ws.folderPath || "");
+  const reserved = reservedPortsFor(cfg, sandboxId);
+
+  log(`Cloudflare start for ${label}: tunnel chat script/backend before UI`);
+  try {
   if (!cfg.noAiServer) {
     await startAiServerForWorkspace(ws, { reserved, cfg });
     await waitUntilReachable(
@@ -1596,6 +1692,8 @@ async function configureCloudflareForWorkspace(ws, cfg) {
   ws.cloudflareUrl = appUrl;
   ws.cloudflare = tunnels;
   ws.appUrl = appUrl;
+  ws.cloudflarePending = false;
+  ws.appsRequested = true;
   persistWorkspaceEntry(cfg, ws);
   cloudflareTunnels.set(sandboxId, { tunnels: started });
   clearProcessProblem(sandboxId, "cloudflare_launch", "tunnel");
@@ -1603,6 +1701,7 @@ async function configureCloudflareForWorkspace(ws, cfg) {
   return {
     sandboxId,
     folderPath: ws.folderPath,
+    port: ws.port,
     appUrl,
     origins: Object.values(tunnels).filter(Boolean),
     tunnels,
@@ -1618,13 +1717,52 @@ async function configureCloudflareForWorkspace(ws, cfg) {
       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",
+        "Install cloudflared or allow npx to download it, then use Start chat server again.",
+      actionCode: "start_ai_server",
     });
     throw err;
   }
 }
 
+async function startAppsForWorkspace(ws, cfg) {
+  if (ws.cloudflarePending) {
+    return launchCloudflareTunnels(ws, cfg);
+  }
+  ws.appsRequested = true;
+  persistWorkspaceEntry(cfg, ws);
+  const reserved = reservedPortsFor(cfg, ws.sandboxId);
+  if (!cfg.noAiServer) {
+    await startAiServerForWorkspace(ws, { reserved, cfg });
+    await sleep(1500);
+  }
+  const startedHosts = await ensureHostProcesses(ws, {
+    reserved,
+    cfg,
+    force: true,
+  });
+  await sleep(800);
+  await inspectHostJobs(ws);
+  const up = await probeUrl(`http://127.0.0.1:${ws.port}/embed-config.js`);
+  if (up) {
+    clearProcessProblem(ws.sandboxId, "ai_server_launch", "ai");
+    clearProcessProblem(ws.sandboxId, "apps_not_started");
+  }
+  const processIssues = issuesForSandbox(ws.sandboxId).map(
+    ({ role: _role, ...issue }) => issue
+  );
+  const warning = processIssues[0]?.message || null;
+  return {
+    up,
+    startedHosts,
+    sandboxId: ws.sandboxId,
+    folderPath: ws.folderPath,
+    port: ws.port,
+    appUrl: ws.appUrl,
+    processIssues,
+    warning,
+  };
+}
+
 async function ensureHostProcesses(ws, opts = {}) {
   const reserved = opts.reserved instanceof Set ? opts.reserved : new Set();
   const cfg = opts.cfg || null;
@@ -1704,6 +1842,7 @@ async function ensureHostProcesses(ws, opts = {}) {
       command,
       env: { PORT: String(port), ...extraEnv },
       launchKey,
+      sandboxId: ws.sandboxId,
       force: Boolean(opts.force),
     });
     if (opened.skipped) continue;
@@ -1763,6 +1902,11 @@ async function inspectHostJobs(ws) {
       clearProcessProblem(ws.sandboxId, "host_process_down", job.role);
       continue;
     }
+    if (!appsWanted(ws)) {
+      clearProcessProblem(ws.sandboxId, "host_process_launch", job.role);
+      clearProcessProblem(ws.sandboxId, "host_process_down", job.role);
+      continue;
+    }
     if (starting) continue;
     const tried = launchedAt.has(launchKey);
     recordProcessProblem({
@@ -1863,6 +2007,8 @@ async function setupWorkspace(cfg, action) {
     clientKind: client.kind,
     appUrl,
     sameOrigin: Boolean(client.sameOrigin),
+    appsRequested: false,
+    cloudflarePending: false,
   };
   if (existing >= 0) cfg.workspaces[existing] = entry;
   else cfg.workspaces.push(entry);
@@ -1881,12 +2027,6 @@ async function setupWorkspace(cfg, action) {
       .join("\n"),
   });
 
-  if (!cfg.noAiServer) {
-    await startAiServerForWorkspace(entry, { reserved, cfg });
-    await sleep(1500);
-  }
-  const startedHosts = await ensureHostProcesses(entry, { reserved, cfg });
-  await sleep(800);
   await inspectHostJobs(entry);
 
   const openUrl = client.sameOrigin
@@ -1895,23 +2035,22 @@ async function setupWorkspace(cfg, action) {
   const aiServerUp = await probeUrl(`http://127.0.0.1:${entry.port}/embed-config.js`);
   if (aiServerUp) {
     clearProcessProblem(sandboxId, "ai_server_launch", "ai");
+    clearProcessProblem(sandboxId, "apps_not_started");
   }
 
   const processIssues = issuesForSandbox(sandboxId).map(
     ({ role: _role, ...issue }) => issue
   );
-  const warning = processIssues[0]?.message || null;
+  const waitingForStart = !aiServerUp;
+  const warning = waitingForStart
+    ? "Folder is attached in Maintainer Pro. Use Start chat server when you want to launch the apps."
+    : processIssues[0]?.message || null;
 
   for (const note of client.notes) log(note);
-  if (startedHosts.length) {
-    log(`started ${startedHosts.join(" + ")} in separate terminals`);
-  }
-  if (aiServerUp) {
-    log(`ai-server up — open ${openUrl}`);
-  } else if (warning) {
-    log(`process issue: ${warning}`);
+  if (waitingForStart) {
+    log(`folder attached — waiting for Start (${openUrl})`);
   } else {
-    log("ai-server not reachable yet; it may still be starting");
+    log(`ai-server already up — open ${openUrl}`);
   }
 
   return {
@@ -1925,10 +2064,11 @@ async function setupWorkspace(cfg, action) {
     clientFiles: client.filesWritten,
     clientNotes: client.notes,
     aiServerUp,
-    startedHosts,
+    startedHosts: [],
     openUrl,
     processIssues,
     warning,
+    waitingForStart,
     projectInfo,
   };
 }
@@ -1970,12 +2110,6 @@ async function runActions(cfg, actions) {
           ok = false;
           result = { error: "No workspace or --no-ai-server" };
         } else {
-          const reserved = new Set();
-          for (const other of cfg.workspaces || []) {
-            if (other.sandboxId !== ws.sandboxId && other.port) {
-              reserved.add(Number(other.port));
-            }
-          }
           const problem = issuesForSandbox(ws.sandboxId)
             .map((issue) => issue.message)
             .join("\n");
@@ -1985,32 +2119,15 @@ async function runActions(cfg, actions) {
               problem ||
               "Local processes are not running or the project setup looks incomplete.",
           });
-          await startAiServerForWorkspace(ws, { reserved, cfg });
-          await sleep(1500);
-          const startedHosts = await ensureHostProcesses(ws, { reserved, cfg });
-          await sleep(800);
-          await inspectHostJobs(ws);
-          const up = await probeUrl(
-            `http://127.0.0.1:${ws.port}/embed-config.js`
-          );
-          if (up) clearProcessProblem(ws.sandboxId, "ai_server_launch", "ai");
-          const processIssues = issuesForSandbox(ws.sandboxId).map(
-            ({ role: _role, ...issue }) => issue
-          );
-          const warning = processIssues[0]?.message || null;
           result = {
-            up,
-            startedHosts,
-            sandboxId: ws.sandboxId,
-            folderPath: ws.folderPath,
-            port: ws.port,
-            appUrl: ws.appUrl,
-            processIssues,
-            warning,
+            ...(await startAppsForWorkspace(ws, cfg)),
             projectInfo,
           };
-          if (processIssues.some((issue) => issue.code === "ai_server_launch")) {
-            result.error = warning;
+          if (
+            Array.isArray(result.processIssues) &&
+            result.processIssues.some((issue) => issue.code === "ai_server_launch")
+          ) {
+            result.error = result.warning;
             ok = false;
           }
         }
@@ -2051,7 +2168,7 @@ async function runActions(cfg, actions) {
         const sandboxId = String(
           action.sandboxId || action.payload?.sandboxId || ""
         );
-        forgetLaunch(sandboxId);
+        await forgetLaunch(sandboxId);
         cfg.workspaces = (cfg.workspaces || []).filter(
           (w) => w.sandboxId !== sandboxId
         );
@@ -2100,6 +2217,7 @@ async function collectWorkspaceStates(cfg) {
       aiServerUp: up,
       startingAi: recentlyLaunched(`${ws.sandboxId}:${folder}:ai`),
       appUrl: ws.appUrl || null,
+      appsRequested: appsWanted(ws),
     });
   }
   return localStates;
@@ -2122,6 +2240,7 @@ async function sendHeartbeat(cfg, folders, localStates) {
         aiServerUp: st.aiServerUp,
         port: st.port,
         appUrl: st.appUrl || undefined,
+        appsRequested: Boolean(st.appsRequested),
       })),
     }
   );
@@ -2145,6 +2264,19 @@ async function buildIssues(cfg, workspaceStates) {
   }
   for (const st of workspaceStates) {
     if (st.aiServerUp || st.startingAi) continue;
+    if (!st.appsRequested) {
+      issues.push({
+        code: "apps_not_started",
+        severity: "info",
+        title: `Apps are not running (${st.sandboxName || "sandbox"})`,
+        message:
+          "This folder is attached in Maintainer Pro. Use Start chat server when you want to launch the local apps.",
+        resolution: "Use Start chat server.",
+        actionCode: "start_ai_server",
+        sandboxId: st.sandboxId,
+      });
+      continue;
+    }
     const launch = [...processProblems.values()].find(
       (issue) =>
         issue.sandboxId === st.sandboxId && issue.code === "ai_server_launch"
@@ -2281,13 +2413,18 @@ async function main() {
         const up = await probeUrl(
           `http://127.0.0.1:${ws.port}/embed-config.js`
         );
-        if (!cfg.noAiServer && !up) {
+        if (appsWanted(ws) && !cfg.noAiServer && !up) {
           await startAiServerForWorkspace(ws, { reserved, cfg });
         } else if (ws.port) {
           reserved.add(Number(ws.port));
-          if (up) clearProcessProblem(ws.sandboxId, "ai_server_launch", "ai");
+          if (up) {
+            clearProcessProblem(ws.sandboxId, "ai_server_launch", "ai");
+            clearProcessProblem(ws.sandboxId, "apps_not_started");
+          }
+        }
+        if (appsWanted(ws)) {
+          await ensureHostProcesses(ws, { reserved, cfg });
         }
-        await ensureHostProcesses(ws, { reserved, cfg });
         await inspectHostJobs(ws);
         localStates.push({
           sandboxId: ws.sandboxId,
@@ -2297,6 +2434,7 @@ async function main() {
           aiServerUp: up,
           startingAi: recentlyLaunched(`${ws.sandboxId}:${folder}:ai`),
           appUrl: ws.appUrl || null,
+          appsRequested: appsWanted(ws),
         });
       }