@gleapai/kai-bridge 0.2.0

package/src/executor.mjs

@@ -0,0 +1,156 @@
+// Runs ONE Kai Code turn on this device with the bundled ACP runner — the
+// same driver the cloud sandbox uses (runner/acp-runner.mjs), pointed at
+// the user's harness login instead of Gleap's keys.
+//
+// Input = the Server's `turn.start` payload (mirrors AgentRunOpts on the
+// analyzer host); output = the contract JSONL events, delivered through
+// `onEvent` as they stream, plus the final `result`.
+
+import { spawn } from "node:child_process";
+import { copyFileSync, existsSync, mkdirSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { dirname, join } from "node:path";
+import { fileURLToPath } from "node:url";
+
+import { ambientConfigDir, managedConfigDir } from "./profiles.mjs";
+import { harnessAcpCommand } from "./harnesses.mjs";
+import { KAI_HOME } from "./config.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");
+
+/** turn.start payload → runner argv (no shell — we spawn node directly). */
+export function buildRunnerArgs(turn, workDir) {
+  const args = ["--task-b64", b64(turn.task || ""), "--work-dir", workDir];
+  // The Server's coder payload signals plan mode as `planMode`, not as an
+  // agent name (the analyzer host does this same mapping before spawning
+  // its runner). Without it, a device Plan turn silently ran as build:
+  // full write permissions, no plan artifact, no "Implement this plan?".
+  const agent = turn.agent ?? (turn.planMode ? "kai-planner" : undefined);
+  if (agent) args.push("--agent", agent);
+  if (turn.model) args.push("--model", turn.model);
+  if (turn.engineModelSlug) args.push("--engine-model", turn.engineModelSlug);
+  if (turn.subagentModel) args.push("--subagent-model", turn.subagentModel);
+  if (turn.effort) args.push("--effort", turn.effort);
+  // ACP resume id when the server split it out (acpSessionId); the
+  // canonical session id otherwise (turn 1 — the runner treats it as a
+  // hint and mints its own ACP id).
+  if (turn.acpSessionId || turn.sessionId) args.push("--session-id", turn.acpSessionId || turn.sessionId);
+  if (turn.harness) args.push("--harness", turn.harness);
+  if (turn.maxSteps > 0) args.push("--max-steps", String(Math.floor(turn.maxSteps)));
+  if (turn.maxBudgetUsd > 0) args.push("--max-budget-usd", String(turn.maxBudgetUsd));
+  if (turn.feedback) args.push("--feedback-b64", b64(turn.feedback));
+  if (turn.questionAnswers?.length) args.push("--answers-b64", b64(turn.questionAnswers));
+  if (turn.attachments?.length) args.push("--attachments-b64", b64(turn.attachments));
+  if (turn.mcpServers?.length) args.push("--mcp-config-b64", b64(turn.mcpServers));
+  if (turn.customInstructions?.trim()) args.push("--system-prompt-b64", b64(turn.customInstructions));
+  if (turn.modelPricing && Object.keys(turn.modelPricing).length) args.push("--model-pricing-b64", b64(turn.modelPricing));
+  if (turn.providerOrders && Object.keys(turn.providerOrders).length) args.push("--provider-orders-b64", b64(turn.providerOrders));
+  if (turn.modelLimits?.contextWindow) args.push("--max-context-tokens", String(turn.modelLimits.contextWindow));
+  if (turn.modelLimits?.maxOutputTokens) args.push("--max-output-tokens", String(turn.modelLimits.maxOutputTokens));
+  if (turn.backgroundModel) args.push("--background-model", turn.backgroundModel);
+  return args;
+}
+
+/**
+ * Env for the runner given the profile:
+ *   ambient/managed → the harness's own login dir; the runner's
+ *   `KAI_ACP_STATE_DIR` is redirected so CLAUDE_CONFIG_DIR/CODEX_HOME
+ *   point at the PROFILE (that's where the login lives), and the
+ *   transcript is read from there too.
+ *   gleap-key → keys handed over in `turn.credentials`, isolated state dir.
+ */
+export function buildRunnerEnv(turn, profile, kaiHome = KAI_HOME) {
+  const env = { ...process.env, KAI_RUNNER_DEBUG: process.env.KAI_RUNNER_DEBUG || "0", KAI_PERSONA_DIR: join(dirname(RUNNER), "personas") };
+  // Never leak the Gleap device token into the harness.
+  delete env.KAI_DEVICE_TOKEN;
+  if (profile.kind === "gleap-key") {
+    env.KAI_ACP_STATE_DIR = join(kaiHome, "state", "gleap-key");
+    for (const [k, v] of Object.entries(turn.credentials || {})) env[k] = String(v);
+  } else {
+    const profileDir = profile.kind === "managed" ? managedConfigDir(profile.harness, profile.id, kaiHome) : ambientConfigDir(profile.harness);
+    env.KAI_ACP_STATE_DIR = join(kaiHome, "state", profile.id);
+    if (profile.harness === "cursor") {
+      // Cursor keeps its login in ~/.cursor with no per-profile dir; the
+      // runner only needs a scratch state dir.
+      env.KAI_ACP_CONFIG_DIR = join(kaiHome, "state", profile.id, "cursor");
+      mkdirSync(env.KAI_ACP_CONFIG_DIR, { recursive: true });
+    } else if (profile.harness === "codex") {
+      // 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
+      // reuse of the ChatGPT login; never written back).
+      const sessionDir = join(kaiHome, "state", profile.id, "codex");
+      mkdirSync(sessionDir, { recursive: true });
+      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.
+      // Ambient = the CLI's own default dir, where macOS keeps OAuth in
+      // the keychain ONLY while CLAUDE_CONFIG_DIR stays unset — so the
+      // runner is told to inherit the env rather than export the dir.
+      env.KAI_ACP_CONFIG_DIR = profileDir;
+      if (profile.kind !== "managed") env.KAI_ACP_CONFIG_DIR_AMBIENT = "1";
+    }
+    // BYO login: the runner must not require Gleap keys.
+    env.KAI_ACP_BYO_LOGIN = "1";
+    delete env.ANTHROPIC_API_KEY;
+    delete env.OPENAI_API_KEY;
+    delete env.OPENROUTER_API_KEY;
+  }
+  // The ACP adapter for this harness: bundled bins for claude/codex, the
+  // bridge-installed Cursor Agent by path (never the vendor symlink).
+  // Precedence: explicit test/dev override (env) → turn → harness registry.
+  const acp = process.env.KAI_ACP_AGENT_CMD ? null : turn.agentCommand || harnessAcpCommand(profile.harness, kaiHome);
+  if (acp) env.KAI_ACP_AGENT_CMD = JSON.stringify(acp);
+  return env;
+}
+
+/**
+ * Execute a turn. Resolves `{ code, result, rateLimited }`; events stream
+ * through `onEvent(event)`. `signal` cancels (SIGTERM to the runner).
+ */
+export function runTurn({ turn, profile, workDir, onEvent, onLog = () => {}, signal, kaiHome = KAI_HOME }) {
+  return new Promise((resolve) => {
+    const args = buildRunnerArgs(turn, workDir);
+    const env = buildRunnerEnv(turn, profile, kaiHome);
+    const child = spawn(process.execPath, [RUNNER, ...args], { cwd: workDir, env, stdio: ["ignore", "pipe", "pipe"] });
+    let result = null;
+    let rateLimited = false;
+    let lastError = null;
+    const rl = createInterface({ input: child.stdout });
+    rl.on("line", (line) => {
+      const t = line.trim();
+      if (!t) return;
+      let ev;
+      try {
+        ev = JSON.parse(t);
+      } catch {
+        return;
+      }
+      if (ev?.type === "result") result = ev;
+      if (ev?.type === "error") {
+        // Keep the most recent human-readable failure so the daemon can
+        // report WHY instead of a generic "turn failed".
+        lastError = String(ev.message || "");
+        if (/rate.?limit|429|usage limit|out of (extra )?usage/i.test(lastError)) rateLimited = true;
+      }
+      onEvent(ev);
+    });
+    child.stderr.on("data", (d) => onLog(String(d)));
+    const onAbort = () => {
+      try {
+        child.kill("SIGTERM");
+      } catch {
+        /* gone */
+      }
+    };
+    signal?.addEventListener("abort", onAbort, { once: true });
+    child.on("close", (code) => {
+      signal?.removeEventListener("abort", onAbort);
+      resolve({ code, result, rateLimited, lastError });
+    });
+  });
+}

package/src/harnesses.mjs

@@ -0,0 +1,252 @@
+// Harness registry: which coding agents this device can run, how to find
+// their binaries, install/update them, probe their login, and open a
+// login.
+//
+//   claude — Claude Code. BUNDLED: the ACP adapter ships the Agent SDK,
+//            which ships the CLI. Nothing to install; only a login.
+//   codex  — Codex CLI. BUNDLED by codex-acp. Only a login.
+//   cursor — Cursor Agent CLI. NOT bundled (no npm package); installed by
+//            the bridge from Cursor's release tarball into
+//            ~/.kai/harnesses/cursor/<version>/ and called by path — never
+//            via the vendor's ~/.local/bin/agent symlink (other vendors
+//            use that name too: Grok's CLI on at least one dev machine).
+//
+// "Installed" therefore means: claude/codex always; cursor when the
+// tarball is present. "Signed in" is per profile (see profiles.mjs).
+
+import { execFileSync, spawn } from "node:child_process";
+import { chmodSync, existsSync, mkdirSync, readdirSync, readFileSync, renameSync, rmSync, symlinkSync, unlinkSync, writeFileSync } from "node:fs";
+import { arch, homedir, platform } from "node:os";
+import { dirname, join, resolve as resolvePath } from "node:path";
+import { fileURLToPath } from "node:url";
+
+const PKG = join(dirname(fileURLToPath(import.meta.url)), "..");
+const PKG_BIN = join(PKG, "node_modules", ".bin");
+
+export const HARNESS_IDS = ["claude", "codex", "cursor"];
+
+export const HARNESS_INFO = {
+  claude: {
+    id: "claude",
+    label: "Claude Code",
+    vendor: "Anthropic",
+    bundled: true,
+    accountHint: "Claude Pro / Max, Team, or an Anthropic API key",
+    loginHint: "Sign in with your Claude account — a browser window opens.",
+    docsUrl: "https://code.claude.com/docs",
+  },
+  codex: {
+    id: "codex",
+    label: "Codex",
+    vendor: "OpenAI",
+    bundled: true,
+    accountHint: "ChatGPT Plus / Pro / Team, or an OpenAI API key",
+    loginHint: "Sign in with your ChatGPT account — a browser window opens.",
+    docsUrl: "https://developers.openai.com/codex/cli",
+  },
+  cursor: {
+    id: "cursor",
+    label: "Cursor",
+    vendor: "Cursor",
+    bundled: false,
+    accountHint: "Cursor subscription (or CURSOR_API_KEY)",
+    loginHint: "Sign in with your Cursor account — a browser window opens.",
+    docsUrl: "https://cursor.com/docs/cli",
+    /** Local-only: Gleap has no Cursor credentials, so the cloud never offers it. */
+    localOnly: true,
+  },
+};
+
+const CURSOR_ROOT = (kaiHome) => join(kaiHome, "harnesses", "cursor");
+const CURSOR_CURRENT = (kaiHome) => join(CURSOR_ROOT(kaiHome), "current");
+/** Version + channel published by Cursor's install script (https://cursor.com/install). */
+export const CURSOR_AGENT_VERSION = process.env.KAI_CURSOR_AGENT_VERSION || "2026.08.11-e8db854";
+
+function cursorPlatform() {
+  const os = platform() === "darwin" ? "darwin" : platform() === "win32" ? "windows" : "linux";
+  const a = arch() === "arm64" ? "arm64" : "x64";
+  return { os, arch: a };
+}
+
+export function cursorDownloadUrl(version = CURSOR_AGENT_VERSION) {
+  const { os, arch: a } = cursorPlatform();
+  return `https://downloads.cursor.com/lab/${version}/${os}/${a}/agent-cli-package.tar.gz`;
+}
+
+/** Bundled / installed binary for a harness, or null. */
+export function harnessBinary(harness, kaiHome = join(homedir(), ".kai")) {
+  if (harness === "claude") {
+    const pkgDir = join(PKG, "node_modules", "@anthropic-ai");
+    try {
+      const plat = readdirSync(pkgDir).find((d) => d.startsWith("claude-agent-sdk-") && d !== "claude-agent-sdk");
+      if (plat) {
+        const bin = join(pkgDir, plat, platform() === "win32" ? "claude.exe" : "claude");
+        if (existsSync(bin)) return bin;
+      }
+    } catch {
+      /* not installed */
+    }
+    return null;
+  }
+  if (harness === "codex") {
+    const bin = join(PKG_BIN, platform() === "win32" ? "codex.cmd" : "codex");
+    return existsSync(bin) ? bin : null;
+  }
+  if (harness === "cursor") {
+    const bin = join(CURSOR_CURRENT(kaiHome), "dist-package", platform() === "win32" ? "cursor-agent.exe" : "cursor-agent");
+    return existsSync(bin) ? bin : null;
+  }
+  return null;
+}
+
+/** The ACP adapter command the runner should spawn for a harness. */
+export function harnessAcpCommand(harness, kaiHome) {
+  if (harness === "claude") return { cmd: join(PKG_BIN, "claude-agent-acp"), args: [] };
+  if (harness === "codex") return { cmd: join(PKG_BIN, "codex-acp"), args: [] };
+  if (harness === "cursor") {
+    const bin = harnessBinary("cursor", kaiHome);
+    return bin ? { cmd: bin, args: ["acp"] } : null;
+  }
+  return null;
+}
+
+function versionOf(bin, args = ["--version"]) {
+  try {
+    return execFileSync(bin, args, { encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 15000 }).trim().split(/\r?\n/)[0] || null;
+  } catch {
+    return null;
+  }
+}
+
+/** Install / version state per harness (login state is per profile). */
+export function describeHarnesses(kaiHome) {
+  return HARNESS_IDS.map((id) => {
+    const bin = harnessBinary(id, kaiHome);
+    return {
+      id,
+      label: HARNESS_INFO[id].label,
+      bundled: HARNESS_INFO[id].bundled,
+      localOnly: !!HARNESS_INFO[id].localOnly,
+      installed: !!bin,
+      version: bin ? versionOf(bin) : null,
+      binary: bin,
+    };
+  });
+}
+
+/**
+ * Install (or update) a harness. Bundled ones are no-ops. Cursor:
+ * download the release tarball for this platform into
+ * ~/.kai/harnesses/cursor/<version>/ and point `current` at it.
+ * `onLog(line)` receives progress; resolves `{ ok, version, binary }`.
+ */
+export async function installHarness(harness, { kaiHome, onLog = () => {}, version = CURSOR_AGENT_VERSION } = {}) {
+  if (!HARNESS_IDS.includes(harness)) throw new Error(`unknown harness ${harness}`);
+  if (HARNESS_INFO[harness].bundled) {
+    const bin = harnessBinary(harness, kaiHome);
+    onLog(`${HARNESS_INFO[harness].label} is bundled with the bridge (${bin ? versionOf(bin) : "missing — run npm install"})`);
+    return { ok: !!bin, version: bin ? versionOf(bin) : null, binary: bin };
+  }
+  const root = CURSOR_ROOT(kaiHome);
+  const target = join(root, version);
+  const tmp = join(root, `.tmp-${version}-${process.pid}`);
+  mkdirSync(root, { recursive: true });
+  if (!existsSync(join(target, "dist-package", "cursor-agent"))) {
+    rmSync(tmp, { recursive: true, force: true });
+    mkdirSync(tmp, { recursive: true });
+    const url = cursorDownloadUrl(version);
+    onLog(`Downloading Cursor Agent ${version} (${url})`);
+    const res = await fetch(url, { signal: AbortSignal.timeout(300_000) });
+    if (!res.ok) throw new Error(`download failed: HTTP ${res.status}`);
+    const buf = Buffer.from(await res.arrayBuffer());
+    const tarPath = join(tmp, "agent-cli-package.tar.gz");
+    writeFileSync(tarPath, buf);
+    onLog(`Extracting ${(buf.length / 1e6).toFixed(1)} MB`);
+    execFileSync("tar", ["-xzf", tarPath, "-C", tmp], { stdio: "ignore" });
+    unlinkSync(tarPath);
+    rmSync(target, { recursive: true, force: true });
+    renameSync(tmp, target);
+    try {
+      chmodSync(join(target, "dist-package", "cursor-agent"), 0o755);
+    } catch {
+      /* windows */
+    }
+  }
+  const current = CURSOR_CURRENT(kaiHome);
+  try {
+    unlinkSync(current);
+  } catch {
+    /* none yet */
+  }
+  symlinkSync(target, current, "dir");
+  const bin = harnessBinary("cursor", kaiHome);
+  const v = bin ? versionOf(bin) : null;
+  onLog(`Cursor Agent ready: ${v}`);
+  return { ok: !!bin, version: v, binary: bin };
+}
+
+/** Interactive login command for a harness under a profile's config dir. */
+export function harnessLoginCommand(harness, configDir, kaiHome) {
+  const bin = harnessBinary(harness, kaiHome);
+  if (!bin) return null;
+  if (harness === "claude") {
+    const claudeDefault = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+    // Ambient login must land in the keychain (env untouched) so the
+    // equally-untouched probe and turns find it; managed dirs are exported.
+    const env = resolvePath(configDir) !== resolvePath(claudeDefault) ? { CLAUDE_CONFIG_DIR: configDir } : {};
+    return { cmd: bin, args: ["login"], env };
+  }
+  if (harness === "codex") return { cmd: bin, args: ["login"], env: { CODEX_HOME: configDir } };
+  return { cmd: bin, args: ["login"], env: {} };
+}
+
+/** Auth probe per harness; returns { state, account? }. */
+export function probeHarnessAuth(harness, configDir, kaiHome) {
+  const bin = harnessBinary(harness, kaiHome);
+  if (!bin) return { state: "missing_binary" };
+  // Claude keeps OAuth in the macOS keychain ONLY while CLAUDE_CONFIG_DIR
+  // is unset — exporting it (even set to the default ~/.claude) flips the
+  // CLI to file-based credentials and a real login probes as signed-out.
+  // So the ambient dir inherits the environment untouched; only managed
+  // profile dirs are exported. Codex/Cursor are file-based — always safe.
+  const claudeDefault = process.env.CLAUDE_CONFIG_DIR || join(homedir(), ".claude");
+  const claudeOverride = harness === "claude" && resolvePath(configDir) !== resolvePath(claudeDefault);
+  const env = { ...process.env, ...(claudeOverride ? { CLAUDE_CONFIG_DIR: configDir } : harness === "codex" ? { CODEX_HOME: configDir } : {}) };
+  try {
+    if (harness === "claude") {
+      const out = execFileSync(bin, ["auth", "status"], { env, encoding: "utf8", stdio: ["ignore", "pipe", "ignore"], timeout: 15000 });
+      let account;
+      try {
+        const parsed = JSON.parse(out);
+        if (parsed?.loggedIn === false) return { state: "signed_out" };
+        account = parsed?.email ?? parsed?.account?.email;
+      } catch {
+        account = /([\w.+-]+@[\w.-]+\.\w+)/.exec(out)?.[1];
+      }
+      return { state: "signed_in", account };
+    }
+    if (harness === "codex") {
+      const auth = JSON.parse(readFileSync(join(configDir, "auth.json"), "utf8"));
+      const signedIn = !!(auth?.tokens?.access_token || auth?.OPENAI_API_KEY);
+      return { state: signedIn ? "signed_in" : "signed_out", account: auth?.tokens?.account_id ? "ChatGPT" : auth?.OPENAI_API_KEY ? "API key" : undefined };
+    }
+    if (harness === "cursor") {
+      if (process.env.CURSOR_API_KEY) return { state: "signed_in", account: "API key" };
+      const out = execFileSync(bin, ["status"], { env, encoding: "utf8", stdio: ["ignore", "pipe", "pipe"], timeout: 20000 });
+      if (/not logged in/i.test(out)) return { state: "signed_out" };
+      const account = /([\w.+-]+@[\w.-]+\.\w+)/.exec(out)?.[1];
+      return { state: "signed_in", account };
+    }
+  } catch (err) {
+    // `claude auth status` exits 1 when signed out; codex without auth.json.
+    return { state: "signed_out" };
+  }
+  return { state: "unknown" };
+}
+
+/** Spawn a detached process that keeps running after the CLI exits (installer helper). */
+export function spawnDetached(cmd, args, opts = {}) {
+  const child = spawn(cmd, args, { stdio: "ignore", detached: true, ...opts });
+  child.unref();
+  return child;
+}