@gleapai/kai-bridge 0.2.4 → 0.2.6

package/bin/kai-bridge.mjs

@@ -27,6 +27,7 @@ import { HARNESSES, createManagedProfile, describeProfiles, findBinary, loginCom
 import { defaultRoots, groupByRepo, scanRoots, toDeviceRepoReport } from "../src/repos.mjs";
 import { install, isInstalled, uninstall, isEphemeralBinPath } from "../src/service.mjs";
 import { HARNESS_INFO, describeHarnesses, installHarness } from "../src/harnesses.mjs";
+import { fetchLatestVersion, installVersion, installedVersion, isNewer } from "../src/selfupdate.mjs";
 
 const BIN = fileURLToPath(import.meta.url);
 const argv = process.argv.slice(2);
@@ -244,6 +245,28 @@ try {
     case "doctor":
       await doctor();
       break;
+    case "update": {
+      // Manual update: ignores autoUpdate and a previous failed attempt.
+      const current = installedVersion();
+      const latest = await fetchLatestVersion();
+      if (!isNewer(latest, current)) {
+        out(`kai-bridge ${current} is up to date.`);
+        break;
+      }
+      out(`Updating kai-bridge ${current} → ${latest}…`);
+      const res = await installVersion(latest);
+      if (!res.ok) fail(`Update failed: ${res.error}\n\nTry: npm i -g @gleapai/kai-bridge@${latest}`);
+      const cfg = loadConfig();
+      cfg.selfUpdate = { lastAttempt: { version: latest, ok: true, at: new Date().toISOString(), error: null } };
+      saveConfig(cfg);
+      if (isInstalled()) {
+        install({ binPath: BIN, logDir: join(KAI_HOME, "logs") });
+        out(`Installed ${latest} and restarted the background service.`);
+      } else {
+        out(`Installed ${latest}. Restart \`kai-bridge start\` to run it.`);
+      }
+      break;
+    }
     default: {
       // A bare `kai-bridge` in a terminal IS the setup — first run pairs,
       // later runs open with keep / reconnect / log out, so it doubles as
@@ -256,7 +279,7 @@ try {
       out(`kai-bridge — run Gleap Kai Code on this machine
 
   setup                            guided onboarding (pair · service · sign-ins)
-  login | logout | install | uninstall | start | status | doctor
+  login | logout | install | uninstall | start | status | doctor | update
   harness list|install <id>|login <id>
   profile list|add <id> --harness claude|codex|cursor|login <id>|remove <id>
   repo scan|roots [add|remove <dir>]|primary <repoKey> <path>

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gleapai/kai-bridge",
-  "version": "0.2.4",
+  "version": "0.2.6",
   "description": "Run Gleap Kai Code sessions on your own machine with your own Claude Code / Codex login — and preview your real dev servers from the dashboard or the phone.",
   "type": "module",
   "license": "MIT",

package/src/daemon.mjs

@@ -20,10 +20,11 @@ import { KAI_HOME, defaultConfig, loadConfig, saveConfig } from "./config.mjs";
 import { runTurn } from "./executor.mjs";
 import { createManagedProfile, describeProfiles, managedConfigDir, ambientConfigDir, openLoginTerminal, probeUsageLimits } from "./profiles.mjs";
 import { defaultRoots, groupByRepo, preferredCloneRoot, scanRoots, toDeviceRepoReport } from "./repos.mjs";
-import { collectChanges, commitAndPush, copyPrimaryEnvFiles, materializeBinding, sessionSlug, worktreePath, ensureCommitExcludes } from "./workspace.mjs";
+import { collectChanges, commitAndPush, copyPrimaryEnvFiles, currentBranch, materializeBinding, sessionSlug, worktreePath, ensureCommitExcludes } from "./workspace.mjs";
 import { ServiceRunner, detectDevConfig, previewMcpServer, readDevConfig } from "./preview.mjs";
 import { describeHarnesses, installHarness, probeHarnessAuth } from "./harnesses.mjs";
 import { probeHarnessModels } from "./models.mjs";
+import { decideUpdate, fetchLatestVersion, installVersion, installedVersion, isNewer } from "./selfupdate.mjs";
 import { dirname } from "node:path";
 import { fileURLToPath } from "node:url";
 
@@ -38,7 +39,14 @@ const USAGE_REFRESH_MS = 10 * 60_000;
 const MODELS_REFRESH_MS = 6 * 60 * 60_000;
 /** Harnesses that can tell us which models they offer (Cursor has no such surface). */
 const MODEL_PROBE_HARNESSES = ["claude", "codex"];
-const VERSION = "0.1.0";
+// Read from package.json: the hard-coded "0.1.0" this used to be is what
+// every device reported as its bridge version, so nobody could tell who
+// was behind.
+const VERSION = installedVersion();
+const SELF_UPDATE_CHECK_MS = 6 * 60 * 60_000;
+// EX_TEMPFAIL: a failure exit on purpose — launchd (SuccessfulExit:false)
+// and systemd (Restart=on-failure) restart the service on the new code.
+const RESTART_EXIT_CODE = 75;
 
 export function createLogger(kaiHome = KAI_HOME) {
   mkdirSync(join(kaiHome, "logs"), { recursive: true });
@@ -109,6 +117,9 @@ export class BridgeDaemon {
     this.usageByProfile = new Map(); // profileId → plan-usage snapshot (claude only)
     this.modelsByHarness = new Map(); // harnessId → models the signed-in login offers (see refreshHarnessModels)
     this.stopped = false;
+    this.updateAvailable = null; // newer registry version, when one exists
+    this.updateError = null; // why the last self-update did not apply
+    this.updating = false; // npm is replacing our files — refuse new turns
   }
 
   async scanRepos() {
@@ -131,6 +142,9 @@ export class BridgeDaemon {
       repos,
       roots: [...defaultRoots(), ...(this.config.roots || [])],
       repoModes: this.config.repoModes || {},
+      updateAvailable: this.updateAvailable || null,
+      updateError: this.updateError || null,
+      autoUpdate: this.config.autoUpdate !== false,
     });
   }
 
@@ -169,6 +183,10 @@ export class BridgeDaemon {
         await new Promise((r) => setTimeout(r, delay));
       }
     }
+    // Update BEFORE picking up work: a machine that wakes up applies the
+    // new version first, so its next turn runs on current code. Applying
+    // restarts the process (this call never returns in that case).
+    await this.checkForUpdate();
     this.connectRealtime();
     // REF'd on purpose: this timer is what keeps the process alive. With
     // it unref'd, a realtime socket that gave up for good left no handle
@@ -190,7 +208,82 @@ export class BridgeDaemon {
     void this.refreshHarnessModels();
     this.modelsTimer = setInterval(() => void this.refreshHarnessModels(), MODELS_REFRESH_MS);
     this.modelsTimer.unref?.();
-    this.log("info", "started", { device: this.config.device.id });
+    this.updateTimer = setInterval(() => void this.checkForUpdate(), SELF_UPDATE_CHECK_MS);
+    this.updateTimer.unref?.();
+    this.log("info", "started", { device: this.config.device.id, version: VERSION });
+  }
+
+  // ── self-update ────────────────────────────────────────────────────
+  /**
+   * Compare with the registry and, when idle, install the newer version
+   * and restart. A busy daemon retries once the turn ends; a version that
+   * failed to install is not retried (the dashboard shows the hint and
+   * `kai-bridge update` forces it). Never throws.
+   */
+  async checkForUpdate() {
+    if (this.stopped || this.updating) return;
+    // Tests and embedded hosts (the Desktop app ships its own copy).
+    if (process.env.KAI_BRIDGE_NO_SELF_UPDATE === "1") return;
+    let latest;
+    try {
+      latest = await fetchLatestVersion();
+    } catch (err) {
+      this.log("warn", "update.check.failed", { error: err?.message });
+      return;
+    }
+    this.updateAvailable = isNewer(latest, VERSION) ? latest : null;
+    const decision = decideUpdate({
+      current: VERSION,
+      latest,
+      running: this.running.size,
+      autoUpdate: this.config.autoUpdate !== false,
+      lastAttempt: this.config.selfUpdate?.lastAttempt ?? null,
+    });
+    if (decision.action === "skip") {
+      if (decision.reason === "busy") this.updatePending = latest;
+      return;
+    }
+    if (decision.action === "notify") {
+      this.updateError = decision.reason === "disabled" ? null : this.config.selfUpdate?.lastAttempt?.error || "previous install failed";
+      this.log("info", "update.available", { latest, reason: decision.reason });
+      await this.hello().catch(() => undefined);
+      return;
+    }
+    await this.applyUpdate(latest);
+  }
+
+  async applyUpdate(version) {
+    this.updating = true;
+    this.updatePending = null;
+    this.log("info", "update.installing", { from: VERSION, to: version });
+    const res = await installVersion(version);
+    this.config.selfUpdate = { lastAttempt: { version, ok: res.ok, at: new Date().toISOString(), error: res.error || null } };
+    try {
+      saveConfig(this.config, this.kaiHome);
+    } catch {
+      /* best-effort */
+    }
+    if (!res.ok) {
+      this.updating = false;
+      this.updateError = res.error;
+      this.log("error", "update.failed", { version, error: res.error });
+      await this.hello().catch(() => undefined);
+      return;
+    }
+    this.log("info", "update.installed", { version, restarting: true });
+    this.restartForUpdate();
+  }
+
+  /** Hand the machine to the new version: the service restarts us. */
+  restartForUpdate() {
+    this.stop();
+    if (platform() === "win32") {
+      // Task Scheduler only starts at logon — respawn ourselves instead.
+      const child = spawn(process.execPath, [process.argv[1], "start"], { detached: true, stdio: "ignore", windowsHide: true });
+      child.unref();
+      process.exit(0);
+    }
+    process.exit(RESTART_EXIT_CODE);
   }
 
   /** Install/version state per harness, plus the models it reported (when probed). */
@@ -277,6 +370,7 @@ export class BridgeDaemon {
     clearInterval(this.heartbeat);
     clearInterval(this.usageTimer);
     clearInterval(this.modelsTimer);
+    clearInterval(this.updateTimer);
     if (this.realtimeRetry) clearTimeout(this.realtimeRetry);
     for (const ctrl of this.running.values()) ctrl.abort();
     for (const runner of this.services.values()) runner.stopAll();
@@ -481,6 +575,15 @@ export class BridgeDaemon {
     this.log("info", "command", { name, turnId: data?.turnId, commandId: data?.commandId });
     switch (name) {
       case "bridge.turn.start":
+        if (this.updating) {
+          // Our files are being replaced under us — a turn started now
+          // would run half old, half new code. Seconds later the restarted
+          // daemon picks queued turns up again.
+          await this.api
+            .turnResult(data.turnId, { status: "failed", error: "This machine is updating kai-bridge — send the turn again in a minute." })
+            .catch((err) => this.log("warn", "update.turn.refused.failed", { turnId: data.turnId, error: err?.message }));
+          return;
+        }
         return this.startTurn(data);
       case "bridge.turn.cancel":
         this.running.get(data.turnId)?.abort();
@@ -738,6 +841,53 @@ export class BridgeDaemon {
     return bound;
   }
 
+  /**
+   * The agent's repo brief: which checkouts are part of the session (only
+   * those get committed, pushed and turned into PRs), and the recipe for
+   * bringing another repo on this device into the session. Ticket #146130:
+   * the session was scoped to Desktop, the fix belonged in JavaScript-SDK,
+   * and the agent's work there was stranded because nothing told it how a
+   * repo joins a session.
+   */
+  repoBrief(turn, bound) {
+    const slug = sessionSlug(turn.sessionId, turn.title);
+    const lines = ["", "", "Repositories for this task (changes here are committed, pushed and opened as pull requests when the turn ends — you cannot commit or push yourself):"];
+    for (const b of bound) lines.push(`- ${b.key}: ${b.cwd}`);
+    const others = this.repoGroups.filter((g) => !bound.some((b) => b.key === g.key));
+    if (others.length) {
+      lines.push(
+        "",
+        "If the fix belongs in a repository that is NOT listed above, do not edit its primary checkout. Create the session worktree for it with the command below and work there — it is picked up like the repositories above (branch kai/" + slug + ", pushed at turn end, PR opened by Gleap):",
+      );
+      for (const g of others.slice(0, 40)) {
+        const base = g.primary.defaultBranch || "main";
+        lines.push(`- ${g.key}: git -C ${g.primary.path} fetch origin ${base} --quiet && git -C ${g.primary.path} worktree add -b kai/${slug} ${worktreePath(this.kaiHome, g.name, slug)} origin/${base}`);
+      }
+      if (others.length > 40) lines.push(`- (${others.length - 40} more repositories on this device — same recipe, path ~/.kai/worktrees/<repo>/${slug})`);
+    }
+    return lines.join("\n");
+  }
+
+  /**
+   * Session worktrees the agent created for repos outside the turn's
+   * bindings (via the recipe in `repoBrief`). They are bound like the
+   * declared repos so their changes are committed, pushed and reported.
+   */
+  adoptSessionWorktrees(turn, bound) {
+    const slug = sessionSlug(turn.sessionId, turn.title);
+    const adopted = [];
+    for (const g of this.repoGroups) {
+      if (bound.some((b) => b.key === g.key)) continue;
+      const cwd = worktreePath(this.kaiHome, g.name, slug);
+      if (!existsSync(cwd)) continue;
+      const branch = currentBranch(cwd);
+      if (!branch || branch === "HEAD") continue;
+      adopted.push({ key: g.key, cwd, mode: "worktree", branch, base: g.primary.defaultBranch || "main", adopted: true });
+      this.log("info", "worktree.adopted", { turnId: turn.turnId, repo: g.key, cwd, branch });
+    }
+    return adopted;
+  }
+
   async startTurn(turn) {
     const { turnId } = turn;
     if (this.running.has(turnId)) return;
@@ -755,7 +905,7 @@ export class BridgeDaemon {
       // local paths — the prompt lists them.
       const workDir = bound[0]?.cwd;
       if (!workDir) throw new Error("Turn has no repositories.");
-      const repoNote = bound.length > 1 ? `\n\nRepositories for this task:\n${bound.map((b) => `- ${b.key}: ${b.cwd}`).join("\n")}` : "";
+      const repoNote = this.repoBrief(turn, bound);
       // Previews are manual-only (dashboard "Start preview") — a turn
       // never boots dev servers on its own. When the user already has a
       // preview running for this session, describe it to the agent and
@@ -773,7 +923,7 @@ export class BridgeDaemon {
       });
       await batcher.flush();
       const completed = !ctrl.signal.aborted && res.code === 0 && !res.rateLimited;
-      const changes = bound.map((b) => {
+      const changes = [...bound, ...this.adoptSessionWorktrees(turn, bound)].map((b) => {
         ensureCommitExcludes(b.cwd, { allowDevConfig: !!turn.allowDevConfig });
         const diff = collectChanges(b.cwd);
         // Build turns in worktree mode publish the session branch so the
@@ -786,7 +936,9 @@ export class BridgeDaemon {
               message: `${turn.title || "Kai Code changes"}\n\nSession ${turn.sessionId} · run on ${this.config.device?.name || "a paired device"}`,
             })
           : null;
-        return { key: b.key, mode: b.mode, branch: b.branch, base: b.base, ...diff, push };
+        // `cwd` travels with the change so the dashboard can point at
+        // work that stayed on this machine (files but no push).
+        return { key: b.key, mode: b.mode, branch: b.branch, base: b.base, cwd: b.cwd, adopted: b.adopted || undefined, ...diff, push };
       });
       // Built OUTSIDE the report call: if posting the result throws, the
       // catch below must not turn a finished turn into a failed one. The
@@ -819,6 +971,7 @@ export class BridgeDaemon {
       this.forgetInflight(turnId);
       releaseAwake();
       this.running.delete(turnId);
+      if (this.updatePending && this.running.size === 0) void this.checkForUpdate();
     }
   }
 

package/src/selfupdate.mjs

@@ -0,0 +1,105 @@
+// Self-update: the daemon checks npm for a newer @gleapai/kai-bridge and,
+// when idle, installs it into the same global prefix the login service
+// already points at, then exits so launchd/systemd restart it on the new
+// code (Windows: it re-spawns itself). Paired machines used to stay on
+// whatever version each teammate last typed `npm i -g` for.
+
+import { execFile } from "node:child_process";
+import { existsSync, readFileSync } from "node:fs";
+import { platform } from "node:os";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+export const PACKAGE_NAME = "@gleapai/kai-bridge";
+export const REGISTRY_LATEST_URL = `https://registry.npmjs.org/${PACKAGE_NAME}/latest`;
+export const PACKAGE_ROOT = join(dirname(fileURLToPath(import.meta.url)), "..");
+
+/** The version of THIS install (re-read after an install to verify it). */
+export function installedVersion(root = PACKAGE_ROOT) {
+  return JSON.parse(readFileSync(join(root, "package.json"), "utf8")).version;
+}
+
+function parseVersion(v) {
+  const m = /^v?(\d+)\.(\d+)\.(\d+)(?:-([0-9A-Za-z.-]+))?/.exec(String(v || "").trim());
+  if (!m) return null;
+  return { parts: [Number(m[1]), Number(m[2]), Number(m[3])], pre: m[4] || null };
+}
+
+/** semver-ish: -1 / 0 / 1; a prerelease ranks below its release; unparsable = equal. */
+export function compareVersions(a, b) {
+  const pa = parseVersion(a);
+  const pb = parseVersion(b);
+  if (!pa || !pb) return 0;
+  for (let i = 0; i < 3; i += 1) {
+    if (pa.parts[i] !== pb.parts[i]) return pa.parts[i] > pb.parts[i] ? 1 : -1;
+  }
+  if (!!pa.pre !== !!pb.pre) return pa.pre ? -1 : 1;
+  return 0;
+}
+
+export function isNewer(latest, current) {
+  return compareVersions(latest, current) > 0;
+}
+
+/** The registry's `latest` dist-tag. Plain HTTPS — no npm needed to look. */
+export async function fetchLatestVersion({ fetchImpl = globalThis.fetch, timeoutMs = 8_000, url = REGISTRY_LATEST_URL } = {}) {
+  const ctrl = new AbortController();
+  const timer = setTimeout(() => ctrl.abort(), timeoutMs);
+  try {
+    const res = await fetchImpl(url, { signal: ctrl.signal, headers: { accept: "application/json" } });
+    if (!res.ok) throw new Error(`registry ${res.status}`);
+    const body = await res.json();
+    if (!body?.version) throw new Error("registry response has no version");
+    return String(body.version);
+  } finally {
+    clearTimeout(timer);
+  }
+}
+
+/**
+ * What to do about `latest`, given the daemon's state:
+ *   skip   — nothing to do now (up to date, or a turn is running: retry later)
+ *   notify — a newer version exists but we must not install it (auto-update
+ *            off, or this exact version already failed to install once)
+ *   update — install it now
+ */
+export function decideUpdate({ current, latest, running = 0, autoUpdate = true, lastAttempt = null }) {
+  if (!latest || !isNewer(latest, current)) return { action: "skip", reason: "up_to_date" };
+  if (autoUpdate === false) return { action: "notify", reason: "disabled" };
+  if (lastAttempt && lastAttempt.version === latest && lastAttempt.ok === false) return { action: "notify", reason: "failed_before" };
+  if (running > 0) return { action: "skip", reason: "busy" };
+  return { action: "update", reason: "newer" };
+}
+
+/** The npm that belongs to the node running us — same global prefix as the install. */
+export function npmBinary(execPath = process.execPath, os = platform()) {
+  const candidate = join(dirname(execPath), os === "win32" ? "npm.cmd" : "npm");
+  return existsSync(candidate) ? candidate : os === "win32" ? "npm.cmd" : "npm";
+}
+
+/**
+ * `npm install -g <pkg>@<version>` into the current prefix, then re-read the
+ * package.json at this install's path to prove the files were replaced.
+ * Async on purpose: the daemon's heartbeat keeps running while npm works.
+ */
+export function installVersion(version, { npm = npmBinary(), timeoutMs = 5 * 60_000, root = PACKAGE_ROOT, exec = execFile } = {}) {
+  return new Promise((resolve) => {
+    exec(
+      npm,
+      ["install", "-g", `${PACKAGE_NAME}@${version}`, "--no-fund", "--no-audit", "--loglevel=error"],
+      { timeout: timeoutMs, maxBuffer: 8 * 1024 * 1024, shell: platform() === "win32" },
+      (err, stdout, stderr) => {
+        const output = `${stdout || ""}${stderr || ""}`.trim().slice(-2000);
+        if (err) return resolve({ ok: false, version, error: `${err.message}${output ? `\n${output}` : ""}`.slice(0, 1500) });
+        let installed = null;
+        try {
+          installed = installedVersion(root);
+        } catch (readErr) {
+          return resolve({ ok: false, version, error: `installed, but could not read ${root}/package.json: ${readErr.message}` });
+        }
+        if (installed !== version) return resolve({ ok: false, version, error: `npm finished but ${root} still reports ${installed}` });
+        resolve({ ok: true, version });
+      },
+    );
+  });
+}

package/src/workspace.mjs

@@ -107,6 +107,15 @@ export function materializeBinding({ kaiHome, repo, binding, sessionId, title, b
   return { cwd: dir, mode, branch, base, resumed: false };
 }
 
+/** The branch checked out at `cwd` (null when it is not a git checkout). */
+export function currentBranch(cwd) {
+  try {
+    return git(cwd, ["rev-parse", "--abbrev-ref", "HEAD"]) || null;
+  } catch {
+    return null;
+  }
+}
+
 /** Diff of what the turn changed (for the dashboard's file-changes panel). */
 export function collectChanges(cwd) {
   const status = git(cwd, ["status", "--porcelain"]);