@maintainer-pro/ai-bridge 0.1.32 → 0.1.33

package/src/daemon.mjs

@@ -43,6 +43,18 @@ import {
   mergeCookieHeader,
   storeCorsCookies,
 } from "./cors-cookies.mjs";
+import {
+  isIntakeArtifactName,
+  startIntakeServer,
+} from "./intake-server.mjs";
+import {
+  flushWebsiteFeedback,
+  isIntakeBuiltWorkspace,
+  markIntakeBuilt,
+  queueWebsiteFeedback,
+  websiteFeedbackShouldFlush,
+  WEBSITE_FEEDBACK_CHECK_MS,
+} from "./website-feedback.mjs";
 import { WebSocket as WsWebSocket } from "ws";
 
 const __dirname = path.dirname(fileURLToPath(import.meta.url));
@@ -69,8 +81,52 @@ const WS_WATCHDOG_MS = 5_000;
 
 /** @type {import("@maintainer-pro/ai-cli").Logger} */
 let logger = createLogger("ai-bridge");
-const log = (msg) => logger.info(msg);
-const warn = (msg) => logger.warn(msg);
+const SECRET_KEY_RE =
+  /token|secret|password|authorization|cookie|api[_-]?key|bearer|pair/i;
+
+function sanitizeLogValue(value, depth = 0) {
+  if (value == null) return value;
+  if (typeof value === "string") {
+    return value.length > 280 ? `${value.slice(0, 280)}…` : value;
+  }
+  if (typeof value !== "object") return value;
+  if (depth > 2) return Array.isArray(value) ? `[${value.length} items]` : "[object]";
+  if (Array.isArray(value)) {
+    return value.slice(0, 16).map((item) => sanitizeLogValue(item, depth + 1));
+  }
+  /** @type {Record<string, unknown>} */
+  const out = {};
+  for (const [key, item] of Object.entries(value)) {
+    out[key] = SECRET_KEY_RE.test(key)
+      ? "[redacted]"
+      : sanitizeLogValue(item, depth + 1);
+  }
+  return out;
+}
+
+function logExtra(extra) {
+  return extra && typeof extra === "object" && !Array.isArray(extra)
+    ? extra
+    : extra != null
+      ? { detail: extra }
+      : undefined;
+}
+
+const log = (msg, extra) => {
+  const fields = logExtra(extra);
+  if (fields) logger.info(fields, String(msg));
+  else logger.info(String(msg));
+};
+const dbg = (msg, extra) => {
+  const fields = logExtra(extra);
+  if (fields) logger.debug(fields, String(msg));
+  else logger.debug(String(msg));
+};
+const warn = (msg, extra) => {
+  const fields = logExtra(extra);
+  if (fields) logger.warn(fields, String(msg));
+  else logger.warn(String(msg));
+};
 const fail = (msg) => {
   logger.fatal(msg);
   process.exit(1);
@@ -79,6 +135,9 @@ const fail = (msg) => {
 /** @type {Map<string, Array<{ at: string, level: string, message: string }>>} */
 const activityBySandbox = new Map();
 
+/** @type {Map<string, { port: number, close: () => Promise<void> }>} */
+const intakeServers = new Map();
+
 /** @type {(payload: Record<string, unknown>) => boolean} */
 let bridgeSend = () => false;
 
@@ -94,7 +153,7 @@ function activity(sandboxId, level, message) {
     level: level === "error" || level === "warn" ? level : "info",
     message: text.slice(0, 500),
   });
-  activityBySandbox.set(sandboxId, list.slice(-40));
+  activityBySandbox.set(sandboxId, list.slice(-80));
 }
 
 function activityLogFor(sandboxId) {
@@ -152,16 +211,30 @@ function resultSummary(result) {
   if (result.folderPath) bits.push(`folder=${result.folderPath}`);
   if (result.port) bits.push(`chat=${result.port}`);
   if (result.appUrl) bits.push(`app=${result.appUrl}`);
+  if (result.publicUrl) bits.push(`share=${result.publicUrl}`);
+  if (result.clientKind) bits.push(`kind=${result.clientKind}`);
+  if (result.intakeStatus) bits.push(`intake=${result.intakeStatus}`);
   if (Array.isArray(result.origins) && result.origins.length) {
     bits.push(`origins=${result.origins.join(",")}`);
   }
   if (typeof result.up === "boolean") bits.push(`chatUp=${result.up}`);
+  if (typeof result.running === "boolean") bits.push(`running=${result.running}`);
   if (typeof result.waitingForStart === "boolean") {
     bits.push(`waitingForStart=${result.waitingForStart}`);
   }
   if (Array.isArray(result.startedHosts) && result.startedHosts.length) {
     bits.push(`started=${result.startedHosts.join(",")}`);
   }
+  if (Array.isArray(result.hostApps) && result.hostApps.length) {
+    bits.push(
+      `apps=${result.hostApps
+        .map((app) => `${app?.id || app?.role || "?"}:${app?.port || "?"}`)
+        .join(",")}`
+    );
+  }
+  if (Array.isArray(result.processIssues) && result.processIssues.length) {
+    bits.push(`issues=${result.processIssues.length}`);
+  }
   if (result.warning) bits.push(`warning=${result.warning}`);
   return bits.join(" ");
 }
@@ -384,6 +457,7 @@ function fetchErrorDetail(err) {
 
 async function api(baseUrl, token, method, pathname, body) {
   const url = `${String(baseUrl || "").replace(/\/$/, "")}${pathname}`;
+  dbg(`admin ${method} ${pathname}`);
   if (!baseUrl) {
     throw new Error("Admin URL is missing. Pair this computer again.");
   }
@@ -415,10 +489,14 @@ async function api(baseUrl, token, method, pathname, body) {
     data = { raw: text };
   }
   if (!res.ok) {
+    warn(`admin ${method} ${pathname} → ${res.status}`, {
+      error: data?.error || text.slice(0, 200),
+    });
     throw new Error(
       data?.error || `Bridge API ${method} ${pathname} failed (${res.status})`
     );
   }
+  dbg(`admin ${method} ${pathname} → ${res.status}`);
   return data;
 }
 
@@ -943,6 +1021,63 @@ function persistWorkspaceEntry(cfg, ws) {
   saveConfig(cfg);
 }
 
+function liveBridgeConfig() {
+  return bridgeCfg || loadConfig();
+}
+
+function noteIntakeWebsiteFeedback(ws, userMessage) {
+  const cfg = liveBridgeConfig();
+  const live =
+    (cfg?.workspaces || []).find((row) => row.sandboxId === ws?.sandboxId) || ws;
+  if (!isIntakeBuiltWorkspace(live)) return;
+  if (!queueWebsiteFeedback(live, userMessage)) return;
+  persistWorkspaceEntry(cfg, live);
+  if (websiteFeedbackShouldFlush(live)) {
+    void flushIntakeWebsiteFeedback(live, cfg);
+  }
+}
+
+const websiteFeedbackFlushing = new Set();
+
+async function flushIntakeWebsiteFeedback(ws, cfg = liveBridgeConfig(), opts = {}) {
+  if (!cfg?.adminUrl || !cfg.token || !ws?.sandboxId) return;
+  if (!websiteFeedbackShouldFlush(ws, opts)) return;
+  if (websiteFeedbackFlushing.has(ws.sandboxId)) return;
+  websiteFeedbackFlushing.add(ws.sandboxId);
+  try {
+    const result = await flushWebsiteFeedback(ws, {
+      loadAiCli,
+      memorySource: {
+        baseUrl: cfg.adminUrl,
+        token: cfg.token,
+        sandboxId: ws.sandboxId,
+      },
+      api: (method, pathname, body) =>
+        api(cfg.adminUrl, cfg.token, method, pathname, body),
+    });
+    persistWorkspaceEntry(cfg, ws);
+    if (result.appended) {
+      activity(ws.sandboxId, "info", "Saved studio feedback for later websites");
+    }
+  } catch (err) {
+    warn(
+      `website memory flush ${shortId(ws.sandboxId)}: ${
+        err instanceof Error ? err.message : String(err)
+      }`
+    );
+  } finally {
+    websiteFeedbackFlushing.delete(ws.sandboxId);
+  }
+}
+
+async function flushAllIntakeWebsiteFeedback(opts = {}) {
+  const cfg = liveBridgeConfig();
+  const rows = Array.isArray(cfg?.workspaces) ? cfg.workspaces : [];
+  for (const ws of rows) {
+    await flushIntakeWebsiteFeedback(ws, cfg, opts);
+  }
+}
+
 /**
  * Sandbox store keys live on the workspace (and ~/.maintainer-pro/bridge.json),
  * not in the app .env. Never use the bridge machine token as MAINTAINER_PRO_API_KEY.
@@ -1824,6 +1959,9 @@ async function restoreHostsAfterReconnect(cfg) {
           status.host.origins.join(",") || "none"
         }`
       );
+    } else if (isIntakePendingWorkspace(ws)) {
+      await startIntakeForWorkspace(ws, cfg);
+      log(`intake form restored for ${label} on ${ws.sitePort}`);
     } else {
       log(
         `no apps running for ${label} — waiting for Start Apps from Maintainer Pro`
@@ -2032,12 +2170,13 @@ function detectProjectKind(dir) {
     return "html";
   }
 
-  // Only README / license → treat as empty scaffold target
+  // Only README / license / intake artifacts → treat as empty scaffold target
   const meaningful = names.filter(
     (n) =>
       !/^readme/i.test(n) &&
       !/^license/i.test(n) &&
-      n !== "package.json"
+      n !== "package.json" &&
+      !isIntakeArtifactName(n)
   );
   if (meaningful.length === 0 && !has("package.json")) return "empty";
 
@@ -2052,37 +2191,26 @@ function escapeHtml(value) {
     .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>
-`;
+function intakeHostApp(appName, port, folder) {
+  return {
+    id: "ui",
+    name: appName || "Website",
+    role: "ui",
+    port: Number(port),
+    startCommand: null,
+    source: "manual",
+    host: true,
+    folderPath: folder || null,
+  };
+}
+
+function isIntakePendingFolder(dir) {
+  return detectProjectKind(dir) === "empty";
+}
+
+function isIntakePendingWorkspace(ws) {
+  const folder = path.resolve(ws?.folderPath || "");
+  return Boolean(Number(ws?.sitePort)) && isIntakePendingFolder(folder);
 }
 
 /**
@@ -2096,6 +2224,7 @@ function configureClient(opts) {
     appName,
     mode, // auto | empty | existing | skip
     hostAppUrl,
+    sitePort,
   } = opts;
   const aiOrigin = `http://localhost:${port}`;
   /** @type {string[]} */
@@ -2120,21 +2249,22 @@ function configureClient(opts) {
   }
 
   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 (chat served in-process).");
-    } else {
-      notes.push("index.html already present.");
-    }
+    const origin = sitePort
+      ? `http://localhost:${sitePort}`
+      : hostAppUrl || aiOrigin;
+    notes.push(
+      sitePort
+        ? `Serving the business intake form on port ${sitePort}. The generated site will use the same port.`
+        : "Empty folder — waiting for a reserved site port."
+    );
     return {
       kind: "empty",
       notes,
       filesWritten,
-      corsOrigin: aiOrigin,
-      appUrl: hostAppUrl || aiOrigin,
-      sameOrigin: true,
+      corsOrigin: origin,
+      appUrl: origin,
+      sameOrigin: false,
+      sitePort: sitePort || null,
     };
   }
 
@@ -2182,6 +2312,172 @@ function configureClient(opts) {
   };
 }
 
+async function stopIntakeForWorkspace(sandboxId) {
+  const row = intakeServers.get(sandboxId);
+  if (!row) return;
+  intakeServers.delete(sandboxId);
+  try {
+    await row.close();
+  } catch {
+    /* ignore */
+  }
+}
+
+async function startIntakeForWorkspace(ws, cfg) {
+  const port = Number(ws.sitePort);
+  if (!port || !ws.sandboxId) return null;
+  const existing = intakeServers.get(ws.sandboxId);
+  if (existing && existing.port === port && (await portIsLive(port, 600))) {
+    dbg(`intake already listening ${shortId(ws.sandboxId)} :${port}`);
+    return existing;
+  }
+  if (existing) {
+    log(`intake restart ${shortId(ws.sandboxId)} :${existing.port} → :${port}`);
+    await stopIntakeForWorkspace(ws.sandboxId);
+  }
+  if (await portIsLive(port, 600)) {
+    warn(`intake skip ${shortId(ws.sandboxId)}: port ${port} already in use`);
+    return existing || null;
+  }
+  const instance = await startIntakeServer({
+    port,
+    appName: ws.applicationName || ws.sandboxName,
+    getStatus: () => ({
+      status: ws.intakeStatus || "form",
+      message: ws.intakeMessage || "",
+      startedAt: Number(ws.intakeStartedAt) || 0,
+      etaSeconds: 5 * 60,
+    }),
+    onSubmit: async (intake) => {
+      if (ws.intakeStatus === "building") {
+        warn(`intake submit ignored ${shortId(ws.sandboxId)}: already building`);
+        throw new Error("A website is already being created.");
+      }
+      ws.intakeStatus = "building";
+      ws.intakeStartedAt = Date.now();
+      ws.intakeMessage = "This usually takes about 5 minutes.";
+      persistWorkspaceEntry(cfg, ws);
+      const trade =
+        intake && typeof intake === "object"
+          ? String(intake.business?.tradeName || intake.slug || "")
+          : "";
+      activity(
+        ws.sandboxId,
+        "info",
+        `Intake received${trade ? ` (${trade})` : ""} — generating website`
+      );
+      log(`intake submit ${shortId(ws.sandboxId)} :${port}`, {
+        trade: trade || null,
+        pages: Array.isArray(intake?.pages) ? intake.pages.length : 0,
+      });
+      void generateSiteForWorkspace(ws, cfg, intake);
+    },
+  });
+  intakeServers.set(ws.sandboxId, instance);
+  if (!ws.intakeStatus) ws.intakeStatus = "form";
+  persistWorkspaceEntry(cfg, ws);
+  activity(ws.sandboxId, "info", `Intake form listening on port ${port}`);
+  log(`intake listening ${shortId(ws.sandboxId)} :${port} status=${ws.intakeStatus || "form"}`);
+  return instance;
+}
+
+async function generateSiteForWorkspace(ws, cfg, intake) {
+  const folder = path.resolve(ws.folderPath || "");
+  const sitePort = Number(ws.sitePort);
+  const label = ws.sandboxName || shortId(ws.sandboxId);
+  const startedAt = Date.now();
+  log(`generate site start ${label}`, { folder, sitePort });
+  try {
+    const cli = await loadAiCli();
+    if (typeof cli.generateWebsiteFromIntake !== "function") {
+      throw new Error(
+        "ai-cli is missing generateWebsiteFromIntake — update @maintainer-pro/ai-cli"
+      );
+    }
+    activity(
+      ws.sandboxId,
+      "info",
+      `Generating website for ${label} with the coding agent`
+    );
+    log(`generate site calling coding agent ${label} in ${folder}`);
+    const generated = await cli.generateWebsiteFromIntake({
+      workspaceDir: folder,
+      intake,
+      sitePort,
+      appName: ws.applicationName || ws.sandboxName,
+      memorySource: {
+        baseUrl: cfg.adminUrl,
+        token: cfg.token,
+        sandboxId: ws.sandboxId,
+      },
+    });
+    log(`generate site files ready ${label}`, {
+      provider: generated?.provider || null,
+      kind: detectProjectKind(folder),
+      ms: Date.now() - startedAt,
+    });
+    markIntakeBuilt(ws);
+    ws.intakeStatus = "ready";
+    ws.intakeStartedAt = null;
+    ws.intakeMessage = "Starting the preview…";
+    ws.clientKind = detectProjectKind(folder);
+    persistWorkspaceEntry(cfg, ws);
+    activity(ws.sandboxId, "info", "Website files created — starting preview");
+
+    await stopIntakeForWorkspace(ws.sandboxId);
+    await sleep(400);
+    if (await portIsLive(sitePort, 600)) {
+      await killPort(sitePort);
+      await sleep(400);
+    }
+
+    const detected = await resolveWorkspaceHostApps(ws, {
+      cfg,
+      force: true,
+      allowAi: false,
+      ignoreDesired: true,
+    });
+    const apps = listedHostApps(detected.apps || ws.hostApps || []);
+    const ui =
+      apps.find((app) => app.host || app.role === "ui" || app.role === "app") || {
+        id: "ui",
+        name: ws.applicationName || "Website",
+        role: "ui",
+        source: "package",
+      };
+    ws.hostApps = listedHostApps([
+      {
+        ...ui,
+        id: ui.id || "ui",
+        role: ui.role === "backend" ? "ui" : ui.role || "ui",
+        port: sitePort,
+        startCommand: ui.startCommand || "npm run dev",
+        source: ui.source || "package",
+        host: true,
+        folderPath: folder,
+      },
+      ...apps.filter(
+        (app) => app.id !== (ui.id || "ui") && app.role === "backend"
+      ),
+    ]);
+    ws.appsRequested = true;
+    persistWorkspaceEntry(cfg, ws);
+    await startAppsForWorkspace(ws, cfg);
+    activity(ws.sandboxId, "info", `Website preview on port ${sitePort}`);
+    log(`generate site done ${label} ${Date.now() - startedAt}ms :${sitePort}`);
+  } catch (err) {
+    const message = err instanceof Error ? err.message : String(err);
+    warn(`generate site failed ${label} ${Date.now() - startedAt}ms: ${message}`);
+    ws.intakeStatus = "error";
+    ws.intakeStartedAt = null;
+    ws.intakeMessage = message.slice(0, 400);
+    persistWorkspaceEntry(cfg, ws);
+    activity(ws.sandboxId, "error", `Website generation failed: ${message}`);
+    ws.intakeStatus = "form";
+    persistWorkspaceEntry(cfg, ws);
+  }
+}
+
 function collectOfferedFolders() {
   return [browseRootFromCwd()];
 }
@@ -2383,9 +2679,20 @@ function shareProxyContext(msg, ws, appId) {
     port: localPortForProxy(ws, appId),
     portUrls: { ...fromWs, ...fromMsg },
     bypassCors: msg?.bypassCors === true,
+    injectChat: !isIntakeShareWorkspace(ws),
   };
 }
 
+function isIntakeShareWorkspace(ws) {
+  const status = String(ws?.intakeStatus || "");
+  return (
+    status === "form" ||
+    status === "building" ||
+    status === "error" ||
+    isIntakePendingWorkspace(ws)
+  );
+}
+
 function sendProcessedProxyHttp(id, ctx, status, headers, body) {
   const processed = processShareHttpResponse({
     ...ctx,
@@ -2393,6 +2700,15 @@ function sendProcessedProxyHttp(id, ctx, status, headers, body) {
     headers,
     body,
   });
+  const pathOnly = String(ctx.path || "").split("?")[0] || "/";
+  if (processed.status >= 400 || pathOnly.includes("/__mp/")) {
+    log(`proxy ${processed.status} ${pathOnly} :${ctx.port || 0}`, {
+      slug: ctx.slug,
+      bytes: processed.body?.length || 0,
+    });
+  } else {
+    dbg(`proxy ${processed.status} ${pathOnly} :${ctx.port || 0}`);
+  }
   replyProxyHttp(id, processed.status, processed.headers, processed.body);
 }
 
@@ -2807,6 +3123,7 @@ function handleProxyHttpFromAdmin(msg) {
   if (!id) return;
   const ws = workspaceForProxy(sandboxId);
   if (!ws) {
+    warn(`proxy miss sandbox=${shortId(sandboxId)} app=${appId} id=${shortId(id)}`);
     bridgeSend({
       type: "proxy.http.error",
       id,
@@ -2829,6 +3146,9 @@ function handleProxyHttpFromAdmin(msg) {
   }
   const port = localPortForProxy(ws, appId);
   if (!port) {
+    warn(
+      `proxy no port sandbox=${shortId(sandboxId)} app=${appId} ${String(msg.method || "GET")} ${safeProxyPath(msg.path)}`
+    );
     bridgeSend({
       type: "proxy.http.error",
       id,
@@ -2840,6 +3160,21 @@ function handleProxyHttpFromAdmin(msg) {
   const path = safeProxyPath(msg.path);
   const ctx = shareProxyContext(msg, ws, appId);
   ctx.port = port;
+  const pathOnly = String(path || "").split("?")[0] || "/";
+  const notableProxy =
+    method !== "GET" && method !== "HEAD" ||
+    pathOnly.includes("/__mp/") ||
+    pathOnly === "/" ||
+    pathOnly === "";
+  if (notableProxy) {
+    log(`proxy ${method} ${pathOnly} → :${port} ${appId}`, {
+      sandbox: shortId(sandboxId),
+      slug: ctx.slug,
+      injectChat: ctx.injectChat !== false,
+    });
+  } else {
+    dbg(`proxy ${method} ${pathOnly} → :${port} ${appId}`);
+  }
   if (replyShareInterceptor(id, ctx, path)) return;
   const prepared = prepareShareHttpRequest(
     proxyReqHeaders(msg.headers),
@@ -3833,6 +4168,9 @@ async function startAiServerForWorkspace(ws, opts = {}) {
       logger: createLogger(`ai-server:${shortId(ws.sandboxId)}`),
       label: `ai-server:${shortId(ws.sandboxId)}`,
       listen: true,
+      onTurnComplete: ({ userMessage }) => {
+        noteIntakeWebsiteFeedback(ws, userMessage);
+      },
     });
     embeddedChat.set(ws.sandboxId, instance);
     ws.port = instance.port;
@@ -3921,6 +4259,7 @@ async function stopWorkspaceApps(ws) {
     }
   }
   log(`stopping local apps on ports ${[...ports].join(", ") || "(none)"}`);
+  await stopIntakeForWorkspace(ws.sandboxId);
   await stopEmbeddedChat(ws.sandboxId);
   await closeRememberedTerminals(ws.sandboxId);
   for (const port of ports) {
@@ -3950,8 +4289,11 @@ async function waitUntilReachable(url, timeoutMs, label, onWait) {
 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));
+    if (other.sandboxId === sandboxId) continue;
+    if (other.port) reserved.add(Number(other.port));
+    if (other.sitePort) reserved.add(Number(other.sitePort));
+    for (const app of listedHostApps(other.hostApps)) {
+      if (app.port) reserved.add(Number(app.port));
     }
   }
   return reserved;
@@ -4025,6 +4367,42 @@ async function startAppsForWorkspace(ws, cfg, opts = {}) {
 
   const chatEnv = chatLaunchEnv(ws, cfg);
 
+  if (isIntakePendingWorkspace(ws)) {
+    await startIntakeForWorkspace(ws, cfg);
+    if (!cfg.noAiServer) {
+      if (status.probe.chatUp) {
+        ws.port = status.probe.chatPort;
+      } else {
+        await startAiServerForWorkspace(ws, {
+          reserved,
+          cfg,
+          port: plan.aiPort,
+          env: chatEnv,
+        });
+      }
+    }
+    status = await reconcileWorkspacePresence(ws, cfg, { timeoutMs: 1200 });
+    return {
+      up: status.aiServerUp,
+      startedHosts: (await portIsLive(ws.sitePort, 800)) ? ["ui"] : [],
+      sandboxId: ws.sandboxId,
+      folderPath: ws.folderPath,
+      port: ws.port,
+      appUrl: status.host.appUrl || ws.appUrl,
+      origins: status.host.origins,
+      publicUrl:
+        proxyUrlForApp(
+          ws,
+          hostAppOf(ws) || { id: "ui", role: "ui", host: true }
+        ) || null,
+      hostApps: status.probe.hostApps || ws.hostApps || [],
+      processIssues: issuesForSandbox(ws.sandboxId).map(
+        ({ role: _role, ...issue }) => issue
+      ),
+      warning: null,
+    };
+  }
+
   if (!cfg.noAiServer) {
     if (status.probe.chatUp) {
       log(`chat already running on ${status.probe.chatPort} — not restarting`);
@@ -4454,12 +4832,7 @@ async function setupWorkspace(cfg, action) {
   );
   log(`setup begin sandbox=${shortId(sandboxId)} folder=${folderPath || "(none)"}`);
   const requestedPort = Number(action.payload?.port) || 3100;
-  const reserved = new Set();
-  for (const other of cfg.workspaces || []) {
-    if (other.sandboxId !== sandboxId && other.port) {
-      reserved.add(Number(other.port));
-    }
-  }
+  const reserved = reservedPortsFor(cfg, sandboxId);
   let port = requestedPort;
   if (await isChatServerOnPort(requestedPort)) {
     reserved.add(requestedPort);
@@ -4578,12 +4951,27 @@ async function setupWorkspace(cfg, action) {
     );
   }
 
+  let detectedKind = detectProjectKind(resolved);
+  if (clientMode === "empty") detectedKind = "empty";
+  log(`setup detect sandbox=${shortId(sandboxId)} kind=${detectedKind} mode=${clientMode}`);
+  let sitePort = 0;
+  if (
+    (detectedKind === "empty" || clientMode === "empty") &&
+    clientMode !== "skip" &&
+    clientMode !== "existing"
+  ) {
+    const preferredSite = Number(existingWs?.sitePort) || 3000;
+    sitePort = await findFreePort(preferredSite, reserved);
+    log(`setup site port ${sitePort} reserved for intake / Next.js`);
+  }
+
   const client = configureClient({
     dir: resolved,
     port,
     appName,
     mode: clientMode,
     hostAppUrl,
+    sitePort,
   });
 
   const aiOrigin = `http://localhost:${port}`;
@@ -4602,10 +4990,14 @@ async function setupWorkspace(cfg, action) {
     sandboxName: config.sandbox?.name,
     applicationName: config.sandbox?.applicationName,
     clientKind: client.kind,
-    appUrl,
-    sameOrigin: Boolean(client.sameOrigin),
-    appsRequested: existingWs?.appsRequested || false,
-    hostApps: existingWs?.hostApps,
+    appUrl: sitePort ? `http://localhost:${sitePort}` : appUrl,
+    sameOrigin: sitePort ? false : Boolean(client.sameOrigin),
+    appsRequested: existingWs?.appsRequested || Boolean(sitePort),
+    sitePort: sitePort || existingWs?.sitePort || null,
+    intakeStatus: sitePort ? "form" : existingWs?.intakeStatus || null,
+    hostApps: sitePort
+      ? [intakeHostApp(appName, sitePort, resolved)]
+      : existingWs?.hostApps,
     store: {
       serverKey: String(config.env?.MAINTAINER_PRO_API_KEY || "").trim(),
       clientKey: String(
@@ -4619,13 +5011,21 @@ async function setupWorkspace(cfg, action) {
   else cfg.workspaces.push(entry);
   saveConfig(cfg);
 
-  const ports = await resolveWorkspaceHostApps(entry, {
-    cfg,
-    allowAi: false,
-  });
+  let ports = { apps: entry.hostApps || [], confused: false, reasons: [] };
+  if (!sitePort) {
+    log(`setup existing app ${shortId(sandboxId)} kind=${client.kind}`);
+    ports = await resolveWorkspaceHostApps(entry, {
+      cfg,
+      allowAi: false,
+    });
+  } else {
+    log(`setup empty folder ${shortId(sandboxId)} — starting intake on :${sitePort}`);
+    await startIntakeForWorkspace(entry, cfg);
+  }
   const needsReview =
-    Boolean(ports.confused) ||
-    !(ports.apps || []).some((app) => app && app.role !== "ai-server");
+    !sitePort &&
+    (Boolean(ports.confused) ||
+      !(ports.apps || []).some((app) => app && app.role !== "ai-server"));
   if (needsReview) {
     activity(
       sandboxId,
@@ -4636,13 +5036,16 @@ async function setupWorkspace(cfg, action) {
   // Do not auto-repair the repo on attach — interactive Review setup handles suggestions.
   const projectInfo = entry.projectInfo || null;
 
-  await inspectHostJobs(entry);
+  if (!sitePort) await inspectHostJobs(entry);
 
-  const openUrl = client.sameOrigin
-    ? `http://localhost:${entry.port}`
-    : entry.appUrl || appUrl;
+  const intakeUp = sitePort ? await portIsLive(sitePort, 1200) : false;
+  const openUrl = sitePort
+    ? `http://localhost:${sitePort}`
+    : client.sameOrigin
+      ? `http://localhost:${entry.port}`
+      : entry.appUrl || appUrl;
   const aiServerUp = await isChatServerOnPort(entry.port);
-  if (aiServerUp) {
+  if (aiServerUp || intakeUp) {
     clearProcessProblem(sandboxId, "ai_server_launch", "ai");
     clearProcessProblem(sandboxId, "apps_not_started");
   }
@@ -4650,17 +5053,21 @@ async function setupWorkspace(cfg, action) {
   const processIssues = issuesForSandbox(sandboxId).map(
     ({ role: _role, ...issue }) => issue
   );
-  const waitingForStart = !aiServerUp;
+  const waitingForStart = sitePort ? !intakeUp : !aiServerUp;
   const warning = waitingForStart
     ? needsReview
       ? "Folder attached. Review the suggested apps and ports in Maintainer Pro, then Start Apps."
-      : "Folder is attached in Maintainer Pro. Review apps if needed, then use Start Apps."
+      : sitePort
+        ? "Folder attached. The intake form should be on the share link."
+        : "Folder is attached in Maintainer Pro. Review apps if needed, then use Start Apps."
     : processIssues[0]?.message || null;
 
   for (const note of client.notes) log(`setup note ${note}`);
   log(
-    waitingForStart
-      ? `setup done — waiting for Start (${openUrl}) kind=${client.kind}`
+    sitePort
+      ? `setup done — intake on ${openUrl} kind=${client.kind}`
+      : waitingForStart
+        ? `setup done — waiting for Start (${openUrl}) kind=${client.kind}`
       : `setup done — chat already up (${openUrl}) kind=${client.kind}`
   );
 
@@ -4681,7 +5088,7 @@ async function setupWorkspace(cfg, action) {
       clientFiles: client.filesWritten,
       clientNotes: client.notes,
       aiServerUp,
-      startedHosts: [],
+      startedHosts: intakeUp ? ["ui"] : [],
       openUrl,
       processIssues,
       warning,
@@ -4788,7 +5195,9 @@ async function runActions(cfg, actions) {
     action.code = canonicalActionCode(action.code);
     const startedAt = Date.now();
     const label = actionLabel(action);
-    log(`${label} start`);
+    log(`${label} start`, {
+      payload: sanitizeLogValue(action.payload || {}),
+    });
     let ok = true;
     /** @type {Record<string, unknown>} */
     let result = {};
@@ -4865,6 +5274,7 @@ async function runActions(cfg, actions) {
           hostApps: hostApps?.apps || [],
           projectInfo: ws?.projectInfo || null,
         };
+        log(`${label} recheck cli=${folderProbe.cliProvider || "none"} missing=${folderProbe.missingCli === true}`);
       } else if (action.code === "redetect_ports" || action.code === "propose_setup") {
         const sandboxId = action.sandboxId || action.payload?.sandboxId;
         const ws = (cfg.workspaces || []).find((w) => w.sandboxId === sandboxId);
@@ -5138,7 +5548,8 @@ async function runActions(cfg, actions) {
     log(
       `${label} ${ok ? "ok" : "failed"} ${elapsed}ms${
         summary ? ` ${summary}` : ""
-      }`
+      }`,
+      { result: sanitizeLogValue(result) }
     );
 
     try {
@@ -5521,6 +5932,12 @@ async function main() {
   );
   await warnIfMissingCli();
   await restoreHostsAfterReconnect(cfg);
+  const websiteFeedbackTimer = setInterval(() => {
+    void flushAllIntakeWebsiteFeedback();
+  }, WEBSITE_FEEDBACK_CHECK_MS);
+  if (typeof websiteFeedbackTimer.unref === "function") {
+    websiteFeedbackTimer.unref();
+  }
 
   /** @type {unknown[]} */
   const claimedActions = [];
@@ -5536,15 +5953,26 @@ async function main() {
       }
       await sendPresenceOverWs();
     } catch (err) {
-      warn(err instanceof Error ? err.message : String(err));
+      warn(`action runner failed: ${err instanceof Error ? err.message : String(err)}`);
     } finally {
       workBusy = false;
-      if (claimedActions.length) void runWork();
+      if (claimedActions.length) {
+        log(`action runner still has ${claimedActions.length} queued`);
+        void runWork();
+      }
     }
   };
 
   const queueActions = (actions) => {
     if (!Array.isArray(actions) || actions.length === 0) return;
+    log(
+      `queue ${actions.length} action(s): ${actions.map((row) => row.code).join(", ")}`,
+      {
+        ids: actions.map((row) => shortId(row.id)),
+        busy: workBusy,
+        waiting: claimedActions.length,
+      }
+    );
     claimedActions.push(...actions);
     void runWork();
   };
@@ -5750,10 +6178,14 @@ async function main() {
     if (!msg || typeof msg !== "object") return;
     if (msg.type === "pong" || msg.type === "hello") return;
     if (msg.type === "actions") {
+      log(`ws inbound actions (${Array.isArray(msg.actions) ? msg.actions.length : 0})`);
       queueActions(msg.actions);
       return;
     }
     if (msg.type === "heartbeat.ok") {
+      const remotes = Array.isArray(msg.workspaces) ? msg.workspaces.length : 0;
+      const incoming = Array.isArray(msg.actions) ? msg.actions.length : 0;
+      dbg(`ws inbound heartbeat.ok workspaces=${remotes} actions=${incoming}`);
       syncAssignedWorkspaces(cfg, msg.workspaces);
       queueActions(msg.actions);
       return;
@@ -5779,12 +6211,17 @@ async function main() {
       return;
     }
     if (msg.type === "chat.run") {
+      log(
+        `ws inbound chat.run sandbox=${shortId(msg.sandboxId)} conv=${shortId(msg.conversationId)}`
+      );
       void handleChatRun(msg);
       return;
     }
     if (msg.type === "error") {
       warn(`ws: ${msg.error || "error"}`);
+      return;
     }
+    dbg(`ws inbound ${msg.type}`);
   };
 
   const socketState = () => {
@@ -5942,6 +6379,7 @@ async function main() {
     clearHeartbeatTimer();
     clearPingTimer();
     clearReconnectTimer();
+    clearInterval(websiteFeedbackTimer);
     if (watchdogTimer) {
       clearInterval(watchdogTimer);
       watchdogTimer = null;
@@ -5949,7 +6387,11 @@ async function main() {
     dropSocket(socket);
     socket = null;
     log("shutting down (other terminals stay open)");
-    void stopAllEmbeddedChat().finally(() => process.exit(0));
+    void flushAllIntakeWebsiteFeedback({ force: true })
+      .catch(() => {})
+      .finally(() =>
+        stopAllEmbeddedChat().finally(() => process.exit(0))
+      );
   };
   process.on("SIGINT", shutdown);
   process.on("SIGTERM", shutdown);