@gleapai/kai-bridge 0.7.0 → 0.9.1

package/src/workspace.mjs

@@ -15,7 +15,6 @@
 import { execFileSync } from "node:child_process";
 import { copyFileSync, existsSync, mkdirSync, readFileSync, readdirSync, rmSync, statSync, writeFileSync } from "node:fs";
 import { dirname, join } from "node:path";
-import { createHash } from 'node:crypto';
 
 import { seedNodeModules } from "./deps.mjs";
 
@@ -23,19 +22,97 @@ function git(cwd, args, opts = {}) {
   return execFileSync("git", args, { cwd, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], ...opts }).trim();
 }
 
-export function sessionSlug(sessionId, title) {
-  if (process.env.KAI_HOSTED === '1') {
-    if (!/^[a-zA-Z0-9_-]{1,128}$/.test(String(sessionId))) throw new Error('Invalid session identity.');
-    return `session-${sessionId}`;
+/** 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);
+
+/**
+ * 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
+ * of a dead session. `repo` names the checkout for the log line.
+ */
+export class WorkspaceError extends Error {
+  constructor(message, { code, repo, cause } = {}) {
+    super(message, cause ? { cause } : undefined);
+    this.name = "WorkspaceError";
+    this.code = code;
+    this.repo = repo;
   }
+}
+
+/**
+ * Git refused to update a ref because ANOTHER git process was writing the
+ * same repo at that moment: the bridge fetches `origin/<base>` in the
+ * user's primary checkout, and IDE auto-fetch / a second session /
+ * the user's own `git pull` race it there. The loser sees one of:
+ *
+ *   cannot lock ref 'refs/remotes/origin/master': is at <new> but expected <old>
+ *   Unable to create '…/refs/remotes/origin/master.lock': File exists.
+ *   Another git process seems to be running in this repository
+ *
+ * None of them mean anything is wrong — the ref is simply being moved by
+ * someone else — so the fetch is retried, and if it keeps losing the
+ * ref the competitor just wrote is used as the base (2026-09-16: a
+ * session on ticket #147312 died 54 s in on exactly this, before the
+ * agent ever ran).
+ */
+export function isRefLockContention(message) {
+  const text = String(message || "");
+  return (
+    /cannot lock ref/i.test(text) ||
+    /\.lock['"]?: File exists/i.test(text) ||
+    /Another git process seems to be running/i.test(text)
+  );
+}
+
+const sleepSync = (ms) => {
+  if (ms > 0) Atomics.wait(new Int32Array(new SharedArrayBuffer(4)), 0, 0, ms);
+};
+
+/**
+ * `git fetch origin <base>` in `primaryPath`, tolerant of ref-lock
+ * contention. Returns `{ 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.
+ */
+export function fetchBase(primaryPath, base, { exec = git, attempts = 4, backoffMs = 400, sleep = sleepSync, repo = primaryPath, gitEnv = null } = {}) {
+  let lastError = null;
+  for (let attempt = 1; attempt <= attempts; attempt += 1) {
+    try {
+      exec(primaryPath, ["fetch", "origin", base, "--quiet"], withGitEnv(gitEnv));
+      return { attempts: attempt, stale: false };
+    } catch (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);
+    }
+  }
+  // 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}`]);
+    return { attempts, stale: true };
+  } catch {
+    throw new WorkspaceError(
+      `Git in ${repo} was busy (another fetch was running) and origin/${base} is not available yet — retry the task.`,
+      { code: "workspace_transient", repo, cause: lastError },
+    );
+  }
+}
+
+export function sessionSlug(sessionId, title) {
   const t = String(title || "").toLowerCase().replace(/[^a-z0-9]+/g, "-").replace(/^-|-$/g, "").slice(0, 32);
   const id = String(sessionId || "").slice(-8);
   return t ? `${t}-${id}` : `session-${id}`;
 }
 
 export function worktreePath(kaiHome, repoName, slug) {
-  const repo = process.env.KAI_HOSTED === '1' ? createHash('sha256').update(String(repoName)).digest('hex') : repoName;
-  return join(kaiHome, "worktrees", repo, slug);
+  return join(kaiHome, "worktrees", repoName, slug);
 }
 
 /**
@@ -73,7 +150,7 @@ export function copyPrimaryEnvFiles(primaryPath, cwd) {
  * Materialise one repo binding. Returns `{ cwd, mode, branch, base }`.
  * `repo` = `{ name, primaryPath, defaultBranch }`, `binding` = `{ mode, base?, carryUncommitted? }`.
  */
-export function materializeBinding({ kaiHome, repo, binding, sessionId, title, branchPrefix = "kai" }) {
+export function materializeBinding({ kaiHome, repo, binding, sessionId, title, branchPrefix = "kai", fetch = fetchBase, gitEnv = null }) {
   const mode = binding?.mode === "local" ? "local" : "worktree";
   if (mode === "local") {
     const branch = git(repo.primaryPath, ["rev-parse", "--abbrev-ref", "HEAD"]);
@@ -88,7 +165,7 @@ export function materializeBinding({ kaiHome, repo, binding, sessionId, title, b
     return { cwd: dir, mode, branch, base, resumed: true };
   }
   mkdirSync(dirname(dir), { recursive: true });
-  git(repo.primaryPath, ["fetch", "origin", base, "--quiet"]);
+  const fetched = fetch(repo.primaryPath, base, { repo: repo.name, gitEnv });
   git(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
@@ -116,7 +193,7 @@ export function materializeBinding({ kaiHome, repo, binding, sessionId, title, b
       }
     }
   }
-  return { cwd: dir, mode, branch, base, resumed: false, deps };
+  return { cwd: dir, mode, branch, base, resumed: false, deps, fetch: fetched };
 }
 
 /** The branch checked out at `cwd` (null when it is not a git checkout). */
@@ -176,22 +253,9 @@ export function discardChanges(cwd) {
 export function removeWorktree({ kaiHome, repo, sessionId, title }) {
   const dir = worktreePath(kaiHome, repo.name, sessionSlug(sessionId, title));
   if (!existsSync(dir)) return false;
-  if (process.env.KAI_HOSTED === '1') {
-    // Never destroy dirty or unpushed work during session cleanup.
-    if (collectChanges(dir).files.length || git(dir, ['log', '--branches', '--not', '--remotes', '--oneline'])) return false;
-    git(repo.primaryPath, ['worktree', 'remove', dir]);
-    return true;
-  }
-  try {
-    git(repo.primaryPath, ["worktree", "remove", "--force", dir]);
-  } catch {
-    rmSync(dir, { recursive: true, force: true });
-    try {
-      git(repo.primaryPath, ["worktree", "prune"]);
-    } catch {
-      /* best-effort */
-    }
-  }
+  // Never destroy dirty or unpushed work during session cleanup.
+  if (collectChanges(dir).files.length || git(dir, ['log', 'HEAD', '--not', '--remotes', '--oneline'])) return false;
+  git(repo.primaryPath, ['worktree', 'remove', dir]);
   return true;
 }
 
@@ -286,7 +350,7 @@ export function ensureCommitExcludes(cwd, { allowDevConfig = false } = {}) {
   }
 }
 
-export function commitAndPush(cwd, { branch, message, allowEmpty = false, allowDevConfig = false } = {}) {
+export function commitAndPush(cwd, { branch, message, allowEmpty = false, allowDevConfig = false, gitEnv = null } = {}) {
   const out = { committed: false, pushed: false, branch, commitSha: null, remote: null, error: null };
   try {
     ensureCommitExcludes(cwd, { allowDevConfig });
@@ -298,7 +362,7 @@ export function commitAndPush(cwd, { branch, message, allowEmpty = false, allowD
     }
     out.commitSha = git(cwd, ["rev-parse", "HEAD"]);
     out.remote = git(cwd, ["remote", "get-url", "origin"]);
-    git(cwd, ["push", "-u", "origin", `HEAD:${branch}`], { timeout: 120_000 });
+    git(cwd, ["push", "-u", "origin", `HEAD:${branch}`], withGitEnv(gitEnv, { timeout: 120_000 }));
     out.pushed = true;
   } catch (err) {
     out.error = String(err?.stderr || err?.message || err).trim().slice(0, 500);

package/fly/Dockerfile

@@ -1,11 +0,0 @@
-FROM node:24-bookworm-slim
-RUN apt-get update && apt-get install -y --no-install-recommends git ca-certificates curl sudo openssh-client lsof procps supervisor xvfb fluxbox x11vnc novnc websockify python3 make g++ && rm -rf /var/lib/apt/lists/*
-RUN useradd --home-dir /data/home/kai --shell /bin/bash kai && printf 'kai ALL=(ALL) NOPASSWD:ALL\n' > /etc/sudoers.d/kai && chmod 440 /etc/sudoers.d/kai
-WORKDIR /opt/kai-bridge
-COPY package.json package-lock.json ./
-RUN npm ci --ignore-scripts
-COPY . .
-ENV PLAYWRIGHT_BROWSERS_PATH=/opt/playwright
-RUN node scripts/postinstall.mjs && node scripts/runtime-smoke.mjs && chmod +x src/codex-broker-client.mjs src/hosted-git.mjs fly/runtime-cli.sh fly/entrypoint.sh fly/login-codex.sh && for cli in codex claude git; do ln -s /opt/kai-bridge/fly/runtime-cli.sh /usr/local/bin/$cli; done && npx playwright install --with-deps chromium
-ENV KAI_HOSTED=1 KAI_HOME=/data/home/kai/.kai HOME=/data/home/kai KAI_BRIDGE_NO_SELF_UPDATE=1 DISABLE_AUTOUPDATER=1
-ENTRYPOINT ["/opt/kai-bridge/fly/entrypoint.sh"]

package/fly/UPDATES.md

@@ -1,76 +0,0 @@
-# Hosted coding runtime releases
-
-One Bridge release owns the complete coding runtime: Codex CLI, Claude Agent SDK
-(including its native Claude Code binary), both ACP adapters, Bridge and its
-runner. Versions are pinned in package.json and package-lock.json. The image no
-longer installs separate global CLIs. `codex`, `claude`, login, version probes,
-coding turns and the supervised Codex process all resolve this bundle.
-
-## Routine updates
-
-Dependabot checks npm dependencies daily and groups the coding runtime changes.
-The `Coding runtime compatibility` workflow runs the full Bridge tests, native
-CLI versions, Codex app-server and both ACP initialization checks, package checks
-and the Linux image build. Vendor CLI updates are disabled for the managed
-executables so they cannot mutate a tested bundle underneath active sessions.
-
-After review and internal qualification, publish a new Bridge version and promote
-that exact version to the npm `hosted-stable` dist-tag. Promotion is a release
-operation, never something a customer VM decides from upstream `latest` versions.
-The channel is intentionally separate from `latest`, which connected devices use.
-No tag is published or promoted merely by adding this workflow.
-
-`npm pack`/`npm publish` generate a published npm-shrinkwrap.json from the committed
-lockfile. Consumers therefore receive the dependency tree that was tested. The
-temporary shrinkwrap is removed after packing. Always bump the Bridge version and
-refresh its lockfile for a new release; npm versions are immutable.
-
-Each hosted machine checks `hosted-stable` on a normal start, at most once per day.
-It does not wake a stopped machine to check. Updates only happen **before
-supervisord starts**, under a file lock; running coding, validation, previews,
-maintenance and login processes are never hot-replaced. A machine that remains
-running applies updates on its next normal stop/start.
-
-The updater downloads an exact release, checks protocol compatibility, installs
-the shrinkwrapped dependencies with lifecycle scripts disabled, and runs native
-startup checks with an empty temporary home. It selects the new bundle atomically
-only after those checks pass. Registry failures, invalid releases, failed checks
-and interrupted installs preserve the previous selection. Failed versions are
-quarantined; the next distinct approved version can still update.
-
-Runtime files are stored under `/opt/kai-runtime`. User repositories, worktrees,
-home directories and authentication remain on `/data` and are never copied or
-overwritten by updates. The current and one previous installed bundle are kept.
-This does not rebuild the VM, reset its usage allowance, or require a new login.
-Setup/update running time still counts against the slot allowance.
-
-## Rollback and support
-
-Inspect `/opt/kai-runtime/state.json` for the active version, previous version,
-last check, failed version and update error. Bridge's normal version/harness
-reports show the selected executable versions in Gleap. Updates can be disabled
-with the machine environment `KAI_HOSTED_RUNTIME_UPDATES=0`.
-
-If a runtime passes startup checks but later proves incompatible, schedule a
-rollback through maintenance SSH:
-
-```sh
-sudo node /opt/kai-bridge/fly/runtime-update.mjs --rollback-next-start
-```
-
-Then stop and start the machine through Gleap. This selects the retained previous
-bundle (or the image's original bundle), preserves credentials/files and
-quarantines the rejected release. The command does not interrupt current work.
-Do not run `npm update` inside active release directories.
-
-The startup checks exercise real binaries and protocol initialization without
-account credentials or billable prompts. They do not replace authenticated
-two-session coding/refresh/verification tests on the internal cohort before
-promoting `hosted-stable`. A startup pass cannot guarantee compatibility with
-every provider-side behavior. Keep the previous runtime available for rollback.
-
-Changing the bootstrap protocol, OS packages, browser revision or persistent data formats requires
-an explicit image/migration release; the boot updater rejects unsupported
-protocol versions and Playwright revisions that differ from the image's installed
-browser. System modifications survive normal starts as configured by
-Fly root-filesystem persistence.

package/fly/codex-auth.mjs

@@ -1,5 +0,0 @@
-import { startCodexBroker } from '../src/codex-broker.mjs';
-import { mkdirSync } from 'node:fs';
-mkdirSync('/data/home/kai/.codex', { recursive: true });
-const broker = startCodexBroker();
-process.on('SIGTERM', () => { broker.close(); process.exit(0); });

package/fly/entrypoint.sh

@@ -1,12 +0,0 @@
-#!/bin/sh
-set -eu
-mkdir -p /data/home/kai/.codex /data/home/kai/.claude /data/repos /data/logs
-chown kai:kai /data/home/kai /data/home/kai/.codex /data/home/kai/.claude /data/repos /data/logs
-touch /run/kai-runtime-update.lock
-chown root:kai /run/kai-runtime-update.lock
-chmod 660 /run/kai-runtime-update.lock
-# The lock and boot boundary keep installations away from coding/login/preview
-# processes. Failed or interrupted updates keep the previous validated bundle.
-KAI_RUNTIME_ROOT="$(flock /run/kai-runtime-update.lock node /opt/kai-bridge/fly/runtime-update.mjs)"
-export KAI_RUNTIME_ROOT
-exec /usr/bin/supervisord -n -c /opt/kai-bridge/fly/supervisord.conf

package/fly/login-codex.sh

@@ -1,9 +0,0 @@
-#!/bin/sh
-set -eu
-# Pause the single refresh owner while native device authentication updates it.
-exec 9>/data/codex-login.lock
-flock -n 9 || { echo 'Another Codex sign-in is already in progress.'; exit 1; }
-control='/opt/kai-bridge/fly/supervisord.conf'
-supervisorctl -c "$control" stop codex-auth
-trap 'supervisorctl -c "$control" start codex-auth' EXIT
-sudo -iu kai codex login --device-auth

package/fly/runtime-cli.mjs

@@ -1,15 +0,0 @@
-#!/usr/bin/env node
-import { basename, join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { spawn } from 'node:child_process';
-import { runtimeRoot } from './runtime-update.mjs';
-
-const root = process.env.KAI_RUNTIME_ROOT || runtimeRoot();
-const name = process.env.KAI_RUNTIME_CLI_NAME || basename(process.argv[1]).replace(/\.mjs$/, '');
-const { harnessBinary } = await import(pathToFileURL(join(root, 'src/harnesses.mjs')));
-const command = name === 'git' ? process.execPath : harnessBinary(name);
-if (!command) { process.stderr.write('The selected Kai runtime is missing this executable.\n'); process.exit(1); }
-const args = name === 'git' ? [join(root, 'src/hosted-git.mjs'), ...process.argv.slice(2)] : process.argv.slice(2);
-const child = spawn(command, args, { stdio: 'inherit', env: { ...process.env, KAI_RUNTIME_ROOT: root, DISABLE_AUTOUPDATER: '1' } });
-child.on('error', () => process.exit(1));
-child.on('exit', (code, signal) => { if (signal) process.kill(process.pid, signal); else process.exit(code ?? 1); });

package/fly/runtime-cli.sh

@@ -1,10 +0,0 @@
-#!/bin/sh
-set -eu
-KAI_RUNTIME_CLI_NAME="${0##*/}"
-export KAI_RUNTIME_CLI_NAME
-# Startup validation has an isolated HOME and already holds the exclusive lock.
-if [ "${KAI_RUNTIME_UPDATE_CHECK:-0}" = '1' ]; then
-  exec node /opt/kai-bridge/fly/runtime-cli.mjs "$@"
-fi
-# A native CLI opened through maintenance SSH waits for an in-progress update.
-exec flock --shared /run/kai-runtime-update.lock node /opt/kai-bridge/fly/runtime-cli.mjs "$@"

package/fly/runtime-launch.mjs

@@ -1,8 +0,0 @@
-import { join } from 'node:path';
-import { pathToFileURL } from 'node:url';
-import { runtimeRoot } from './runtime-update.mjs';
-const entry = { bridge: 'start.mjs', 'codex-auth': 'codex-auth.mjs' }[process.argv[2]];
-if (!entry) throw new Error('Unknown hosted runtime service.');
-const root = process.env.KAI_RUNTIME_ROOT || runtimeRoot();
-process.env.KAI_RUNTIME_ROOT = root;
-await import(pathToFileURL(join(root, 'fly', entry)));

package/fly/runtime-update.mjs

@@ -1,137 +0,0 @@
-import { execFile } from 'node:child_process';
-import { existsSync, mkdirSync, readFileSync, readdirSync, renameSync, rmSync, writeFileSync } from 'node:fs';
-import { join, resolve } from 'node:path';
-import { fileURLToPath } from 'node:url';
-import { promisify } from 'node:util';
-import { isNewer } from '../src/selfupdate.mjs';
-
-const exec = promisify(execFile);
-export const BASE_RUNTIME = '/opt/kai-bridge';
-export const RUNTIME_STORE = '/opt/kai-runtime';
-const CHANNEL = 'https://registry.npmjs.org/@gleapai/kai-bridge/hosted-stable';
-const DAY = 86400_000;
-const version = value => typeof value === 'string' && /^\d+\.\d+\.\d+$/.test(value);
-const read = path => { try { return JSON.parse(readFileSync(path, 'utf8')); } catch { return {}; } };
-const packageAt = root => read(join(root, 'package.json'));
-export function browserVersion(root) {
-  const lock = read(join(root, existsSync(join(root, 'npm-shrinkwrap.json')) ? 'npm-shrinkwrap.json' : 'package-lock.json'));
-  return lock.packages?.['node_modules/playwright-core']?.version;
-}
-
-export function assertImageCompatibility(candidate, base) {
-  // Chromium is installed by the image, outside the replaceable runtime. Never
-  // activate a new Playwright revision against the old browser executable.
-  if (!browserVersion(candidate) || browserVersion(candidate) !== browserVersion(base)) {
-    throw Object.assign(new Error('This release needs a browser image update.'), { code: 'image_required' });
-  }
-}
-
-export function runtimeRoot(store = RUNTIME_STORE, base = BASE_RUNTIME) {
-  const state = read(join(store, 'state.json'));
-  const candidate = version(state.active) ? join(store, 'releases', state.active) : base;
-  return existsSync(join(candidate, 'package.json')) ? candidate : base;
-}
-
-function save(store, state) {
-  mkdirSync(store, { recursive: true });
-  const temporary = join(store, `state.${process.pid}.tmp`);
-  writeFileSync(temporary, JSON.stringify(state, null, 2) + '\n', { mode: 0o644 });
-  renameSync(temporary, join(store, 'state.json'));
-}
-
-export function supervisorRunning() {
-  const pid = Number(readFileText('/run/supervisord.pid'));
-  if (!Number.isSafeInteger(pid) || pid <= 1) return false;
-  try { process.kill(pid, 0); return true; } catch { return false; }
-}
-const readFileText = path => { try { return readFileSync(path, 'utf8').trim(); } catch { return ''; } };
-
-export function requestRuntimeRollback(store = RUNTIME_STORE) {
-  const state = read(join(store, 'state.json'));
-  if (!state.active || !state.previousVersion) throw new Error('No previous runtime is available.');
-  writeFileSync(join(store, 'rollback-next-start'), '1\n', { mode: 0o600 });
-}
-
-export async function fetchHostedRelease() {
-  const response = await fetch(CHANNEL, { signal: AbortSignal.timeout(8000), headers: { accept: 'application/json' } });
-  if (response.status === 404) return null; // Channel has not been promoted yet.
-  if (!response.ok) throw new Error(`Release registry unavailable (${response.status}).`);
-  return response.json();
-}
-
-export async function installHostedRelease(release, destination, store, base = BASE_RUNTIME) {
-  mkdirSync(destination, { recursive: true });
-  const home = join(destination, '.install-home'); mkdirSync(home);
-  // No customer HOME, OAuth profiles, bootstrap token or npm login is inherited.
-  const env = { PATH: process.env.PATH, HOME: home, CI: '1', KAI_RUNTIME_UPDATE_CHECK: '1', npm_config_registry: 'https://registry.npmjs.org', npm_config_cache: join(store, 'cache') };
-  try {
-    const packed = await exec('npm', ['pack', `@gleapai/kai-bridge@${release.version}`, '--ignore-scripts', '--json', '--pack-destination', destination], { env, timeout: 30_000, maxBuffer: 1024 * 1024 });
-    const archive = JSON.parse(packed.stdout)?.[0]?.filename;
-    if (archive !== `gleapai-kai-bridge-${release.version}.tgz`) throw new Error('Unexpected runtime archive.');
-    await exec('tar', ['-xzf', join(destination, archive), '--strip-components=1', '-C', destination], { timeout: 10_000 });
-    const pkg = packageAt(destination), lock = read(join(destination, 'npm-shrinkwrap.json'));
-    if (pkg.name !== '@gleapai/kai-bridge' || pkg.version !== release.version || pkg.kaiHostedRuntime?.protocol !== 1 || lock.version !== pkg.version) throw new Error('Release lacks a matching locked runtime.');
-    assertImageCompatibility(destination, base);
-    await exec('npm', ['ci', '--ignore-scripts', '--omit=dev', '--no-audit', '--no-fund'], { cwd: destination, env, timeout: 60_000, maxBuffer: 1024 * 1024 });
-    await exec(process.execPath, [join(destination, 'scripts/runtime-smoke.mjs')], { cwd: destination, env, timeout: 45_000, maxBuffer: 1024 * 1024 });
-    rmSync(join(destination, archive), { force: true });
-  } finally { rmSync(home, { recursive: true, force: true }); }
-}
-
-/** Called under flock BEFORE supervisord starts. Running VMs never hot-swap
- * runtimes. Install/check failures and interrupted installs retain the old root. */
-export async function updateHostedRuntime({ store = RUNTIME_STORE, base = BASE_RUNTIME, now = Date.now(), busy = supervisorRunning(), enabled = true,
-  fetchRelease = fetchHostedRelease, install = installHostedRelease, log = message => process.stderr.write(`${message}\n`) } = {}) {
-  const current = runtimeRoot(store, base);
-  if (busy) return current;
-  const state = read(join(store, 'state.json'));
-  if (existsSync(join(store, 'rollback-next-start')) && state.active && state.previousVersion) {
-    save(store, { checkedAt: now, active: state.previous || null, failed: state.active, rolledBackAt: now });
-    rmSync(join(store, 'rollback-next-start'), { force: true });
-    log('Previous hosted runtime selected; the rejected release is quarantined.');
-    return runtimeRoot(store, base);
-  }
-  if (!enabled) return current;
-  if (state.checkedAt && now - state.checkedAt < DAY) return current;
-  state.checkedAt = now; save(store, state);
-  let release, staging;
-  try {
-    release = await fetchRelease();
-    if (!release || release.name !== '@gleapai/kai-bridge' || release.kaiHostedRuntime?.protocol !== 1 || !version(release.version)) return current;
-    if (!isNewer(release.version, packageAt(current).version) || state.failed === release.version) return current;
-    staging = join(store, 'releases', `.staging-${release.version}`);
-    rmSync(staging, { recursive: true, force: true });
-    await install(release, staging, store, base);
-    // Recheck admission boundary before activation, including manual invocation.
-    if (supervisorRunning()) throw new Error('Machine became busy during the update.');
-    const destination = join(store, 'releases', release.version);
-    rmSync(destination, { recursive: true, force: true });
-    renameSync(staging, destination);
-    save(store, { checkedAt: now, active: release.version, previous: state.active || null, previousVersion: packageAt(current).version, activatedAt: now });
-    // Keep one rollback bundle. User repositories and auth are outside this store.
-    try {
-      for (const entry of readdirSync(join(store, 'releases'))) {
-        if (version(entry) && entry !== release.version && entry !== state.active) rmSync(join(store, 'releases', entry), { recursive: true, force: true });
-      }
-      rmSync(join(store, 'cache'), { recursive: true, force: true });
-    } catch { /* Cleanup cannot invalidate an already-validated activation. */ }
-    log(`Hosted runtime ${release.version} validated and selected for this start.`);
-    return destination;
-  } catch (error) {
-    if (staging) rmSync(staging, { recursive: true, force: true });
-    save(store, { ...state, ...(release?.version && version(release.version) ? { failed: release.version } : {}), error: error.code === 'image_required' ? 'This release needs a browser image update; previous runtime retained.' : 'Runtime update failed; previous release retained.' });
-    log('Hosted runtime update failed; starting the previous release.');
-    return current;
-  }
-}
-
-if (process.argv[1] && resolve(process.argv[1]) === fileURLToPath(import.meta.url)) {
-  if (process.argv.includes('--rollback-next-start')) {
-    requestRuntimeRollback(); process.stdout.write('Rollback scheduled. Stop and start the machine from Gleap to apply it.\n');
-  } else {
-  // stdout is consumed by the entrypoint: emit only the selected absolute path.
-  updateHostedRuntime({ enabled: process.env.KAI_HOSTED_RUNTIME_UPDATES !== '0' })
-    .then(root => process.stdout.write(`${root}\n`))
-    .catch(() => process.stdout.write(`${runtimeRoot()}\n`));
-  }
-}

package/fly/start.mjs

@@ -1,7 +0,0 @@
-import { bootstrapHosted } from '../src/hosted.mjs';
-import { BridgeDaemon } from '../src/daemon.mjs';
-await bootstrapHosted();
-const daemon = new BridgeDaemon();
-process.on('SIGTERM', () => { void daemon.stop(); });
-process.on('SIGINT', () => { void daemon.stop(); });
-await daemon.start();

package/fly/supervisord.conf

@@ -1,45 +0,0 @@
-[unix_http_server]
-file=/run/supervisor.sock
-chmod=0700
-[supervisord]
-nodaemon=true
-logfile=/data/logs/supervisor.log
-pidfile=/run/supervisord.pid
-[rpcinterface:supervisor]
-supervisor.rpcinterface_factory=supervisor.rpcinterface:make_main_rpcinterface
-[supervisorctl]
-serverurl=unix:///run/supervisor.sock
-[program:kai-bridge]
-command=node /opt/kai-bridge/fly/runtime-launch.mjs bridge
-user=kai
-environment=HOME="/data/home/kai",KAI_HOME="/data/home/kai/.kai",DISPLAY=":99"
-autorestart=unexpected
-stopasgroup=true
-killasgroup=true
-stdout_logfile=/data/logs/bridge.log
-stderr_logfile=/data/logs/bridge-error.log
-[program:codex-auth]
-command=node /opt/kai-bridge/fly/runtime-launch.mjs codex-auth
-user=kai
-environment=HOME="/data/home/kai",CODEX_HOME="/data/home/kai/.codex"
-autorestart=true
-stopasgroup=true
-stdout_logfile=/data/logs/codex-auth.log
-stderr_logfile=/data/logs/codex-auth-error.log
-[program:display]
-command=/usr/bin/Xvfb :99 -screen 0 1440x900x24 -nolisten tcp
-user=kai
-autorestart=true
-[program:desktop]
-command=/usr/bin/fluxbox
-user=kai
-environment=DISPLAY=":99",HOME="/data/home/kai"
-autorestart=true
-[program:vnc]
-command=/usr/bin/x11vnc -display :99 -localhost -forever -shared -nopw -rfbport 5900
-user=kai
-autorestart=true
-[program:browser-login]
-command=/usr/bin/websockify --web=/usr/share/novnc 127.0.0.1:6080 127.0.0.1:5900
-user=kai
-autorestart=true

package/src/codex-broker-client.mjs

@@ -1,16 +0,0 @@
-#!/usr/bin/env node
-import { connect } from 'node:net';
-import { spawn } from 'node:child_process';
-import { harnessBinary } from './harnesses.mjs';
-if (process.argv[2] !== 'app-server') {
-  // Version/login commands remain native. Refresh for coding sessions is owned
-  // exclusively by the supervised app-server.
-  const child = spawn(harnessBinary('codex'), process.argv.slice(2), { stdio: 'inherit' });
-  child.on('error', () => process.exit(1));
-  child.on('exit', code => process.exit(code || 0));
-} else {
-  const socket = connect('/data/home/kai/.kai/codex.sock');
-  process.stdin.pipe(socket); socket.pipe(process.stdout);
-  socket.on('error', () => { process.stderr.write('The Codex authentication service is unavailable. Restart it using maintenance SSH.\n'); process.exit(1); });
-  socket.on('close', () => process.exit(0));
-}

package/src/codex-broker.mjs

@@ -1,85 +0,0 @@
-// One native Codex app-server (and therefore one refresh-token owner) per VM.
-// ACP adapters retain independent session configuration and talk JSON-RPC
-// through private Unix sockets. No authentication files are copied per turn.
-import { createServer } from 'node:net';
-import { spawn } from 'node:child_process';
-import { createInterface } from 'node:readline';
-import { chmodSync, rmSync, mkdirSync } from 'node:fs';
-import { dirname } from 'node:path';
-import { boundHostedProcess } from './hosted-resources.mjs';
-import { harnessBinary } from './harnesses.mjs';
-
-export function startCodexBroker({ socketPath = '/data/home/kai/.kai/codex.sock', command = harnessBinary('codex'), spawnImpl = spawn } = {}) {
-  if (!command) throw new Error('The bundled Codex executable is missing.');
-  mkdirSync(dirname(socketPath), { recursive: true }); rmSync(socketPath, { force: true });
-  const processHandle = spawnImpl(command, ['app-server'], { env: { ...process.env, CODEX_HOME: '/data/home/kai/.codex' }, detached: process.env.KAI_HOSTED === '1', stdio: ['pipe', 'pipe', 'inherit'] });
-  boundHostedProcess(processHandle, { limitMb: 1536 });
-  const clients = new Set(), pending = new Map(), threadOwners = new Map(), reverse = new Map(), activeTurns = new Map();
-  let sequence = 0, initialized, initializeRequest, initializeWaiters = [], notified = false;
-  const send = (socket, msg) => { if (!socket.destroyed) socket.write(JSON.stringify(msg) + '\n'); };
-  const upstream = msg => processHandle.stdin.write(JSON.stringify(msg) + '\n');
-  const server = createServer(socket => {
-    clients.add(socket);
-    const lines = createInterface({ input: socket });
-    lines.on('line', line => {
-      let msg; try { msg = JSON.parse(line); } catch { socket.destroy(); return; }
-      if (msg.method === 'initialize') {
-        if (initialized) { send(socket, { id: msg.id, result: initialized }); return; }
-        initializeWaiters.push({ socket, id: msg.id });
-        if (!initializeRequest) { initializeRequest = ++sequence; upstream({ ...msg, id: initializeRequest }); }
-        return;
-      }
-      if (msg.method === 'initialized') { if (!notified) { notified = true; upstream(msg); } return; }
-      if (!msg.method && reverse.has(String(msg.id))) {
-        const req = reverse.get(String(msg.id));
-        if (req.socket !== socket) return;
-        reverse.delete(String(msg.id)); upstream({ ...msg, id: req.id }); return;
-      }
-      const thread = msg.params?.threadId;
-      if (thread && threadOwners.has(thread) && threadOwners.get(thread) !== socket && !threadOwners.get(thread).destroyed) {
-        if (msg.id != null) send(socket, { id: msg.id, error: { code: -32000, message: 'This thread is active in another session.' } });
-        return;
-      }
-      if (thread) threadOwners.set(thread, socket);
-      if (msg.id != null) { const id = ++sequence; pending.set(id, { socket, id: msg.id }); upstream({ ...msg, id }); }
-      else upstream(msg);
-    });
-    socket.once('close', () => {
-      clients.delete(socket); lines.close();
-      initializeWaiters = initializeWaiters.filter(w => w.socket !== socket);
-      for (const [threadId, owner] of threadOwners) if (owner === socket && activeTurns.has(threadId))
-        upstream({ id: ++sequence, method: 'turn/interrupt', params: { threadId, turnId: activeTurns.get(threadId) } });
-      for (const [key, request] of reverse) if (request.socket === socket) { reverse.delete(key); upstream({ id: request.id, error: { code: -32000, message: 'Session owner disconnected.' } }); }
-    });
-    socket.on('error', () => socket.destroy());
-  });
-  createInterface({ input: processHandle.stdout }).on('line', line => {
-    let msg; try { msg = JSON.parse(line); } catch { return; }
-    if (msg.id === initializeRequest && !msg.method) {
-      initialized = msg.result;
-      for (const waiter of initializeWaiters) send(waiter.socket, { ...msg, id: waiter.id });
-      initializeWaiters = []; if (msg.error) initializeRequest = undefined; return;
-    }
-    if (msg.id != null && !msg.method) {
-      const req = pending.get(msg.id); if (!req) return;
-      pending.delete(msg.id);
-      const thread = msg.result?.thread?.id;
-      if (thread) threadOwners.set(thread, req.socket);
-      send(req.socket, { ...msg, id: req.id }); return;
-    }
-    const thread = msg.params?.threadId || msg.params?.thread_id || msg.params?.thread?.id;
-    if (thread && msg.method === 'turn/started' && msg.params?.turn?.id) activeTurns.set(thread, msg.params.turn.id);
-    if (thread && msg.method === 'turn/completed') activeTurns.delete(thread);
-    const socket = thread && threadOwners.get(thread);
-    if (socket && !socket.destroyed) {
-      if (msg.id != null) { const id = `up-${++sequence}`; reverse.set(id, { socket, id: msg.id }); send(socket, { ...msg, id }); }
-      else send(socket, msg);
-    } else if (!thread && msg.id == null && /^(account|model|serverStatus)/.test(msg.method || '')) {
-      for (const client of clients) send(client, msg);
-    } else if (msg.id != null) upstream({ id: msg.id, error: { code: -32000, message: 'Session owner disconnected.' } });
-  });
-  processHandle.once('exit', () => { for (const client of clients) client.destroy(); server.close(); });
-  processHandle.on('error', () => { for (const client of clients) client.destroy(); server.close(); });
-  server.listen(socketPath, () => chmodSync(socketPath, 0o600));
-  return { close() { for (const client of clients) client.destroy(); server.close(); processHandle.kill('SIGTERM'); rmSync(socketPath, { force: true }); } };
-}