@gleapai/kai-bridge 0.5.0 → 0.7.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gleapai/kai-bridge",
-  "version": "0.5.0",
+  "version": "0.7.0",
   "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",
@@ -12,7 +12,10 @@
     "src",
     "runner",
     "scripts/postinstall.mjs",
-    "README.md"
+    "README.md",
+    "fly",
+    "scripts/runtime-smoke.mjs",
+    "npm-shrinkwrap.json"
   ],
   "engines": {
     "node": ">=20"
@@ -20,19 +23,25 @@
   "scripts": {
     "test": "node --test 'test/**/*.test.mjs'",
     "sync-runner": "node scripts/sync-runner.mjs",
-    "postinstall": "node scripts/postinstall.mjs"
+    "postinstall": "node scripts/postinstall.mjs",
+    "runtime:check": "node scripts/runtime-smoke.mjs",
+    "prepack": "node scripts/prepare-release.mjs",
+    "postpack": "node scripts/prepare-release.mjs --clean"
   },
   "dependencies": {
-    "@agentclientprotocol/claude-agent-acp": "0.73.0",
+    "@agentclientprotocol/claude-agent-acp": "0.75.1",
     "@agentclientprotocol/codex-acp": "1.10.0",
     "@agentclientprotocol/sdk": "1.4.0",
     "@playwright/mcp": "^0.0.79",
     "@sockudo/client": "^2.0.0",
     "chokidar": "^4.0.1",
-    "yaml": "^2.9.0"
+    "ws": "^8.21.3",
+    "yaml": "^2.9.0",
+    "@openai/codex": "0.153.4",
+    "@anthropic-ai/claude-agent-sdk": "0.3.266"
   },
   "overrides": {
-    "@anthropic-ai/claude-agent-sdk": "0.3.258"
+    "@anthropic-ai/claude-agent-sdk": "$@anthropic-ai/claude-agent-sdk"
   },
   "exports": {
     ".": "./src/daemon.mjs",
@@ -43,5 +52,8 @@
     "type": "git",
     "url": "git+https://github.com/GleapSDK/kai-bridge.git"
   },
-  "homepage": "https://gleap.io"
+  "homepage": "https://gleap.io",
+  "kaiHostedRuntime": {
+    "protocol": 1
+  }
 }

package/runner/lib/acp/harnesses.mjs

@@ -339,7 +339,7 @@ export const HARNESSES = {
       if (!ctx.byoLogin) env.CODEX_API_KEY = env.OPENAI_API_KEY;
       // MCP servers + disabled/gated tools via config.toml (see
       // buildCodexConfigToml) — never via session/new for codex.
-      writeFileSync(join(ctx.configDir, "config.toml"), buildCodexConfigToml(ctx.mcpServers));
+      if (process.env.KAI_HOSTED !== '1') writeFileSync(join(ctx.configDir, "config.toml"), buildCodexConfigToml(ctx.mcpServers));
       env.NO_BROWSER = "1";
       env.INITIAL_AGENT_MODE = ctx.isPlanMode ? "read-only" : "agent-full-access";
       // Session config merged by the adapter: model + effort + our
@@ -349,6 +349,11 @@ export const HARNESSES = {
         ...(ctx.effort ? { model_reasoning_effort: ctx.effort } : {}),
         ...(ctx.instructionsPath ? { model_instructions_file: ctx.instructionsPath } : {}),
         ...(ctx.maxContextTokens ? { model_context_window: ctx.maxContextTokens } : {}),
+        ...(process.env.KAI_HOSTED === '1' ? { features: { apps: false, collaboration_modes: true },
+          mcp_servers: Object.fromEntries((ctx.mcpServers || []).filter(s => s && (s.url || s.command)).map(s => [sanitizeMcpKey(s.name || s.id), {
+            ...(s.transport === 'http' ? { url: s.url, http_headers: s.headers || {} } : { command: s.command, args: s.args || [], env: s.env || {} }),
+            startup_timeout_sec: 60, tool_timeout_sec: 60, default_tools_approval_mode: 'approve', disabled_tools: [...(s.disabledTools || []), ...(s.gatedTools || [])],
+          }])) } : {}),
       };
       env.CODEX_CONFIG = JSON.stringify(config);
       return env;

package/scripts/runtime-smoke.mjs

@@ -0,0 +1,60 @@
+import { execFile, spawn } from 'node:child_process';
+import { promisify } from 'node:util';
+import { mkdtempSync, mkdirSync, rmSync } from 'node:fs';
+import { tmpdir } from 'node:os';
+import { join, basename } from 'node:path';
+import { createInterface } from 'node:readline';
+import { harnessBinary, harnessAcpCommand } from '../src/harnesses.mjs';
+import { ensureClaudeAcpPatched } from '../src/acp-patch.mjs';
+
+const exec = promisify(execFile);
+const home = mkdtempSync(join(tmpdir(), 'kai-runtime-check-'));
+// No real login, API key, project, device token or user settings in a smoke test.
+const env = { PATH: process.env.PATH, HOME: home, USERPROFILE: home, CODEX_HOME: join(home, 'codex'), CLAUDE_CONFIG_DIR: join(home, 'claude'), DISABLE_AUTOUPDATER: '1', CI: '1', KAI_RUNTIME_UPDATE_CHECK: '1' };
+mkdirSync(env.CODEX_HOME); mkdirSync(env.CLAUDE_CONFIG_DIR);
+
+async function initialize(command, args, params) {
+  const child = spawn(command, args, { env, detached: process.platform !== 'win32', stdio: ['pipe', 'pipe', 'pipe'] });
+  const lines = createInterface({ input: child.stdout });
+  let diagnostic = '';
+  child.stdin.on('error', () => {}); child.stderr.on('data', data => { diagnostic = (diagnostic + data).slice(-1500); });
+  let killTimer;
+  try {
+    await new Promise((resolve, reject) => {
+      const timer = setTimeout(() => reject(new Error('Runtime protocol initialization timed out.')), 12_000);
+      const finish = error => { clearTimeout(timer); error ? reject(error) : resolve(); };
+      child.once('error', finish);
+      child.once('exit', (code, signal) => finish(new Error(`${basename(command)} exited before initialization (${code ?? signal}): ${diagnostic}`)));
+      lines.on('line', line => {
+        let message; try { message = JSON.parse(line); } catch { return; }
+        if (message.id === 1) finish(message.error || !message.result ? new Error('Runtime protocol initialization failed.') : null);
+      });
+      child.stdin.write(JSON.stringify({ jsonrpc: '2.0', id: 1, method: 'initialize', params }) + '\n');
+    });
+  } finally {
+    lines.close();
+    const kill = signal => { try { process.platform === 'win32' ? child.kill(signal) : process.kill(-child.pid, signal); } catch {} };
+    kill('SIGTERM');
+    await new Promise(resolve => { killTimer = setTimeout(() => { kill('SIGKILL'); resolve(); }, 1500); child.once('close', () => { clearTimeout(killTimer); resolve(); }); });
+  }
+}
+
+try {
+  ensureClaudeAcpPatched();
+  for (const harness of ['claude', 'codex']) {
+    const binary = harnessBinary(harness);
+    if (!binary) throw new Error(`${harness} executable is missing.`);
+    const { stdout } = await exec(binary, ['--version'], { env, timeout: 12_000, maxBuffer: 64 * 1024 });
+    if (!/\d+\.\d+\.\d+/.test(stdout)) throw new Error(`${harness} version check failed.`);
+    console.log(`${harness}: ${stdout.trim()}`);
+    env[harness === 'claude' ? 'CLAUDE_CODE_EXECUTABLE' : 'CODEX_PATH'] = binary;
+  }
+  await initialize(harnessBinary('codex'), ['app-server'], { clientInfo: { name: 'kai-runtime-check', version: '1.0.0' }, capabilities: {} });
+  for (const harness of ['claude', 'codex']) {
+    const adapter = harnessAcpCommand(harness);
+    await initialize(adapter.cmd, adapter.args, { protocolVersion: 1, clientCapabilities: {}, clientInfo: { name: 'kai-runtime-check', version: '1.0.0' } });
+  }
+  // Imports catch packaging omissions and syntax/dependency failures before boot.
+  await import('../src/daemon.mjs'); await import('../src/codex-broker.mjs');
+  console.log('Native CLIs, Codex app-server and both ACP adapters passed isolated startup checks.');
+} finally { rmSync(home, { recursive: true, force: true }); }

package/src/codex-broker-client.mjs

@@ -0,0 +1,16 @@
+#!/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

@@ -0,0 +1,85 @@
+// 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 }); } };
+}

package/src/daemon.mjs

@@ -1,3 +1,4 @@
+import { cloneRepository, locateRepository } from './repository-setup.mjs';
 // The always-on part: one outbound realtime subscription for commands,
 // REST for everything the device reports. Idles at ~0 CPU; reconnects
 // with backoff; keeps the machine awake only while a turn runs.
@@ -27,6 +28,9 @@ import { BridgeApi, createEventBatcher } from "./api.mjs";
 import { ensureClaudeAcpPatched } from "./acp-patch.mjs";
 import { KAI_HOME, defaultConfig, loadConfig, saveConfig } from "./config.mjs";
 import { runTurn } from "./executor.mjs";
+import { awaitHostedAdmission, hostedResources, syncHostedRepositories } from './hosted.mjs';
+import { HostedTunnel } from './hosted-tunnel.mjs';
+import { hostedLoginExpired, markHostedLoginExpired, hostedLoginRecovery } from './hosted-auth.mjs';
 import { createManagedProfile, describeProfiles, managedConfigDir, ambientConfigDir, openLoginTerminal, probeUsageLimits } from "./profiles.mjs";
 import { defaultRoots, groupByRepo, preferredCloneRoot, scanRoots, toDeviceRepoReport } from "./repos.mjs";
 import { describeBranchChanges, discardChanges, collectChanges, commitAndPush, copyPrimaryEnvFiles, currentBranch, currentHead, materializeBinding, sessionSlug, worktreePath, ensureCommitExcludes } from "./workspace.mjs";
@@ -184,6 +188,14 @@ export class BridgeDaemon {
 
   async hello() {
     const profiles = await describeProfiles(resolveProfiles(this.config, this.kaiHome), this.usageByProfile);
+    if (this.config.hosted) {
+      for (const profile of resolveProfiles(this.config, this.kaiHome)) {
+        if (hostedLoginExpired(profile, this.kaiHome)) {
+          const report = profiles.find(p => p.id === profile.id);
+          if (report) report.authState = 'signed_out';
+        }
+      }
+    }
     const repos = toDeviceRepoReport(this.repoGroups);
     return this.api.hello({
       name: this.config.device?.name,
@@ -260,9 +272,16 @@ export class BridgeDaemon {
     // machine stayed offline until the next login — silently.
     this.heartbeat = setInterval(() => {
       this.api
-        .heartbeat({ running: [...this.running.keys()] })
+        .heartbeat({ running: [...this.running.keys()], ...(this.config.hosted ? { resources: hostedResources(this) } : {}) })
         .catch((err) => this.onApiError("heartbeat", err));
     }, HEARTBEAT_MS);
+    if (this.config.hosted) {
+      this.hostedTunnel = new HostedTunnel({ config: this.config, api: this.api, log: this.log });
+      this.hostedTunnel.connect();
+      void this.hostedTunnel.register('maintenance', 'machine-browser', 6080).catch(err => this.log('warn', 'hosted.browser', { error: err.message }));
+      const sync = () => void syncHostedRepositories(this).catch(err => this.log('warn', 'hosted.repositories', { error: err.message }));
+      sync(); this.hostedRepoTimer = setInterval(sync, 30_000);
+    }
     // Plan-usage windows for the composer popover. Fire-and-forget on a
     // slow cadence, unref'd (the heartbeat keeps the process alive), and
     // NEVER in hello's path — the probe spawns the CLI (~2s per profile).
@@ -390,6 +409,8 @@ export class BridgeDaemon {
     let changed = false;
     const profiles = resolveProfiles(this.config, this.kaiHome);
     for (const harness of MODEL_PROBE_HARNESSES) {
+      // Model probing must not start a second Codex authentication owner.
+      if (this.config.hosted && harness === 'codex') continue;
       // The user's own ~/.claude / ~/.codex first, then any signed-in
       // managed profile — the catalogue is per account, not per profile.
       const candidates = profiles
@@ -459,6 +480,8 @@ export class BridgeDaemon {
     clearInterval(this.usageTimer);
     clearInterval(this.modelsTimer);
     clearInterval(this.updateTimer);
+    clearInterval(this.hostedRepoTimer);
+    this.hostedTunnel?.close();
     if (this.realtimeRetry) clearTimeout(this.realtimeRetry);
     for (const entry of this.running.values()) entry.ctrl.abort();
     const reports = [];
@@ -782,6 +805,8 @@ export class BridgeDaemon {
         }
         return this.startTurn(data);
       case "bridge.turn.cancel":
+        this.hostedCancelled ??= new Set();
+        this.hostedCancelled.add(data.turnId);
         this.running.get(data.turnId)?.ctrl.abort();
         return;
       case "bridge.turn.steer":
@@ -856,6 +881,7 @@ export class BridgeDaemon {
    * how non-github companions get cloned; `note` survives onto error writes.
    */
   async previewStart({ sessionId, title, repos, companionRemotes = null }) {
+    if (this.config.hosted) { this.hostedPreviewWork ??= new Set(); this.hostedPreviewWork.add(sessionId); }
     let lastNote = null;
     const skipped = [];
     // Every report is also RETURNED: the verify turn boots the preview
@@ -863,7 +889,11 @@ export class BridgeDaemon {
     const report = async (payload) => {
       if (payload.note) lastNote = payload.note;
       const body = payload.status === "error" ? { ...payload, urls: payload.urls ?? [], previews: payload.previews ?? [], ...(lastNote && !payload.note ? { note: lastNote } : {}), ...(skipped.length && !payload.skipped ? { skipped } : {}) } : payload;
-      await this.api.sessionPreview(sessionId, body).catch((err) => this.log("warn", "preview.report.failed", { error: err.message }));
+      if (['running', 'error'].includes(body.status)) this.hostedPreviewWork?.delete(sessionId);
+      const runner = this.services.get(sessionId);
+      const publicPreview = p => this.config.hosted && runner?.publicUrls?.[p.name] ? { ...p, url: runner.publicUrls[p.name], lanUrl: null } : p;
+      const reportBody = this.config.hosted ? { ...body, previews: body.previews?.map(publicPreview), urls: body.urls?.map(publicPreview), landingUrl: body.previews?.[0] ? publicPreview(body.previews[0]).url : body.landingUrl } : body;
+      await this.api.sessionPreview(sessionId, reportBody).catch((err) => this.log("warn", "preview.report.failed", { error: err.message }));
       return body;
     };
     const fail = (err, ctx = {}) => report(toPreviewErrorPayload(err, { ...ctx, skipped }));
@@ -878,7 +908,7 @@ export class BridgeDaemon {
           return fail(new PreviewError(`Repository ${r.key} is not checked out on this device.`, { code: "companion_missing", repo: r.key }), { repo: r.key });
         }
         const mode = r.mode || this.config.repoModes?.[r.key] || "worktree";
-        const cwd = mode === "local" ? group.primary.path : this.findSessionWorktree(group.name, sessionId, title);
+        const cwd = mode === "local" ? group.primary.path : this.findSessionWorktree(this.config.hosted ? group.key : group.name, sessionId, title);
         if (!cwd || !existsSync(cwd)) {
           return fail(new PreviewError(`The workspace for this session is gone on this device — send Kai a message to recreate it, then start the preview again.`, { code: "other", repo: r.key }), { repo: r.key });
         }
@@ -1043,6 +1073,7 @@ export class BridgeDaemon {
   findSessionWorktree(repoName, sessionId, title) {
     const exact = worktreePath(this.kaiHome, repoName, sessionSlug(sessionId, title));
     if (existsSync(exact)) return exact;
+    if (this.config.hosted) return exact;
     const suffix = `-${String(sessionId || "").slice(-8)}`;
     if (suffix.length < 2) return exact;
     try {
@@ -1131,7 +1162,7 @@ export class BridgeDaemon {
       this.previewIdleTimers.delete(sessionId);
       const runner = this.services.get(sessionId);
       if (!runner) return;
-      if (await this.previewHasConnections(runner)) {
+      if (!this.config.hosted && await this.previewHasConnections(runner)) {
         this.log("info", "preview.idle.connected", { sessionId });
         if (this.services.get(sessionId) === runner) this.armPreviewIdleTimer(sessionId);
         return;
@@ -1164,6 +1195,7 @@ export class BridgeDaemon {
   }
 
   async previewStop({ sessionId }) {
+    this.hostedTunnel?.unregisterSession(sessionId);
     this.manualPreviews?.delete(sessionId);
     this.verifyOwnedPreviews?.delete(sessionId);
     // A sign-in window for this session has nothing left to sign in to.
@@ -1181,6 +1213,7 @@ export class BridgeDaemon {
    * dashboard why — with the classified log line.
    */
   onServiceDied(sessionId, info) {
+    this.hostedTunnel?.unregisterSession(sessionId);
     const runner = this.services.get(sessionId);
     if (!runner) return Promise.resolve();
     this.log("warn", "preview.service.died", { sessionId, name: info.name, code: info.code, errorCode: info.errorCode });
@@ -1210,6 +1243,7 @@ export class BridgeDaemon {
       runner = new ServiceRunner({
         kaiHome: this.kaiHome,
         sessionId,
+        ...(this.hostedTunnel ? { registerPublicService: (name, port, protocol) => this.hostedTunnel.register(sessionId, name, port, protocol) } : {}),
         log: this.log,
         onStatus: (message) => {
           this.log("info", "preview.status", { sessionId, message });
@@ -1235,7 +1269,7 @@ export class BridgeDaemon {
       const mode = r.mode || this.config.repoModes?.[r.key] || "worktree";
       const ws = materializeBinding({
         kaiHome: this.kaiHome,
-        repo: { name: group.name, primaryPath: group.primary.path, defaultBranch: group.primary.defaultBranch },
+        repo: { name: this.config.hosted ? group.key : group.name, primaryPath: group.primary.path, defaultBranch: group.primary.defaultBranch },
         binding: { mode, base: r.base, carryUncommitted: r.carryUncommitted },
         sessionId: turn.sessionId,
         title: turn.title,
@@ -1269,7 +1303,7 @@ export class BridgeDaemon {
       );
       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}`);
+        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, this.config.hosted ? g.key : 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})`);
     }
@@ -1286,7 +1320,7 @@ export class BridgeDaemon {
     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);
+      const cwd = worktreePath(this.kaiHome, this.config.hosted ? g.key : g.name, slug);
       if (!existsSync(cwd)) continue;
       const branch = currentBranch(cwd);
       if (!branch || branch === "HEAD") continue;
@@ -1299,6 +1333,8 @@ export class BridgeDaemon {
   async startTurn(turn) {
     const { turnId } = turn;
     if (this.running.has(turnId)) return;
+    if (this.config.hosted && !(await awaitHostedAdmission(this, turn))) return;
+    if (this.running.has(turnId)) return;
     const ctrl = new AbortController();
     const entry = { ctrl, control: null, sessionId: turn.sessionId };
     this.running.set(turnId, entry);
@@ -1313,6 +1349,8 @@ export class BridgeDaemon {
     const batcher = createEventBatcher({ api: this.api, turnId, onError: (err) => this.log("warn", "events.post.failed", { error: err.message }) });
     try {
       const profile = resolveProfiles(this.config, this.kaiHome).find((p) => p.id === turn.profileId) ?? { id: "gleap-key", kind: "gleap-key", harness: turn.harness };
+      if (this.config.hosted && (profile.kind === 'gleap-key' || !['codex', 'claude'].includes(profile.harness))) throw new Error('Choose your signed-in Claude Code or Codex profile for this machine.');
+      if (this.config.hosted && hostedLoginExpired(profile, this.kaiHome)) throw new Error(hostedLoginRecovery(profile.harness));
       const bound = this.bindRepos(turn);
       // Multi-repo: the runner's cwd is the first repo; the others are
       // reachable as siblings under the same worktree root or by their
@@ -1396,6 +1434,11 @@ export class BridgeDaemon {
         onLog: (l) => this.log("debug", "runner", { line: l.slice(0, 500) }),
       });
       await batcher.flush();
+      if (this.config.hosted && res.errorCode === 'authentication_required') {
+        markHostedLoginExpired(profile, this.kaiHome);
+        res.lastError = hostedLoginRecovery(profile.harness);
+        await this.hello().catch(() => {});
+      }
       const completed = !ctrl.signal.aborted && res.code === 0 && !res.rateLimited;
       // Plan and verify turns are read-only: worktrees are restored, local
       // checkouts only reported, nothing is ever committed or pushed.
@@ -1452,6 +1495,7 @@ export class BridgeDaemon {
       outcome = {
         status: ctrl.signal.aborted ? "cancelled" : res.rateLimited ? "rate_limited" : res.code === 0 ? "completed" : "failed",
         exitCode: res.code,
+        ...(res.errorCode ? { errorCode: res.errorCode } : {}),
         result: verify?.redact?.size ? redactDeep(res.result, verify.redact) : res.result,
         // The runner's own failure text (e.g. the engine's usage-limit
         // message) — the Server prefers this over its generic fallback.
@@ -2393,65 +2437,27 @@ export class BridgeDaemon {
    * unattended runs: no credential prompts (`GIT_TERMINAL_PROMPT=0`,
    * `GIT_ASKPASS=echo`), stderr captured for the error, bounded by
    * `timeoutMs` (default 3 min). Resolves the checkout path; throws an Error
-   * carrying `.target` and the stderr tail. As a command handler
+   * carrying `.target` and a diagnostic message. As a command handler
    * (`bridge.repo.clone`) it acks ok/error instead of throwing.
    */
-  async cloneRepo({ commandId, remote, name, timeoutMs = CLONE_TIMEOUT_MS }) {
-    // Prefer the directory the machine's repos already live in (e.g.
-    // ~/Documents/Gleap), not the bare scan root that discovered them
-    // (~/Documents) — "Clone here" should land next to the other checkouts.
+  async cloneRepo({ commandId, remote, name, repoKey, timeoutMs = CLONE_TIMEOUT_MS }) {
     const root = preferredCloneRoot(this.repoGroups, (this.config.roots || [])[0] ?? defaultRoots()[0]);
-    const fail = async (err) => {
+    try {
+      const target = await cloneRepository({ remote, name, root, repoKey, timeoutMs });
+      await this.scanRepos();
+      // Ack only after the Server has the new inventory: recovery checks
+      // readiness before automatically retrying the blocked session.
+      await this.hello();
+      if (commandId) await this.api.commandAck(commandId, { ok: true, path: target });
+      return target;
+    } catch (err) {
+      if (err.target) err.cloneCommand = buildCloneCommand({ remote, target: err.target });
       if (commandId) {
         await this.api.commandAck(commandId, { ok: false, error: err.message, ...(err.cloneCommand ? { cloneCommand: err.cloneCommand } : {}) }).catch(() => {});
         return null;
       }
       throw err;
-    };
-    if (!root) return fail(new Error("No scan root to clone into — add one with `kai-bridge repo roots add <dir>`."));
-    const target = join(root, String(name || "").replace(/[^\w.-]/g, "-") || "repo");
-    if (existsSync(target)) {
-      const err = new Error(`${target} already exists — remove it or point Gleap at it (Locate…).`);
-      err.target = target;
-      return fail(err);
     }
-    try {
-      await new Promise((resolve, reject) => {
-        const p = spawn("git", ["clone", remote, target], {
-          stdio: ["ignore", "ignore", "pipe"],
-          env: { ...process.env, GIT_TERMINAL_PROMPT: "0", GIT_ASKPASS: "echo", SSH_ASKPASS: "echo", GIT_SSH_COMMAND: process.env.GIT_SSH_COMMAND || "ssh -o BatchMode=yes" },
-        });
-        let stderr = "";
-        p.stderr.on("data", (d) => {
-          stderr = `${stderr}${d}`.slice(-4000);
-        });
-        const timer = setTimeout(() => {
-          try {
-            p.kill("SIGTERM");
-          } catch {}
-          reject(Object.assign(new Error(`git clone timed out after ${Math.round(timeoutMs / 60_000)} minutes`), { target, stderr }));
-        }, timeoutMs);
-        p.on("close", (code) => {
-          clearTimeout(timer);
-          if (code === 0) return resolve();
-          const tail = stderr.trim().split("\n").filter(Boolean).slice(-2).join(" · ").slice(0, 300);
-          reject(Object.assign(new Error(`git clone exited ${code}${tail ? ` — ${tail}` : ""}`), { target, stderr, code }));
-        });
-        p.on("error", (err) => {
-          clearTimeout(timer);
-          reject(Object.assign(err, { target }));
-        });
-      });
-    } catch (err) {
-      this.log("error", "repo.clone.failed", { remote, target, error: err.message });
-      rmSync(target, { recursive: true, force: true });
-      err.cloneCommand = buildCloneCommand({ remote, target });
-      return fail(err);
-    }
-    await this.scanRepos();
-    await this.hello().catch(() => {});
-    if (commandId) await this.api.commandAck(commandId, { ok: true, path: target });
-    return target;
   }
 
   /**
@@ -2466,11 +2472,7 @@ export class BridgeDaemon {
    */
   async locateRepo({ commandId, repoKey, path: rawPath }) {
     try {
-      const target = resolvePath(String(rawPath || "").replace(/^~(?=$|\/)/, homedir()));
-      if (!existsSync(target)) throw new Error(`${target} does not exist on this machine.`);
-      if (repoKey && !existsSync(join(target, ".git"))) {
-        throw new Error(`${target} is not a git checkout.`);
-      }
+      const target = locateRepository(rawPath, repoKey);
       const root = repoKey ? dirname(target) : target;
       this.config.roots = [...new Set([...(this.config.roots || []), root])];
       if (repoKey) {

package/src/executor.mjs

@@ -13,8 +13,10 @@ import { delimiter, dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
 
 import { ambientConfigDir, managedConfigDir } from "./profiles.mjs";
-import { harnessAcpCommand } from "./harnesses.mjs";
+import { harnessAcpCommand, harnessBinary } from "./harnesses.mjs";
 import { KAI_HOME } from "./config.mjs";
+import { boundHostedProcess } from './hosted-resources.mjs';
+import { classifyHarnessFailure } from './hosted-auth.mjs';
 
 const RUNNER = join(dirname(fileURLToPath(import.meta.url)), "..", "runner", "acp-runner.mjs");
 const b64 = (v) => Buffer.from(typeof v === "string" ? v : JSON.stringify(v), "utf8").toString("base64");
@@ -77,6 +79,13 @@ export function buildRunnerEnv(turn, profile, kaiHome = KAI_HOME, extraEnv = nul
   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;
+  delete env.KAI_BOOTSTRAP_TOKEN;
+  // Login, version probes and coding must resolve the same release's binaries.
+  // Hosted Codex replaces this path below with its single-owner RPC transport.
+  const native = harnessBinary(profile.harness, kaiHome);
+  if (native && profile.harness === 'claude') { env.CLAUDE_CODE_EXECUTABLE = native; env.DISABLE_AUTOUPDATER = '1'; }
+  if (native && profile.harness === 'codex') env.CODEX_PATH = native;
+  if (process.env.KAI_HOSTED === '1') env.NODE_OPTIONS = '--max-old-space-size=1536';
   // The daemon's own node first on PATH for the runner, the harness and
   // every shell the agent opens. Under launchd PATH is frozen at install
   // time and a stale /usr/local/bin/node (v20 here) beat the nvm node the
@@ -98,6 +107,12 @@ export function buildRunnerEnv(turn, profile, kaiHome = KAI_HOME, extraEnv = nul
       env.KAI_ACP_CONFIG_DIR = join(kaiHome, "state", profile.id, "cursor");
       mkdirSync(env.KAI_ACP_CONFIG_DIR, { recursive: true });
     } else if (profile.harness === "codex") {
+      if (process.env.KAI_HOSTED === '1') {
+        // A single supervised app-server owns login refresh for every hosted
+        // turn. Per-session config travels over RPC, never through config.toml.
+        env.KAI_ACP_CONFIG_DIR = profileDir;
+        env.CODEX_PATH = join(dirname(fileURLToPath(import.meta.url)), 'codex-broker-client.mjs');
+      } else {
       // The runner writes config.toml (MCP servers, kill-switches) into
       // CODEX_HOME — that must never be the user's real ~/.codex. Use a
       // per-profile session dir seeded with a COPY of auth.json (read-only
@@ -107,6 +122,7 @@ export function buildRunnerEnv(turn, profile, kaiHome = KAI_HOME, extraEnv = nul
       const src = join(profileDir, "auth.json");
       if (existsSync(src)) copyFileSync(src, join(sessionDir, "auth.json"));
       env.KAI_ACP_CONFIG_DIR = sessionDir;
+      }
     } else {
       // Claude: CLAUDE_CONFIG_DIR IS the login dir; the runner reads the
       // transcript from it and passes settings via the SDK, never by file.
@@ -143,7 +159,8 @@ export function runTurn({ turn, profile, workDir, onEvent, onLog = () => {}, onS
     // stdin is the runner's control channel (JSONL: steer / cancel) — see
     // startControlChannel in runner/acp-runner.mjs. Never closed from
     // here; the runner exits on its own when the turn ends.
-    const child = spawn(process.execPath, [RUNNER, ...args], { cwd: workDir, env, stdio: ["pipe", "pipe", "pipe"] });
+    const child = spawn(process.execPath, [RUNNER, ...args], { cwd: workDir, env, detached: process.env.KAI_HOSTED === '1', stdio: ["pipe", "pipe", "pipe"] });
+    boundHostedProcess(child, { onExceeded: message => { lastError = message; onEvent({ type: 'error', message, code: 'memory_pressure' }); } });
     child.stdin.on("error", () => {});
     onSpawn?.({
       /** Write one control line; false when the runner is already gone. */
@@ -182,7 +199,8 @@ export function runTurn({ turn, profile, workDir, onEvent, onLog = () => {}, onS
     child.stderr.on("data", (d) => onLog(String(d)));
     const onAbort = () => {
       try {
-        child.kill("SIGTERM");
+        if (process.env.KAI_HOSTED === '1') process.kill(-child.pid, 'SIGTERM');
+        else child.kill("SIGTERM");
       } catch {
         /* gone */
       }
@@ -190,7 +208,7 @@ export function runTurn({ turn, profile, workDir, onEvent, onLog = () => {}, onS
     signal?.addEventListener("abort", onAbort, { once: true });
     child.on("close", (code) => {
       signal?.removeEventListener("abort", onAbort);
-      resolve({ code, result, rateLimited, lastError });
+      resolve({ code, result, rateLimited, lastError, errorCode: classifyHarnessFailure(lastError || '') });
     });
   });
 }