@gleapai/kai-bridge 0.10.2 → 0.12.0

package/src/tui.mjs

@@ -0,0 +1,76 @@
+// Terminal drawing for the wizard and status screens: ANSI colours that
+// switch off on pipes / NO_COLOR, and box-drawn panels laid out side by
+// side when the terminal is wide enough. No dependency on purpose.
+
+const ANSI_RE = /\x1b\[[0-9;]*m/g;
+
+export function colorsEnabled({ stream = process.stdout, env = process.env } = {}) {
+  if (env.NO_COLOR) return false;
+  if (env.FORCE_COLOR) return true;
+  return !!stream.isTTY && env.TERM !== "dumb";
+}
+
+/** `palette().green("ok")` — every style is an identity function when colours are off. */
+export function palette(on = colorsEnabled()) {
+  const wrap = (open, close) => (s) => (on ? `\x1b[${open}m${s}\x1b[${close}m` : String(s));
+  return {
+    on,
+    bold: wrap(1, 22),
+    dim: wrap(2, 22),
+    red: wrap(31, 39),
+    green: wrap(32, 39),
+    yellow: wrap(33, 39),
+    blue: wrap(34, 39),
+    magenta: wrap(35, 39),
+    cyan: wrap(36, 39),
+  };
+}
+
+export const strip = (s) => String(s).replace(ANSI_RE, "");
+/** Printed width of a string — styling stripped. Box glyphs count as one cell. */
+export const width = (s) => [...strip(s)].length;
+export const padRight = (s, n) => s + " ".repeat(Math.max(0, n - width(s)));
+
+/**
+ * Rounded banner: title left, `right` flush right.
+ *   ╭──────────────────────╮
+ *   │  TITLE  v1     ● ok  │
+ *   ╰──────────────────────╯
+ */
+export function banner({ left, right = "", cols = 64, paint = palette() }) {
+  const inner = Math.max(cols - 2, width(left) + width(right) + 6);
+  const gap = inner - 2 - width(left) - width(right) - 2;
+  const line = `│  ${left}${" ".repeat(Math.max(1, gap))}${right}  │`;
+  return [paint.magenta(`╭${"─".repeat(inner)}╮`), paint.magenta("│") + line.slice(1, -1) + paint.magenta("│"), paint.magenta(`╰${"─".repeat(inner)}╯`)];
+}
+
+/**
+ * One box with a title in its top edge. `inner` widens it beyond its content.
+ *   ┌ title ───────┐
+ *   │ line         │
+ *   └──────────────┘
+ */
+export function panel(title, lines, { inner = 0, paint = palette() } = {}) {
+  const w = Math.max(inner, width(title) + 3, ...lines.map((l) => width(l) + 2));
+  const top = paint.dim(`┌ ${title} ${"─".repeat(Math.max(0, w - width(title) - 2))}┐`);
+  const body = lines.map((l) => `${paint.dim("│")} ${padRight(l, w - 2)} ${paint.dim("│")}`);
+  return [top, ...body, paint.dim(`└${"─".repeat(w)}┘`)];
+}
+
+/** Blocks (arrays of lines) next to each other when they fit in `cols`, else stacked. */
+export function layout(blocks, { cols = 80, gap = 1 } = {}) {
+  const widths = blocks.map((b) => Math.max(...b.map(width)));
+  const total = widths.reduce((a, b) => a + b, 0) + gap * (blocks.length - 1);
+  if (total > cols) return blocks.flatMap((b, i) => (i < blocks.length - 1 ? [...b, ""] : b));
+  const rows = Math.max(...blocks.map((b) => b.length));
+  const lines = [];
+  for (let r = 0; r < rows; r += 1) {
+    lines.push(blocks.map((b, i) => padRight(b[r] ?? "", widths[i])).join(" ".repeat(gap)).replace(/\s+$/, ""));
+  }
+  return lines;
+}
+
+/** The terminal width to draw for — capped so wide monitors keep a readable block. */
+export function terminalColumns({ stream = process.stdout, max = 72, min = 40 } = {}) {
+  return Math.max(min, Math.min(max, stream.columns || 80));
+}

package/src/workspace.mjs

@@ -12,19 +12,64 @@
 // another a worktree). Git ops ported from the retired desktop runtime's
 // git-checkout-ops.mjs in spirit: plain `git` CLI, no libraries.
 
-import { execFileSync } from "node:child_process";
+import { execFile, execFileSync } from "node:child_process";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
+import { promisify } from "node:util";
 
 import { seedNodeModules } from "./deps.mjs";
 
+const execFileAsync = promisify(execFile);
+
 function git(cwd, args, opts = {}) {
   return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], ...opts }).trim();
 }
 
+/**
+ * `git` that leaves the daemon's event loop alone. Preparing a fresh
+ * worktree takes minutes on a big repo (fetch, checkout, the node_modules
+ * clone); run with execFileSync it froze the whole daemon for that long —
+ * no heartbeat (the device could read "away" after 90 s), no realtime pongs, and
+ * the next turn's start and the user's Stop sat in the queue until it was
+ * done (bridge.log 2026-09-11 and 09-18: a start logged the millisecond a
+ * 60-second node_modules clone for another turn finished). stdin is closed
+ * right away, like execFileSync's "ignore": nothing may wait on a prompt.
+ */
+async function gitAsync(cwd, args, opts = {}) {
+  const pending = execFileAsync("git", args, { cwd, encoding: "utf8", maxBuffer: 64 * 1024 * 1024, ...opts });
+  pending.child.stdin?.end();
+  const { stdout } = await pending;
+  return String(stdout).trim();
+}
+
 /** Network ops only: `gitEnv` is the git-auth.mjs fallback, applied to that one command. */
 const withGitEnv = (gitEnv, opts = {}) => (gitEnv ? { ...opts, env: { ...process.env, ...gitEnv } } : opts);
 
+/**
+ * Nobody can answer a prompt from a background daemon: a credential or
+ * passphrase prompt fails fast instead of hanging the fetch (git-auth.mjs
+ * then offers the Server's credentials) — the same hardening the clone path
+ * has. A user's own GIT_SSH_COMMAND wins.
+ */
+const nonInteractiveGitEnv = (gitEnv) => ({
+  ...process.env,
+  GIT_TERMINAL_PROMPT: "0",
+  GIT_ASKPASS: "echo",
+  SSH_ASKPASS: "echo",
+  GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND || "ssh -o BatchMode=yes",
+  ...(gitEnv || {}),
+});
+
+/**
+ * The prep fetch had no limit: a black-holed network (captive portal,
+ * dropped VPN) left the session "running" with nothing running. A single
+ * branch of even a large repo arrives well within this.
+ */
+export const FETCH_TIMEOUT_MS = 120_000;
+
+/** The child was killed because it ran past its `timeout` (async and sync forms). */
+const isTimeout = (err) => err?.code === "ETIMEDOUT" || (err?.killed === true && err?.signal === "SIGTERM");
+
 /**
  * A workspace could not be prepared for a reason that has nothing to do
  * with the task — the Server surfaces `code` as a one-click retry instead
@@ -64,38 +109,43 @@ export function isRefLockContention(message) {
   );
 }
 
-const sleepSync = (ms) => {
-  if (ms > 0) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
-};
+const pause = (ms) => new Promise((resolve) => setTimeout(resolve, ms));
 
 /**
  * `git fetch origin <base>` in `primaryPath`, tolerant of ref-lock
- * contention. Returns `{ attempts, stale }` — `stale: true` means every
+ * contention. Resolves `{ attempts, stale }` — `stale: true` means every
  * attempt lost the race and the existing `origin/<base>` (which the
- * competitor just updated) is used instead. Any other fetch failure, or
- * contention with no usable `origin/<base>`, throws a WorkspaceError
- * whose `code` the Server turns into a retry offer.
+ * competitor just updated) is used instead. Any other fetch failure, a
+ * fetch that runs past `timeoutMs`, or contention with no usable
+ * `origin/<base>` rejects with a WorkspaceError whose `code` the Server
+ * turns into a retry offer.
  */
-export function fetchBase(primaryPath, base, { exec = git, attempts = 4, backoffMs = 400, sleep = sleepSync, repo = primaryPath, gitEnv = null } = {}) {
+export async function fetchBase(primaryPath, base, { exec = gitAsync, attempts = 4, backoffMs = 400, sleep = pause, repo = primaryPath, gitEnv = null, timeoutMs = FETCH_TIMEOUT_MS } = {}) {
   let lastError = null;
   for (let attempt = 1; attempt <= attempts; attempt += 1) {
     try {
-      exec(primaryPath, ["fetch", "origin", base, "--quiet"], withGitEnv(gitEnv));
+      await exec(primaryPath, ["fetch", "origin", base, "--quiet"], { timeout: timeoutMs, env: nonInteractiveGitEnv(gitEnv) });
       return { attempts: attempt, stale: false };
     } catch (err) {
+      if (isTimeout(err)) {
+        throw new WorkspaceError(
+          `git fetch origin ${base} in ${repo} did not finish within ${Math.round(timeoutMs / 1000)} s — check this machine's network and Git access, then retry the task.`,
+          { code: "workspace_fetch_failed", repo, cause: err },
+        );
+      }
       const text = `${err?.stderr || ""}\n${err?.message || ""}`;
       if (!isRefLockContention(text)) {
         throw new WorkspaceError(err?.message || String(err), { code: "workspace_fetch_failed", repo, cause: err });
       }
       lastError = err;
-      if (attempt < attempts) sleep(backoffMs * attempt);
+      if (attempt < attempts) await sleep(backoffMs * attempt);
     }
   }
   // Every attempt lost: whoever kept winning has already moved
   // origin/<base> forward, so it is at least as fresh as our fetch
   // would have made it.
   try {
-    exec(primaryPath, ["rev-parse", "--verify", "--quiet", `origin/${base}^{commit}`]);
+    await exec(primaryPath, ["rev-parse", "--verify", "--quiet", `origin/${base}^{commit}`]);
     return { attempts, stale: true };
   } catch {
     throw new WorkspaceError(
@@ -147,13 +197,16 @@ export function copyPrimaryEnvFiles(primaryPath, cwd) {
 }
 
 /**
- * Materialise one repo binding. Returns `{ cwd, mode, branch, base }`.
+ * Materialise one repo binding. Resolves `{ cwd, mode, branch, base }`.
  * `repo` = `{ name, primaryPath, defaultBranch }`, `binding` = `{ mode, base?, carryUncommitted? }`.
+ * `onPrepare({ repo, base })` is awaited once a fresh worktree has to be
+ * built — the slow path (fetch, checkout, node_modules) — before any of it
+ * starts; resumed worktrees and local checkouts never call it.
  */
-export function materializeBinding({ kaiHome, repo, binding, sessionId, title, branchPrefix = "kai", fetch = fetchBase, gitEnv = null }) {
+export async function materializeBinding({ kaiHome, repo, binding, sessionId, title, branchPrefix = "kai", fetch = fetchBase, gitEnv = null, onPrepare = null }) {
   const mode = binding?.mode === "local" ? "local" : "worktree";
   if (mode === "local") {
-    const branch = git(repo.primaryPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
+    const branch = await gitAsync(repo.primaryPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
     return { cwd: repo.primaryPath, mode, branch, base: branch };
   }
   const base = binding?.base || repo.defaultBranch || "main";
@@ -164,26 +217,27 @@ export function materializeBinding({ kaiHome, repo, binding, sessionId, title, b
     // Resume: the worktree from the previous turn is the session state.
     return { cwd: dir, mode, branch, base, resumed: true };
   }
+  await onPrepare?.({ repo: repo.name, base });
   mkdirSync(dirname(dir), { recursive: true });
-  const fetched = fetch(repo.primaryPath, base, { repo: repo.name, gitEnv });
-  git(repo.primaryPath, ["worktree", "add", "-b", branch, dir, `origin/${base}`]);
+  const fetched = await fetch(repo.primaryPath, base, { repo: repo.name, gitEnv });
+  await gitAsync(repo.primaryPath, ["worktree", "add", "-b", branch, dir, `origin/${base}`]);
   // A fresh worktree has no node_modules; clone the primary checkout's
   // when the lockfiles match so the agent's tests and the preview boot
   // don't each start with a 2-minute install (see deps.mjs).
-  const deps = seedNodeModules({ primaryPath: repo.primaryPath, cwd: dir });
+  const deps = await seedNodeModules({ primaryPath: repo.primaryPath, cwd: dir });
   if (binding?.carryUncommitted) {
     // Tracked changes as a patch; untracked (non-ignored) files copied.
-    const patch = git(repo.primaryPath, ["diff", "HEAD"], { maxBuffer: 64 * 1024 * 1024 });
+    const patch = await gitAsync(repo.primaryPath, ["diff", "HEAD"]);
     if (patch) {
       const patchPath = join(dir, ".kai-carry.patch");
       writeFileSync(patchPath, patch + "\n");
       try {
-        git(dir, ["apply", "--3way", patchPath]);
+        await gitAsync(dir, ["apply", "--3way", patchPath]);
       } finally {
         rmSync(patchPath, { force: true });
       }
     }
-    const untracked = git(repo.primaryPath, ["ls-files", "--others", "--exclude-standard"]).split("\n").filter(Boolean);
+    const untracked = (await gitAsync(repo.primaryPath, ["ls-files", "--others", "--exclude-standard"])).split("\n").filter(Boolean);
     for (const rel of untracked) {
       try {
         mkdirSync(dirname(join(dir, rel)), { recursive: true });