@yolo-labs/yolobridge 0.21.0 → 0.22.0

package/dist/cli.js

@@ -443,6 +443,10 @@ async function cmdAttach(args) {
                 // real `onExit` handler below: stop + detach immediately rather than
                 // let the daemon loop ride out the full heartbeat-staleness window.
                 try {
+                    // Say where Ctrl+C goes BEFORE the agent takes over the screen.
+                    // Without this the operator presses it expecting to quit, nothing
+                    // happens, and there is no way to discover why.
+                    process.stdout.write('yolo-bridge: Ctrl+C goes to the agent · Ctrl-P Ctrl-Q to detach\n');
                     startLocalAgent({
                         agentBin,
                         // Empty unless the MCP block above successfully resolved argv
@@ -451,6 +455,15 @@ async function cmdAttach(args) {
                         // never a launch carrying a flag the binary would reject.
                         agentArgs: agentMcpArgs,
                         cwd: spawnCwd,
+                        // The daemon's only reachable stop key. `process.on('SIGINT')`
+                        // above cannot fire from the keyboard: stdin is in raw mode so the
+                        // tty never turns Ctrl+C into a signal, and Ctrl+C is deliberately
+                        // forwarded to the AGENT instead (interrupting a runaway agent is
+                        // worth more than quitting the daemon). Same teardown either way.
+                        onDetachRequested: () => {
+                            process.stdout.write('\nyolo-bridge: detaching...\n');
+                            onSignal();
+                        },
                         onExit: ({ exitCode, signal }) => {
                             localAgentExited = true;
                             stopRequested = true;

package/dist/detach-sequence.js

@@ -0,0 +1,80 @@
+/**
+ * The detach escape sequence for `yolo-bridge attach`.
+ *
+ * WHY THIS EXISTS. `cli.ts` registers `process.on('SIGINT', …)` as the daemon's
+ * stop path, and `local-agent.ts` puts stdin into RAW MODE so every byte can be
+ * forwarded to the agent's PTY. Raw mode is precisely the mode in which the
+ * tty stops translating `\x03` into SIGINT — so that handler is not merely at
+ * risk of being missed, it is UNREACHABLE from the keyboard for as long as an
+ * agent is attached. The operator presses Ctrl+C expecting to quit, gets
+ * silence, and the teardown never runs.
+ *
+ * ⚠️ THE FIX IS NOT TO GIVE Ctrl+C BACK TO THE DAEMON. Forwarding it to the
+ * agent is the more valuable behaviour by a wide margin — interrupting a
+ * runaway agent is the thing an operator actually needs mid-session, and a
+ * daemon that quit instead would take the agent down with it. So Ctrl+C keeps
+ * going to the agent and the daemon gets its own key.
+ *
+ * `Ctrl-P Ctrl-Q`, following `docker attach`. Chosen because it is vanishingly
+ * rare in agent TUIs: `Ctrl-C`, `Ctrl-D`, `Ctrl-Z` and a lone `Ctrl-Q` are all
+ * in active use by the CLIs this daemon spawns, and stealing any of them would
+ * trade one broken key for another.
+ */
+/** `Ctrl-P` — the prefix. Held back until the next byte decides its meaning. */
+export const DETACH_PREFIX_BYTE = 0x10;
+/** `Ctrl-Q` — only a detach when it IMMEDIATELY follows the prefix. */
+export const DETACH_SUFFIX_BYTE = 0x11;
+/**
+ * Splits a stdin stream into "detach" and "everything else".
+ *
+ * Byte-oriented and chunk-agnostic on purpose: in raw mode each keypress
+ * usually arrives as its own chunk, but nothing guarantees it, so the two
+ * bytes of the sequence may land together or apart and must behave identically
+ * either way.
+ *
+ * ⚠️ A PREFIX FOLLOWED BY ANYTHING ELSE FORWARDS BOTH BYTES. Swallowing the
+ * `Ctrl-P` would silently break it for agents that use it, which is the same
+ * class of bug this whole change exists to fix.
+ */
+export function createDetachSequenceFilter(opts) {
+    let prefixPending = false;
+    let detached = false;
+    return {
+        push(data) {
+            // Once detached, further keystrokes belong to a session that is going
+            // away; forwarding them would race the teardown.
+            if (detached)
+                return;
+            let out = '';
+            for (let i = 0; i < data.length; i++) {
+                const code = data.charCodeAt(i);
+                if (prefixPending) {
+                    prefixPending = false;
+                    if (code === DETACH_SUFFIX_BYTE) {
+                        // Emit whatever preceded the sequence, then stop. The prefix and
+                        // suffix are consumed and never reach the agent.
+                        if (out)
+                            opts.emit(out);
+                        detached = true;
+                        opts.onDetach();
+                        return;
+                    }
+                    // Not the suffix: the prefix was an ordinary keystroke after all.
+                    out += String.fromCharCode(DETACH_PREFIX_BYTE);
+                    // Fall through so THIS byte is handled normally — including the case
+                    // where it is itself another prefix.
+                }
+                if (code === DETACH_PREFIX_BYTE) {
+                    prefixPending = true;
+                    continue;
+                }
+                out += String.fromCharCode(code);
+            }
+            if (out)
+                opts.emit(out);
+        },
+        dispose() {
+            prefixPending = false;
+        },
+    };
+}

package/dist/local-agent.js

@@ -33,6 +33,7 @@
  */
 import { createRequire } from 'node:module';
 import { randomUUID } from 'node:crypto';
+import { createDetachSequenceFilter } from './detach-sequence.js';
 import * as pty from 'node-pty';
 import { splitByUtf8Bytes } from './output-stream.js';
 import { AnsiScanner, TerminalModeTracker, buildModePrologue, resolveGroundStart, } from './ansi-replay-state.js';
@@ -737,8 +738,16 @@ export function startLocalAgent(opts = {}) {
         fanOutRawData(data, pushRaw(data));
     });
     if (inStream && typeof inStream.on === 'function') {
+        // Every byte passes through the detach filter on its way to the PTY. It
+        // forwards everything except the `Ctrl-P Ctrl-Q` sequence — including a
+        // lone `Ctrl-P`, which agents use for history and which must not be eaten.
+        const detachFilter = createDetachSequenceFilter({
+            emit: (chunk) => { ptyProcess.write(chunk); },
+            onDetach: () => { opts.onDetachRequested?.(); },
+        });
+        state.detachFilter = detachFilter;
         const stdinListener = (data) => {
-            ptyProcess.write(typeof data === 'string' ? data : data.toString('utf-8'));
+            detachFilter.push(typeof data === 'string' ? data : data.toString('utf-8'));
         };
         if (inStream.isTTY && typeof inStream.setRawMode === 'function') {
             inStream.setRawMode(true);
@@ -818,6 +827,7 @@ function handleLocalResize(state) {
     }
 }
 function teardownStdio(state) {
+    state.detachFilter?.dispose();
     if (state.resizeSource && state.resizeListener && typeof state.resizeSource.removeListener === 'function') {
         state.resizeSource.removeListener('resize', state.resizeListener);
     }

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@yolo-labs/yolobridge",
-  "version": "0.21.0",
+  "version": "0.22.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",