@yolo-labs/yolobridge 0.22.0 → 0.23.0

package/dist/attach-cmd.js

@@ -22,8 +22,8 @@ import { SseFrameParser } from './sse-frame-parser.js';
 import { actionForFrame } from './frame-actions.js';
 import { startHeartbeat, defaultTimers } from './heartbeat.js';
 import { nextBackoffMs, isFatalCredentialRefusal, fatalCredentialRefusalMessage, } from './reconnect.js';
-import { deliverPromptToLocalAgent, captureLocalAgentOutput, onLocalAgentData, takeRawSeed as takeRawSeedFromAgent, primeRawStream as primeRawStreamFromAgent, getLocalAgentGeometry, } from './local-agent.js';
-import { OutputStreamBuffer, DEFAULT_FLUSH_INTERVAL_MS, } from './output-stream.js';
+import { deliverPromptToLocalAgent, captureLocalAgentOutput, onLocalAgentData, takeRawSeed as takeRawSeedFromAgent, primeRawStream as primeRawStreamFromAgent, getLocalAgentGeometry, writeInputToLocalAgent, } from './local-agent.js';
+import { OutputStreamBuffer, DEFAULT_FLUSH_INTERVAL_MS, INTERACTIVE_ECHO_FLUSH_MS, } from './output-stream.js';
 import * as apiClient from './api-client.js';
 import { refreshAccessToken as refreshAccessTokenApi } from './device-auth.js';
 import { loadAuth, saveAuth, loadAttachment, saveAttachment, clearAttachment, } from './config-store.js';
@@ -78,6 +78,7 @@ export async function runAttachDaemon(deps) {
     const log = deps.log ?? ((line) => process.stdout.write(`${line}\n`));
     const clearScreen = deps.clearScreen ?? (() => process.stdout.write('\x1b[2J\x1b[3J\x1b[H'));
     const deliverPrompt = deps.deliverPrompt ?? deliverPromptToLocalAgent;
+    const writeInput = deps.writeInput ?? writeInputToLocalAgent;
     const captureOutput = deps.captureOutput ?? captureLocalAgentOutput;
     const timers = deps.timers ?? defaultTimers;
     const now = deps.now ?? Date.now;
@@ -925,6 +926,27 @@ export async function runAttachDaemon(deps) {
                                 case 'prompt':
                                     await deliverPrompt(action.prompt);
                                     break;
+                                case 'input': {
+                                    // Raw keystrokes from a console client. Written verbatim —
+                                    // no Enter appended, no readiness gate — see
+                                    // `writeInputToLocalAgent`. Nothing logs the bytes.
+                                    writeInput(action.data);
+                                    // The PTY echoes within ~1ms. Without this the echo waits out
+                                    // the 80ms batch window, which buys nothing for a payload
+                                    // this small and spends ~40% of the latency budget that is
+                                    // ours rather than the network's. `flushOutputStream` re-checks
+                                    // that this session is still current, so a stale timer no-ops.
+                                    const echoSession = outputStream;
+                                    if (echoSession) {
+                                        // A plain timer, not `timers`: that seam exists so tests can
+                                        // drive the heartbeat/flush CADENCE, and widening it for a
+                                        // 5ms nudge would touch every existing double. `unref` so a
+                                        // pending echo can never hold the process open at exit.
+                                        const t = setTimeout(() => { void flushOutputStream(echoSession); }, INTERACTIVE_ECHO_FLUSH_MS);
+                                        t.unref?.();
+                                    }
+                                    break;
+                                }
                                 case 'read-output': {
                                     const captured = await captureOutput();
                                     // Taken AFTER the (async) capture and synchronously, so

package/dist/frame-actions.js

@@ -27,6 +27,10 @@ export function actionForFrame(frame) {
             return { kind: 'ping' };
         case 'prompt':
             return { kind: 'prompt', attachmentId: String(data.attachmentId ?? ''), prompt: String(data.prompt ?? '') };
+        case 'input':
+            // No coercion beyond String(): these are the operator's own keystrokes
+            // and anything clever here would corrupt a control sequence.
+            return { kind: 'input', attachmentId: String(data.attachmentId ?? ''), data: String(data.data ?? '') };
         case 'read-output':
             return {
                 kind: 'read-output',

package/dist/local-agent.js

@@ -868,6 +868,38 @@ export function stopLocalAgent() {
         // already dead
     }
 }
+/**
+ * Write raw bytes straight into the PTY, exactly as typed.
+ *
+ * ⚠️ DELIBERATELY NOT `deliverPromptToLocalAgent`. That function is for one
+ * coherent instruction: it waits on a readiness gate, writes the text, pauses,
+ * then writes `\r`. Every one of those is wrong for a keystroke —
+ * a lone `\x03` would get an Enter appended, an arrow-key escape sequence would
+ * be split by the pause, and the readiness gate would block on a prompt that a
+ * mid-session TUI never shows.
+ *
+ * So this does the minimum: if there is a live PTY, write the bytes. No
+ * interpretation, no framing, no Enter.
+ *
+ * ⚠️ NOTHING HERE LOGS `data`. These are the operator's keystrokes on their own
+ * machine — the same rule the output path already follows, and the reason a
+ * console session logs that it opened and closed and never what was typed.
+ *
+ * Returns false when there is no agent to write to, so a caller can say
+ * "nothing is attached" rather than silently swallowing input.
+ */
+export function writeInputToLocalAgent(data) {
+    if (!current || !data)
+        return false;
+    try {
+        current.ptyProcess.write(data);
+        return true;
+    }
+    catch {
+        // The child is gone; onExit will clear `current`.
+        return false;
+    }
+}
 /**
  * Best-effort readiness check before `deliverPromptToLocalAgent` writes
  * into the PTY — docs/YOLOBRIDGE_PLAN.md's "[P1] Blind prompt delivery can

package/dist/output-stream.js

@@ -42,6 +42,21 @@
  *  output reads as live, long enough that a chatty PTY costs ~12 POSTs/second
  *  rather than one per `onData`. */
 export const DEFAULT_FLUSH_INTERVAL_MS = 80;
+/**
+ * Flush delay after a console keystroke, rather than waiting out the batch
+ * window.
+ *
+ * The 80ms above is right for a passive VIEWER: it trades a little liveness for
+ * ~12 POSTs/second instead of one per `onData`. It is wrong for an interactive
+ * session, where a single echoed keystroke IS the entire payload and the batch
+ * saves nothing while costing up to 80ms of a round trip already near 200ms —
+ * measured 2026-08-28, and roughly 40% of the budget that is ours to spend
+ * rather than the network's.
+ *
+ * 5ms is long enough that a burst of keystrokes still coalesces into one POST,
+ * short enough to be invisible next to the ~160ms the network costs.
+ */
+export const INTERACTIVE_ECHO_FLUSH_MS = 5;
 /** ~192 KiB/s sustained. Comfortably above a fast agent's real output rate
  *  (a streaming LLM response is a few KiB/s), far below what `cat`ting a
  *  large file would produce. */

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolo-labs/yolobridge",
-  "version": "0.22.0",
+  "version": "0.23.0",
   "description": "YoloBridge — local coding-agent daemon that attaches a user's own Claude Code/Codex session to a YOLO Studio workspace as a first-class tile (docs/YOLOBRIDGE_PLAN.md, build-order Phase 5).",
   "license": "MIT",
   "type": "module",