@gleapai/kai-bridge 0.2.8 → 0.2.9

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@gleapai/kai-bridge",
-  "version": "0.2.8",
+  "version": "0.2.9",
   "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/runner/acp-runner.mjs

@@ -21,6 +21,7 @@ import { existsSync, mkdirSync, readFileSync, readdirSync, statSync, writeFileSy
 import { tmpdir } from "node:os";
 import { dirname, join } from "node:path";
 import { fileURLToPath } from "node:url";
+import { createInterface } from "node:readline";
 import { Readable, Writable } from "node:stream";
 
 import { ClientSideConnection, ndJsonStream } from "@agentclientprotocol/sdk";
@@ -342,6 +343,75 @@ function buildDisallowedTools() {
 }
 
 // ── Main ──────────────────────────────────────────────────────────────
+/**
+ * Host → runner control channel: JSONL on OUR stdin (the ACP transport is
+ * the adapter child's stdio, so process.stdin is free). The bridge daemon
+ * pipes it directly; the cloud host reaches it through the E2B API
+ * (`commands.sendStdin`). Old hosts spawn us with stdin ignored/closed —
+ * readline just closes and nothing else changes.
+ *
+ *   {type:"steer", id, text}  → `_session/steering` into the running turn.
+ *                                Answered on stdout with
+ *                                {type:"steer", id, outcome} where outcome is
+ *                                "injected" or a non-injected reason
+ *                                ("promptRequired" | "startedNewTurn" |
+ *                                "unsupported" | "failed"). Anything but
+ *                                "injected" tells the host to queue the
+ *                                message for the next turn instead.
+ *   {type:"cancel"}           → graceful ACP `session/cancel` (turn ends,
+ *                                session stays resumable).
+ */
+function startControlChannel({ isInFlight, steeringSupported, steer, cancel }) {
+  const stdin = process.stdin;
+  if (!stdin || typeof stdin.on !== "function") return;
+  stdin.on("error", () => {});
+  let rl;
+  try {
+    rl = createInterface({ input: stdin, terminal: false });
+  } catch {
+    return;
+  }
+  rl.on("line", (line) => {
+    let cmd;
+    try {
+      cmd = JSON.parse(line);
+    } catch {
+      return;
+    }
+    if (!cmd || typeof cmd !== "object") return;
+    if (cmd.type === "steer") {
+      const id = String(cmd.id || "");
+      const text = typeof cmd.text === "string" ? cmd.text.trim() : "";
+      const reply = (outcome, extra = {}) => emit({ type: "steer", id, outcome, ...extra });
+      if (!id || !text) return;
+      if (!steeringSupported) return reply("unsupported");
+      if (!isInFlight()) return reply("promptRequired");
+      traceLog("steer.inject", { id, chars: text.length });
+      Promise.resolve()
+        .then(() => steer(text))
+        .then((res) => {
+          const outcome = res?.outcome === "injected" ? "injected" : String(res?.outcome || "failed");
+          traceLog("steer.outcome", { id, outcome });
+          reply(outcome);
+        })
+        .catch((err) => {
+          traceLog("steer.failed", { id, error: String(err?.message ?? err) });
+          reply("failed", { error: String(err?.message ?? err).slice(0, 500) });
+        });
+      return;
+    }
+    if (cmd.type === "cancel") {
+      traceLog("control.cancel", {});
+      Promise.resolve()
+        .then(() => cancel())
+        .catch((err) => traceLog("control.cancel.failed", { error: String(err?.message ?? err) }));
+    }
+  });
+  rl.on("close", () => {
+    /* host closed stdin — control channel gone, turn continues */
+  });
+}
+
 async function main() {
   // One config dir per harness (NOT per session): the agent mints the
   // session id on turn 1, and the resume turn must find the same
@@ -531,6 +601,13 @@ async function main() {
     clientInfo: { name: "kai-acp-runner", version: "0.1.0" },
   });
   traceLog("initialized", { agent: init.agentInfo, auth: (init.authMethods || []).map((m) => m.id) });
+  // Steering: both adapters (claude-agent-acp ≥0.73, codex-acp ≥1.8)
+  // implement the `_session/steering` extension request and advertise it
+  // here. The host learns about it via `run_info` and routes a mid-turn
+  // message to us over stdin (see startControlChannel) or, without it,
+  // parks the message on the session's queue for the next turn.
+  const steeringSupported = init?._meta?.steering?.supported === true;
+  emit({ type: "run_info", steeringSupported });
 
   // API-key auth where the adapter asks for it (codex-acp advertises
   // `api-key`; claude-agent-acp needs nothing with the key in env).
@@ -579,6 +656,17 @@ async function main() {
   acpSessionId = sessionResponse.sessionId ?? (resumed ? SESSION_ID : null);
   ctx.sessionId = acpSessionId;
   traceLog("session", { sessionId: acpSessionId, resumed });
+  startControlChannel({
+    isInFlight: () => inFlight,
+    steeringSupported,
+    steer: (text) =>
+      conn.extMethod("_session/steering", {
+        sessionId: acpSessionId,
+        prompt: [{ type: "text", text }],
+        _meta: { steering: { idleBehavior: "promptRequired" } },
+      }),
+    cancel: () => conn.cancel({ sessionId: acpSessionId }),
+  });
 
   // Permission mode via ACP (`session/set_mode`). claude-agent-acp ignores
   // `options.permissionMode` (it re-applies its own default after our

package/src/daemon.mjs

@@ -6,6 +6,8 @@
 // protocol, the same channel family the dashboard uses):
 //   bridge.turn.start   { commandId, turnId, sessionId, profileId, repos:[{key, mode, base, carryUncommitted}], ...AgentRunOpts }
 //   bridge.turn.cancel  { turnId }
+//   bridge.turn.steer   { turnId, steer: { id, text } }   — inject into the running turn;
+//                        answered with a {type:"steer", id, outcome} turn event
 //   bridge.repo.clone   { commandId, remote, name }
 //   bridge.profile.login{ commandId, profileId }
 //   bridge.rescan       {}
@@ -112,7 +114,7 @@ export class BridgeDaemon {
     this.log = log;
     this.api = new BridgeApi({ apiBase: config.apiBase, token: config.device?.token });
     this.realtimeFactory = realtimeFactory;
-    this.running = new Map(); // turnId → AbortController
+    this.running = new Map(); // turnId → { ctrl: AbortController, control?: (obj) => boolean }
     this.services = new Map(); // sessionId → ServiceRunner (lives across turns)
     this.repoGroups = [];
     this.usageByProfile = new Map(); // profileId → plan-usage snapshot (claude only)
@@ -377,7 +379,7 @@ export class BridgeDaemon {
     clearInterval(this.modelsTimer);
     clearInterval(this.updateTimer);
     if (this.realtimeRetry) clearTimeout(this.realtimeRetry);
-    for (const ctrl of this.running.values()) ctrl.abort();
+    for (const entry of this.running.values()) entry.ctrl.abort();
     for (const runner of this.services.values()) runner.stopAll();
     this.realtime?.disconnect?.();
     this.releaseLock();
@@ -591,8 +593,10 @@ export class BridgeDaemon {
         }
         return this.startTurn(data);
       case "bridge.turn.cancel":
-        this.running.get(data.turnId)?.abort();
+        this.running.get(data.turnId)?.ctrl.abort();
         return;
+      case "bridge.turn.steer":
+        return this.steerTurn(data);
       case "bridge.rescan":
         await this.scanRepos();
         // A rescan is the user's "look again" — refresh the model lists too
@@ -897,7 +901,8 @@ export class BridgeDaemon {
     const { turnId } = turn;
     if (this.running.has(turnId)) return;
     const ctrl = new AbortController();
-    this.running.set(turnId, ctrl);
+    const entry = { ctrl, control: null };
+    this.running.set(turnId, entry);
     const releaseAwake = keepAwake();
     let outcome = null;
     this.rememberInflight(turnId);
@@ -923,6 +928,9 @@ export class BridgeDaemon {
         workDir,
         kaiHome: this.kaiHome,
         signal: ctrl.signal,
+        onSpawn: (handle) => {
+          entry.control = handle.control;
+        },
         onEvent: (ev) => batcher.push(ev),
         onLog: (l) => this.log("debug", "runner", { line: l.slice(0, 500) }),
       });
@@ -999,6 +1007,28 @@ export class BridgeDaemon {
     }
   }
 
+  /**
+   * Mid-turn steering: forward the message to the running runner's stdin
+   * control channel. The runner answers with a `steer` turn event
+   * (outcome injected / promptRequired / …) that rides the normal event
+   * batcher. When the turn is not running here (already ended, never
+   * started, laptop was asleep) we answer `promptRequired` ourselves so
+   * the Server queues the message for the next turn instead of waiting
+   * for its timeout.
+   */
+  async steerTurn({ turnId, steer }) {
+    const id = String(steer?.id || "");
+    const text = typeof steer?.text === "string" ? steer.text : "";
+    if (!turnId || !id || !text.trim()) return;
+    const entry = this.running.get(turnId);
+    const delivered = entry?.control ? entry.control({ type: "steer", id, text }) : false;
+    this.log("info", delivered ? "turn.steer" : "turn.steer.miss", { turnId, id, running: !!entry });
+    if (delivered) return;
+    await this.api
+      .turnEvents(turnId, [{ type: "steer", id, outcome: "promptRequired" }])
+      .catch((err) => this.log("warn", "turn.steer.report.failed", { turnId, id, error: err?.message }));
+  }
+
   /**
    * Turn-path preview policy: previews start MANUALLY only. A turn never
    * boots dev servers — that surprised people ("Kai always starts a

package/src/executor.mjs

@@ -121,12 +121,30 @@ export function buildRunnerEnv(turn, profile, kaiHome = KAI_HOME) {
 /**
  * Execute a turn. Resolves `{ code, result, rateLimited }`; events stream
  * through `onEvent(event)`. `signal` cancels (SIGTERM to the runner).
+ * `onSpawn(handle)` hands out `handle.control(obj)` for the runner's stdin
+ * control channel (mid-turn steering).
  */
-export function runTurn({ turn, profile, workDir, onEvent, onLog = () => {}, signal, kaiHome = KAI_HOME }) {
+export function runTurn({ turn, profile, workDir, onEvent, onLog = () => {}, onSpawn, signal, kaiHome = KAI_HOME }) {
   return new Promise((resolve) => {
     const args = buildRunnerArgs(turn, workDir, profile);
     const env = buildRunnerEnv(turn, profile, kaiHome);
-    const child = spawn(process.execPath, [RUNNER, ...args], { cwd: workDir, env, stdio: ["ignore", "pipe", "pipe"] });
+    // 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"] });
+    child.stdin.on("error", () => {});
+    onSpawn?.({
+      /** Write one control line; false when the runner is already gone. */
+      control(obj) {
+        if (child.exitCode !== null || child.killed || !child.stdin.writable) return false;
+        try {
+          child.stdin.write(JSON.stringify(obj) + "\n");
+          return true;
+        } catch {
+          return false;
+        }
+      },
+    });
     let result = null;
     let rateLimited = false;
     let lastError = null;