@gleapai/kai-bridge 0.9.1 → 0.10.1

package/src/executor.mjs

@@ -73,8 +73,8 @@ export function buildRunnerArgs(turn, workDir, profile) {
  */
 export function buildRunnerEnv(turn, profile, kaiHome = KAI_HOME, extraEnv = null) {
   const env = { ...process.env, KAI_RUNNER_DEBUG: process.env.KAI_RUNNER_DEBUG || "0", KAI_PERSONA_DIR: join(dirname(RUNNER), "personas") };
-  // Host-only values for the runner's MCP bridges (the verify tool's
-  // request policy: KAI_VERIFY_*). Never part of the prompt.
+  // Host-only extras for the runner process (tests inject fixture paths
+  // and scenarios here). Never part of the prompt.
   for (const [k, v] of Object.entries(extraEnv || {})) if (v != null && v !== "") env[k] = String(v);
   // Never leak the Gleap device token into the harness.
   delete env.KAI_DEVICE_TOKEN;

package/src/gateway.mjs

@@ -0,0 +1,217 @@
+// The preview gateway — a small reverse proxy the bridge puts IN FRONT of
+// every web service it starts. The service's public port (the one the
+// dashboard and the agent's browser tools address) is the gateway's; the
+// app itself runs on a second, internal port. That indirection is what
+// makes the public port stable across restarts of the app (a fix that
+// restarts the dev server keeps its URL), lets the gateway answer with a
+// "starting…" page while the app boots or compiles for the first time
+// (`hold()` — the warm-up), and smooths over a cold dev server's transient
+// connection resets with a few retries. Everything else is a dumb pipe,
+// WebSocket upgrades included.
+
+import { Agent as HttpAgent, createServer as createHttpServer, request as httpRequest } from "node:http";
+import { Agent as HttpsAgent, request as httpsRequest } from "node:https";
+import { connect as netConnect } from "node:net";
+import { connect as tlsConnect } from "node:tls";
+
+/** The warm-up browser sends this header so the hold page does not apply to it. */
+export const WARMUP_HEADER = "x-kai-warmup";
+/** Transient upstream resets are retried this many times (cold dev server under a burst). */
+export const PROXY_RETRIES = 4;
+export const PROXY_RETRY_BACKOFF_MS = [50, 150, 350, 700];
+const HOP_BY_HOP = new Set(["connection", "keep-alive", "proxy-authenticate", "proxy-authorization", "te", "trailer", "transfer-encoding", "upgrade"]);
+
+/** A navigation to an HTML document (not an XHR, a module, an image)? */
+export function wantsHtmlDocument(headers) {
+  const dest = String(headers["sec-fetch-dest"] || "").toLowerCase();
+  if (dest) return dest === "document" || dest === "iframe" || dest === "frame";
+  return /text\/html/i.test(String(headers.accept || ""));
+}
+
+// ── the proxy ──────────────────────────────────────────────────────
+
+const sleep = (ms) => new Promise((r) => setTimeout(r, ms));
+
+/**
+ * One gateway per fronted service. `listen()` binds the public port and
+ * proxies to `127.0.0.1:<upstreamPort>` (https upstream accepted with a
+ * self-signed cert). `hold(note)` parks browser tabs on a reloading page
+ * until `release()`.
+ */
+export class Gateway {
+  constructor({ listenPort, upstreamPort, upstreamProtocol = "http", host = "0.0.0.0", name = null, log = () => {} }) {
+    this.listenPort = listenPort;
+    this.upstreamPort = upstreamPort;
+    this.upstreamProtocol = upstreamProtocol === "https" ? "https" : "http";
+    this.host = host;
+    this.name = name;
+    this.log = log;
+    // While the bridge warms a cold app (its first compile), browser tabs get a
+    // friendly auto-reloading page instead of stampeding the server. `null` = open.
+    this.holding = null; // { note }
+    this.server = null;
+    this.sockets = new Set();
+    // Own keep-alive pool to the app (a dev server answers thousands of
+    // module requests; reusing connections matters) — destroyed with the
+    // gateway so no idle socket outlives it on the app's side.
+    this.agent = this.upstreamProtocol === "https" ? new HttpsAgent({ keepAlive: true, rejectUnauthorized: false }) : new HttpAgent({ keepAlive: true });
+  }
+
+  async listen() {
+    this.server = createHttpServer((req, res) => void this.onRequest(req, res));
+    this.server.on("upgrade", (req, socket, head) => this.onUpgrade(req, socket, head));
+    this.server.on("connection", (s) => {
+      this.sockets.add(s);
+      s.once("close", () => this.sockets.delete(s));
+    });
+    this.server.keepAliveTimeout = 65_000;
+    await new Promise((resolve, reject) => {
+      this.server.once("error", reject);
+      this.server.listen(this.listenPort, this.host, () => {
+        this.server.off("error", reject);
+        resolve();
+      });
+    });
+    this.log("info", "gateway.listen", { name: this.name, port: this.listenPort, upstream: this.upstreamPort });
+    return this;
+  }
+
+  async close() {
+    const srv = this.server;
+    this.server = null;
+    if (!srv) return;
+    for (const s of this.sockets) s.destroy();
+    this.sockets.clear();
+    this.agent.destroy();
+    await new Promise((r) => srv.close(() => r()));
+    this.log("info", "gateway.close", { name: this.name, port: this.listenPort });
+  }
+
+  /** Hold document requests on a "warming up" page (the warm-up browser itself passes). */
+  hold(note) {
+    this.holding = { note: String(note || "The preview is starting.") };
+  }
+
+  release() {
+    this.holding = null;
+  }
+
+  async onRequest(req, res) {
+    try {
+      if (this.holding && req.method === "GET" && wantsHtmlDocument(req.headers) && !req.headers[WARMUP_HEADER]) {
+        res.writeHead(503, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store", "retry-after": "3" });
+        return res.end(holdPage(this.holding.note));
+      }
+      return this.proxy(req, res);
+    } catch (err) {
+      this.log("warn", "gateway.request.failed", { name: this.name, error: err?.message });
+      if (!res.headersSent) res.writeHead(502, { "content-type": "text/plain" });
+      res.end("gateway error");
+    }
+  }
+
+  proxy(req, res) {
+    // Hop-by-hop headers stay out; the original Host stays in (dev servers
+    // compare it with Origin — Next server actions, Vite allowedHosts).
+    const headers = {};
+    for (const [k, v] of Object.entries(req.headers)) {
+      if (HOP_BY_HOP.has(k)) continue;
+      headers[k] = v;
+    }
+    const request = this.upstreamProtocol === "https" ? httpsRequest : httpRequest;
+    // A cold dev server (a big Vite app compiling its first requests) resets
+    // or refuses connections under a burst — several browser tabs at once,
+    // say. For a bodyless idempotent request that reset is transient, not
+    // "app down": retry a few times before the 503 so one module 503 does
+    // not break the whole page load. Requests WITH a body are not replayable.
+    const hasBody = req.headers["content-length"] || req.headers["transfer-encoding"];
+    const idempotent = req.method === "GET" || req.method === "HEAD" || req.method === "OPTIONS";
+    const canRetry = idempotent && !hasBody;
+    const attempt = (tries) => {
+      const up = request({ host: "127.0.0.1", port: this.upstreamPort, method: req.method, path: req.url, headers, agent: this.agent, ...(this.upstreamProtocol === "https" ? { rejectUnauthorized: false } : {}) });
+      up.on("response", (upRes) => {
+        const outHeaders = {};
+        for (const [k, v] of Object.entries(upRes.headers)) if (!HOP_BY_HOP.has(k)) outHeaders[k] = v;
+        res.writeHead(upRes.statusCode, outHeaders);
+        upRes.pipe(res);
+      });
+      up.on("error", (err) => {
+        if (res.headersSent) return res.end();
+        const transient = err?.code === "ECONNREFUSED" || err?.code === "ECONNRESET" || err?.code === "ECONNABORTED" || err?.code === "EPIPE";
+        if (transient && canRetry && tries < PROXY_RETRIES) {
+          setTimeout(() => attempt(tries + 1), PROXY_RETRY_BACKOFF_MS[tries] ?? 300);
+          return;
+        }
+        if (transient) {
+          // Still failing after retries: the app is (re)starting. A page that
+          // reloads itself; module/XHR fetches just get the 503 and the app's
+          // own retry (or the user's reload) picks up once the server is warm.
+          res.writeHead(503, { "content-type": "text/html; charset=utf-8", "cache-control": "no-store", "retry-after": "2" });
+          return res.end(`<!doctype html><meta charset="utf-8"><meta http-equiv="refresh" content="2"><title>Starting…</title><body style="font:15px system-ui;padding:32px;color:#444">The preview is starting — this page retries automatically.</body>`);
+        }
+        res.writeHead(502, { "content-type": "text/plain" });
+        res.end(`gateway: ${err?.message || err}`);
+      });
+      if (canRetry) {
+        up.end();
+      } else {
+        req.on("aborted", () => up.destroy());
+        req.pipe(up);
+      }
+    };
+    attempt(0);
+  }
+
+  /** WebSocket & co.: a raw splice to the upstream, headers replayed as received. */
+  onUpgrade(req, socket, head) {
+    const connect = () => (this.upstreamProtocol === "https" ? tlsConnect({ host: "127.0.0.1", port: this.upstreamPort, rejectUnauthorized: false }) : netConnect({ host: "127.0.0.1", port: this.upstreamPort }));
+    const up = connect();
+    this.sockets.add(up);
+    up.once("close", () => this.sockets.delete(up));
+    const fail = () => {
+      try {
+        socket.destroy();
+      } catch {
+        /* gone */
+      }
+    };
+    up.once("error", fail);
+    socket.once("error", () => up.destroy());
+    // Either half closing closes the other: a lingering upstream half would
+    // keep the app's listener from ever closing (and leak a socket per tab).
+    socket.once("close", () => up.destroy());
+    up.once("close", fail);
+    up.once(this.upstreamProtocol === "https" ? "secureConnect" : "connect", () => {
+      const lines = [`${req.method} ${req.url} HTTP/${req.httpVersion}`];
+      for (let i = 0; i < req.rawHeaders.length; i += 2) lines.push(`${req.rawHeaders[i]}: ${req.rawHeaders[i + 1]}`);
+      up.write(lines.join("\r\n") + "\r\n\r\n");
+      if (head?.length) up.write(head);
+      socket.pipe(up).pipe(socket);
+    });
+  }
+}
+
+const escapeHtml = (t) => String(t).replace(/[&<>"]/g, (c) => ({ "&": "&amp;", "<": "&lt;", ">": "&gt;", '"': "&quot;" })[c]);
+
+/** The page a tab sees while the app compiles for the first time: reloads itself every 3 s. */
+export function holdPage(note) {
+  return `<!doctype html><meta charset="utf-8"><meta http-equiv="refresh" content="3"><title>Starting…</title><body style="font:15px/1.5 system-ui;padding:40px;max-width:520px;color:#333"><p style="font-size:17px;font-weight:600;margin:0 0 6px">Kai is starting the preview</p><p style="margin:0;color:#666">${escapeHtml(note)}</p><p style="margin:14px 0 0;color:#999;font-size:13px">This page reloads on its own — no need to refresh.</p></body>`;
+}
+
+/** Wait until the gateway's upstream answers (used by tests and the pre-warm). */
+export async function waitForUpstream(port, { timeoutMs = 10_000 } = {}) {
+  const deadline = Date.now() + timeoutMs;
+  while (Date.now() < deadline) {
+    const ok = await new Promise((resolve) => {
+      const s = netConnect({ host: "127.0.0.1", port });
+      s.once("connect", () => {
+        s.destroy();
+        resolve(true);
+      });
+      s.once("error", () => resolve(false));
+    });
+    if (ok) return true;
+    await sleep(100);
+  }
+  return false;
+}

package/src/harnesses.mjs

@@ -49,7 +49,7 @@ export const HARNESS_INFO = {
 const CURSOR_ROOT = (kaiHome) => join(kaiHome, "harnesses", "cursor");
 const CURSOR_CURRENT = (kaiHome) => join(CURSOR_ROOT(kaiHome), "current");
 /** Version + channel published by Cursor's install script (https://cursor.com/install). */
-export const CURSOR_AGENT_VERSION = process.env.KAI_CURSOR_AGENT_VERSION || "2026.08.11-e8db854";
+export const CURSOR_AGENT_VERSION = process.env.KAI_CURSOR_AGENT_VERSION || "2026.09.18-9a7762b";
 
 function cursorPlatform() {
   const os = platform() === "darwin" ? "darwin" : platform() === "win32" ? "windows" : "linux";
@@ -254,12 +254,25 @@ export function probeHarnessAuth(harness, configDir, kaiHome) {
       return { state: "signed_in", account };
     }
   } catch (err) {
-    // `claude auth status` exits 1 when signed out; codex without auth.json.
-    return { state: "signed_out" };
+    return classifyAuthProbeError(err, harness);
   }
   return { state: "unknown" };
 }
 
+/**
+ * A non-zero EXIT is an answer (`claude auth status` exits 1 when signed
+ * out; `cursor status` likewise), and codex without a readable auth.json
+ * is signed out. A probe that never ran to completion — the CLI timed out
+ * (`ETIMEDOUT`, no exit status) or could not be spawned (`ENOENT`) — is
+ * NOT: report `unknown` so callers keep the last known state instead of
+ * showing "signed out" until the next good probe.
+ */
+export function classifyAuthProbeError(err, harness) {
+  if (harness === "codex") return { state: "signed_out" };
+  if (typeof err?.status === "number") return { state: "signed_out" };
+  return { state: "unknown", error: err?.code || err?.message || String(err) };
+}
+
 /** Spawn a detached process that keeps running after the CLI exits (installer helper). */
 export function spawnDetached(cmd, args, opts = {}) {
   const child = spawn(cmd, args, { stdio: "ignore", detached: true, ...opts });

package/src/playwright-patch.mjs

@@ -0,0 +1,84 @@
+// Raise Playwright's client-side default action timeout in the bundled
+// playwright-core that the browser MCP (and the daemon's own probe) run on.
+//
+// @playwright/mcp captures an aria snapshot after EVERY tool call
+// (`page.ariaSnapshot`, `page.title`) without a timeout option, so those
+// calls fall back to `DEFAULT_PLAYWRIGHT_TIMEOUT` — 30 s. A heavy dev build
+// (the Gleap dashboard: 3,400 requests, main thread busy for a minute on a
+// loaded machine) cannot answer in 30 s, and every navigate / snapshot
+// "fails" with `Timeout 30000ms exceeded` while the page keeps loading
+// (seen 2026-09-15/16: the agent's browser never got past its first page).
+// `--timeout-action` / `--timeout-navigation` do not reach these calls and
+// nothing in the MCP config does, so the constant is raised in place —
+// idempotent, marked, re-applied after every install (a self-update
+// reinstalls the package) and on daemon start, best-effort like the ACP
+// patch (src/acp-patch.mjs). Explicit timeouts (locator actions with
+// `--timeout-action`, navigations with `--timeout-navigation`) are untouched.
+import { readFileSync, writeFileSync } from "node:fs";
+import { createRequire } from "node:module";
+import { dirname, join } from "node:path";
+
+export const PLAYWRIGHT_DEFAULT_TIMEOUT_MS = 120_000;
+const MARKER = "/* kai-bridge: default timeout raised */";
+const ORIGINAL = /DEFAULT_PLAYWRIGHT_TIMEOUT = 3e4;/g;
+
+/**
+ * Every `playwright-core/lib/coreBundle.js` this package can reach: the
+ * one the MCP CLI loads and the one `playwright` (the probe) loads —
+ * usually the same hoisted file, deduplicated.
+ */
+export function bundledPlaywrightCoreBundles() {
+  const files = new Set();
+  const require = createRequire(import.meta.url);
+  const roots = [];
+  try {
+    roots.push(dirname(require.resolve("@playwright/mcp/package.json")));
+  } catch {
+    /* not installed */
+  }
+  try {
+    roots.push(dirname(require.resolve("playwright/package.json")));
+  } catch {
+    /* not installed */
+  }
+  for (const root of roots) {
+    try {
+      const local = createRequire(join(root, "package.json"));
+      files.add(join(dirname(local.resolve("playwright-core/package.json")), "lib", "coreBundle.js"));
+    } catch {
+      /* no playwright-core from there */
+    }
+  }
+  return [...files];
+}
+
+/** Pure: `{ source, status }` — status `patched` | `already` | `unrecognized`. */
+export function patchPlaywrightTimeoutSource(source, timeoutMs = PLAYWRIGHT_DEFAULT_TIMEOUT_MS) {
+  if (source.includes(MARKER)) return { source, status: "already" };
+  const matches = source.match(ORIGINAL) || [];
+  if (matches.length !== 1) return { source, status: "unrecognized" };
+  return { source: source.replace(ORIGINAL, `DEFAULT_PLAYWRIGHT_TIMEOUT = ${timeoutMs}; ${MARKER}`), status: "patched" };
+}
+
+/**
+ * Apply the patch where needed. Returns `[{ file, status }]` — status
+ * `patched` | `already` | `unrecognized` | `error`; empty when no bundle
+ * is installed.
+ */
+export function ensurePlaywrightTimeoutPatched({ log, files = bundledPlaywrightCoreBundles() } = {}) {
+  const results = [];
+  for (const file of files) {
+    try {
+      const { source, status } = patchPlaywrightTimeoutSource(readFileSync(file, "utf8"));
+      if (status === "patched") {
+        writeFileSync(file, source);
+        log?.("info", "playwright.patch.applied", { file, timeoutMs: PLAYWRIGHT_DEFAULT_TIMEOUT_MS });
+      } else if (status !== "already") log?.("warn", "playwright.patch.skipped", { file, status });
+      results.push({ file, status });
+    } catch (err) {
+      log?.("warn", "playwright.patch.failed", { file, error: err?.message ?? String(err) });
+      results.push({ file, status: "error" });
+    }
+  }
+  return results;
+}

package/src/preview-errors.mjs

@@ -252,32 +252,3 @@ function safeRead(read, path) {
   }
 }
 
-const PLACEHOLDER_RE = /^(?:changeme|change-me|change_me|replace-?me|todo|tbd|xxx+|your[-_ ].*|<[^>]*>|\$\{[^}]*\}|example.*|.*example\.(?:com|org|net).*|placeholder|secret|password|true|false|null|undefined|none|localhost.*|0+|\d+)$/i;
-
-/** Is this env value worth redacting (≥ 12 chars, not a placeholder, not a URL/number/bool)? */
-export function isRedactableEnvValue(value) {
-  if (typeof value !== "string") return false;
-  const text = value.trim();
-  if (text.length < 12) return false;
-  if (PLACEHOLDER_RE.test(text)) return false;
-  // URLs / connection strings: only ones carrying `user:password@` are secrets.
-  if (/^[a-z][a-z0-9+.-]*:\/\//i.test(text)) return /\/\/[^/@\s]+:[^/@\s]+@/.test(text);
-  if (/^[\d.,\s-]+$/.test(text)) return false;
-  if (/^\d{4}-\d{2}-\d{2}/.test(text)) return false;
-  return true;
-}
-
-/**
- * Every value from the given dotenv texts that looks like a secret (the
- * redaction set grows by these so a leaked `.env` value never reaches the
- * Server in a tool row). Longest first, like `redactionSet`.
- */
-export function envRedactionValues(texts) {
-  const values = new Set();
-  for (const text of texts || []) {
-    for (const value of Object.values(parseDotenv(text))) {
-      if (isRedactableEnvValue(value)) values.add(value.trim());
-    }
-  }
-  return new Set([...values].sort((a, b) => b.length - a.length));
-}