ccx-relay 1.7.1 → 1.8.0

package/README.md

@@ -78,11 +78,6 @@ While the wrapped process is running:
 - Review the rewritten line, then press **Enter** to submit it to the child process.
 - A plain line with no trigger submits immediately on Enter, exactly as if `ccx` weren't there.
 - Arrow keys, Ctrl+C, and other control sequences pass through untouched.
-- **Multi-line prompts:** Shift+Enter adds a line break without submitting (same as in a plain Claude Code session).
-  `ccx` tracks the whole multi-line prompt internally, so the marker/Alt+M trigger enhances the entire thing, and a
-  multi-line rewrite gets spliced back in as multiple soft-broken lines rather than being submitted early.
-- Typing ahead while a spinner is running (e.g. mashing Alt+M again) is queued and replayed once the enhancement
-  finishes, instead of leaking into the child mid-rewrite. Ctrl+C still interrupts immediately even while enhancing.
 
 ### Changing the marker
 

package/bin/ccx.js

@@ -116,40 +116,10 @@ process.stdout.on('resize', () => {
 process.stdin.setRawMode(true);
 process.stdin.resume();
 
-// Windows Console API CONTROL_KEY_STATE flag (see README's win32-input-mode notes;
-// must match SHIFT_PRESSED in src/input.js).
-const SHIFT_PRESSED = 0x0010;
-
-function win32KeyEvent(vk, uc, keyDown, cs) {
-  return `\x1b[${vk};0;${uc};${keyDown ? 1 : 0};${cs};1_`;
-}
-
-// A raw '\r'/'\n' byte written into the pty reads to the wrapped app as a plain
-// Enter keypress, which submits instead of inserting a line break — so a
-// multi-line rewrite (or the original multi-line prompt, on restore-after-error)
-// would get cut off mid-line and the remainder typed as a new, separately
-// submitted line. Encode each embedded newline as a synthetic Shift+Enter
-// win32-input-mode sequence instead, matching how a real Shift+Enter keypress
-// already arrives (see the SHIFT_PRESSED branch in src/input.js).
-function writeTextPreservingLines(text) {
-  const lines = text.split('\n');
-  lines.forEach((line, idx) => {
-    if (line) ptyProcess.write(line);
-    if (idx < lines.length - 1) {
-      if (isWindows) {
-        ptyProcess.write(win32KeyEvent(13, 13, true, SHIFT_PRESSED));
-        ptyProcess.write(win32KeyEvent(13, 13, false, SHIFT_PRESSED));
-      } else {
-        ptyProcess.write('\n');
-      }
-    }
-  });
-}
-
 const handler = createInputHandler({
   marker: config.marker,
 
-  onEnhance: async (line, cursor, token) => {
+  onEnhance: async (line, cursor) => {
     const toSend = line.endsWith(config.marker) ? line.slice(0, -config.marker.length) : line;
     handler.setBusy(true);
     spinnerStart();
@@ -158,10 +128,6 @@ const handler = createInputHandler({
       const context = contextLines.length > 0 ? contextLines.join('\n') : null;
       improved = await enhance(toSend, config, context);
     } catch (err) {
-      // The user may have Ctrl+C'd out (or otherwise moved on) while this was
-      // in flight — reset() bumps the epoch, so an old token here means
-      // whatever we'd write back no longer belongs on the current line.
-      if (!handler.isCurrent(token)) return;
       let msg = 'Enhancement failed';
       if (err instanceof RateLimitError) msg = 'Quota exceeded';
       else if (err instanceof AuthError)    msg = 'Invalid key — run ccx-init';
@@ -173,20 +139,19 @@ const handler = createInputHandler({
       const charsAfterCursor = line.length - cursor;
       if (charsAfterCursor > 0) ptyProcess.write(`\x1b[${charsAfterCursor}C`);
       ptyProcess.write(Buffer.alloc(line.length, 0x7f));
-      writeTextPreservingLines(toSend);
-      handler.setLine(toSend);
+      ptyProcess.write(toSend);
       handler.setBusy(false);
+      handler.setLine(toSend);
       return;
     }
-    if (!handler.isCurrent(token)) return;
     await spinnerStop('success', 'Enhanced');
     // Move cursor to end of line then erase, write improved
     const charsAfterCursor = line.length - cursor;
     if (charsAfterCursor > 0) ptyProcess.write(`\x1b[${charsAfterCursor}C`);
     ptyProcess.write(Buffer.alloc(line.length, 0x7f));
-    writeTextPreservingLines(improved);
-    handler.setLine(improved);
+    ptyProcess.write(improved);
     handler.setBusy(false);
+    handler.setLine(improved);
   },
 
   onSubmit: (_line) => {},

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "ccx-relay",
-  "version": "1.7.1",
+  "version": "1.8.0",
   "description": "Transparent PTY wrapper for Claude Code (or any CLI) that lets you refine your prompt with Gemini AI before submitting it, without leaving your terminal session.",
   "main": "bin/ccx.js",
   "bin": {

package/src/input.js

@@ -21,42 +21,19 @@ function parseCsiSeq(chunk, i) {
   return { consumed: j + 1 - i, params, final };
 }
 
-// Windows Console API CONTROL_KEY_STATE flag (see README's win32-input-mode notes).
-const SHIFT_PRESSED = 0x0010;
-
 export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough, onCtrlC }) {
   let lineBuffer = '';
   let cursor = 0;
   let busy = false;
-  let epoch = 0;
-  let pendingWhileBusy = [];
 
   function reset() {
     lineBuffer = '';
     cursor = 0;
     busy = false;
-    pendingWhileBusy = [];
-    epoch++;
-  }
-
-  // Invalidated by reset() (e.g. Ctrl+C) so a still-in-flight enhance that
-  // resolves afterward can tell its result is stale and discard it instead of
-  // writing over whatever the user has moved on to.
-  function isCurrent(token) {
-    return token === epoch;
   }
 
   function setBusy(b) {
-    const wasBusy = busy;
     busy = b;
-    // Replay input that arrived mid-enhancement now that the line has been
-    // updated — see processChunk's busy branch for why it's queued instead
-    // of forwarded live.
-    if (wasBusy && !b && pendingWhileBusy.length > 0) {
-      const queued = pendingWhileBusy;
-      pendingWhileBusy = [];
-      for (const buf of queued) processChunk(buf);
-    }
   }
 
   // Sync internal buffer after external rewrite (e.g. after enhancement)
@@ -66,21 +43,7 @@ export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough,
   }
 
   function processChunk(chunk) {
-    if (busy) {
-      // A lone Ctrl+C still gets through immediately so the wrapped app (and
-      // the user) aren't stuck waiting on a hung enhance call. Everything
-      // else is queued rather than forwarded raw: forwarding live would let
-      // e.g. a mashed Alt+M reach the child unintercepted, silently editing
-      // its buffer in a way ccx's lineBuffer/cursor snapshot never sees —
-      // desyncing the erase-and-replace math once the enhance completes.
-      if (chunk.length === 1 && chunk[0] === 0x03) {
-        onCtrlC();
-        onPassthrough(chunk);
-        return;
-      }
-      pendingWhileBusy.push(Buffer.from(chunk));
-      return;
-    }
+    if (busy) { onPassthrough(chunk); return; }
 
     let i = 0;
     while (i < chunk.length) {
@@ -92,13 +55,8 @@ export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough,
         if (seq !== null) {
           if (seq.kd === 1) {
             if (seq.vk === 13) {
-              if (seq.cs & SHIFT_PRESSED) {
-                // Shift+Enter: soft line break in the wrapped app's own
-                // multi-line input, not a submit — keep composing.
-                lineBuffer = lineBuffer.slice(0, cursor) + '\n' + lineBuffer.slice(cursor);
-                cursor++;
-              } else if (lineBuffer.endsWith(marker) && lineBuffer.trim().length > marker.length) {
-                onEnhance(lineBuffer, cursor, epoch);
+              if (lineBuffer.endsWith(marker) && lineBuffer.trim().length > marker.length) {
+                onEnhance(lineBuffer, cursor);
                 return;
               } else {
                 onSubmit(lineBuffer);
@@ -119,7 +77,7 @@ export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough,
             } else if (seq.vk === 35) {
               cursor = lineBuffer.length;
             } else if (seq.vk === 77 && (seq.cs & (0x0001 | 0x0002)) && !(seq.cs & (0x0004 | 0x0008))) {
-              if (lineBuffer.length > 0) { onEnhance(lineBuffer, cursor, epoch); return; }
+              if (lineBuffer.length > 0) { onEnhance(lineBuffer, cursor); return; }
             }
           }
           onPassthrough(chunk.slice(i, i + seq.consumed));
@@ -130,7 +88,7 @@ export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough,
         // 2. Alt+M (ESC m)
         if (i + 1 < chunk.length && chunk[i + 1] === 0x6d) {
           if (lineBuffer.length > 0) {
-            onEnhance(lineBuffer, cursor, epoch);
+            onEnhance(lineBuffer, cursor);
             return;
           } else {
             onPassthrough(chunk.slice(i, i + 2));
@@ -158,7 +116,7 @@ export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough,
         return;
       } else if (byte === 0x0d) {
         if (lineBuffer.endsWith(marker) && lineBuffer.trim().length > marker.length) {
-          onEnhance(lineBuffer, cursor, epoch);
+          onEnhance(lineBuffer, cursor);
           return;
         } else {
           onSubmit(lineBuffer);
@@ -189,5 +147,5 @@ export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough,
     }
   }
 
-  return { processChunk, setBusy, reset, setLine, isCurrent };
+  return { processChunk, setBusy, reset, setLine };
 }