ccx-relay 2.1.0 → 2.3.0

package/bin/ccx.js

@@ -3,12 +3,12 @@
 
 import { load } from '../src/config.js';
 import { enhance, RateLimitError, AuthError, ModelError, TimeoutError, NetworkError } from '../src/gemini.js';
-import { start as spinnerStart, stop as spinnerStop, clear as spinnerClear } from '../src/ui.js';
-import { createInputHandler } from '../src/input.js';
+import { start as spinnerStart, stop as spinnerStop } from '../src/ui.js';
+import { openPopup } from '../src/popup.js';
 
 const argv = process.argv.slice(2);
 
-// Shell tab-completion scripts
+// ── Shell tab-completion ───────────────────────────────────────────────────────
 if (argv[0] === 'completion') {
   const shell = argv[1] || 'bash';
   const scripts = {
@@ -42,13 +42,13 @@ if (argv[0] === 'completion') {
     process.exit(1);
   }
   process.stdout.write(scripts[shell] + '\n');
-  process.stdout.write('\n# To activate, add to your shell profile:\n');
-  if (shell === 'bash') process.stdout.write('# eval "$(ccx completion bash)"\n');
-  else if (shell === 'zsh') process.stdout.write('# eval "$(ccx completion zsh)"\n');
+  if (shell === 'bash')       process.stdout.write('# eval "$(ccx completion bash)"\n');
+  else if (shell === 'zsh')   process.stdout.write('# eval "$(ccx completion zsh)"\n');
   else if (shell === 'powershell') process.stdout.write('# Invoke-Expression (ccx completion powershell)\n');
   process.exit(0);
 }
 
+// ── Load node-pty ──────────────────────────────────────────────────────────────
 let pty;
 try {
   pty = (await import('node-pty')).default;
@@ -62,23 +62,21 @@ try {
 }
 
 const config = load();
-
 if (!config.geminiApiKey) {
   process.stderr.write('[ccx] No API key found. Run `ccx-init` to set up.\n');
   process.exit(1);
 }
-
 if (!process.stdin.isTTY || !process.stdout.isTTY) {
-  process.stderr.write('[ccx] ccx must be run in an interactive terminal.\n');
+  process.stderr.write('[ccx] Must be run in an interactive terminal.\n');
   process.exit(1);
 }
 
+// ── Spawn PTY ──────────────────────────────────────────────────────────────────
 const targetCmd  = argv[0] || 'claude';
 const targetArgs = argv.slice(1);
-
-const isWindows = process.platform === 'win32';
-const shellFile = isWindows ? (process.env.COMSPEC || 'cmd.exe') : targetCmd;
-const shellArgs = isWindows ? ['/d', '/s', '/c', [targetCmd, ...targetArgs].join(' ')] : targetArgs;
+const isWindows  = process.platform === 'win32';
+const shellFile  = isWindows ? (process.env.COMSPEC || 'cmd.exe') : targetCmd;
+const shellArgs  = isWindows ? ['/d', '/s', '/c', [targetCmd, ...targetArgs].join(' ')] : targetArgs;
 
 const ptyProcess = pty.spawn(shellFile, shellArgs, {
   name: 'xterm-color',
@@ -88,7 +86,7 @@ const ptyProcess = pty.spawn(shellFile, shellArgs, {
   env:  process.env,
 });
 
-// Ring buffer of recent PTY output lines for context-aware enhancement
+// ── Context ring buffer ────────────────────────────────────────────────────────
 const CONTEXT_MAX = 20;
 const contextLines = [];
 
@@ -101,9 +99,9 @@ function stripAnsi(s) {
 
 ptyProcess.onData(data => {
   process.stdout.write(data);
-  for (const line of stripAnsi(data).split('\n')) {
-    if (line.trim()) {
-      contextLines.push(line.trim());
+  for (const ln of stripAnsi(data).split('\n')) {
+    if (ln.trim()) {
+      contextLines.push(ln.trim());
       if (contextLines.length > CONTEXT_MAX) contextLines.shift();
     }
   }
@@ -113,67 +111,69 @@ process.stdout.on('resize', () => {
   ptyProcess.resize(process.stdout.columns, process.stdout.rows);
 });
 
-process.stdin.setRawMode(true);
-process.stdin.resume();
-
-function eraseInput(line, cursor) {
-  const parts = line.split('\n');
-  const extraLines = parts.length - 1;
-  if (extraLines === 0) {
-    const charsAfterCursor = line.length - cursor;
-    if (charsAfterCursor > 0) ptyProcess.write(`\x1b[${charsAfterCursor}C`);
-    ptyProcess.write(Buffer.alloc(line.length, 0x7f));
-  } else {
-    ptyProcess.write('\x1b[2K');
-    for (let i = 0; i < extraLines; i++) ptyProcess.write('\x1b[1A\x1b[2K');
-    ptyProcess.write('\x1b[G');
+// ── Alt+M detection ────────────────────────────────────────────────────────────
+// Returns true if this chunk is an Alt+M keypress (standard or win32-input-mode).
+function isAltM(chunk) {
+  // Standard: ESC m (0x1b 0x6d)
+  if (chunk.length >= 2 && chunk[0] === 0x1b && chunk[1] === 0x6d) return true;
+  // Win32 input mode: ESC [ vk;sc;uc;kd;cs;rc _  where vk=77 (M), kd=1 (keydown), Alt bit in cs
+  if (chunk.length >= 2 && chunk[0] === 0x1b && chunk[1] === 0x5b) {
+    const m = chunk.toString('ascii').match(/^\x1b\[(\d+);\d+;\d+;(\d+);(\d+);\d+_/);
+    if (m) {
+      const vk = +m[1], kd = +m[2], cs = +m[3];
+      if (vk === 77 && kd === 1 && (cs & 0x0003) && !(cs & 0x000c)) return true;
+    }
   }
+  return false;
 }
 
-const handler = createInputHandler({
-  marker: config.marker,
-
-  onEnhance: async (line, cursor) => {
-    const toSend = line.endsWith(config.marker) ? line.slice(0, -config.marker.length) : line;
-    handler.setBusy(true);
-    spinnerStart();
-    let improved;
-    try {
-      const context = contextLines.length > 0 ? contextLines.join('\n') : null;
-      improved = await enhance(toSend, config, context);
-    } catch (err) {
-      let msg = 'Enhancement failed';
-      if (err instanceof RateLimitError) msg = 'Quota exceeded';
-      else if (err instanceof AuthError)    msg = 'Invalid key — run ccx-init';
-      else if (err instanceof ModelError)   msg = 'Model not found — run ccx-init';
-      else if (err instanceof TimeoutError) msg = `Timed out after ${config.timeoutSeconds}s — original restored`;
-      else if (err instanceof NetworkError) msg = 'No connection — original restored';
-      await spinnerStop('error', msg);
-      eraseInput(line, cursor);
-      ptyProcess.write(toSend);
-      handler.setBusy(false);
-      handler.setLine(toSend);
-      return;
-    }
-    await spinnerStop('success', 'Enhanced');
-    eraseInput(line, cursor);
-    ptyProcess.write(improved);
-    handler.setBusy(false);
-    handler.setLine(improved);
-  },
+// ── Enhancement flow ───────────────────────────────────────────────────────────
+let busy = false;
+
+async function handleEnhance() {
+  busy = true;
+
+  const text = await openPopup();
+  if (!text) { busy = false; return; }
+
+  spinnerStart();
+  let improved;
+  try {
+    const context = contextLines.length > 0 ? contextLines.join('\n') : null;
+    improved = await enhance(text, config, context);
+  } catch (err) {
+    let msg = 'Enhancement failed';
+    if (err instanceof RateLimitError) msg = 'Quota exceeded';
+    else if (err instanceof AuthError)    msg = 'Invalid key — run ccx-init';
+    else if (err instanceof ModelError)   msg = 'Model not found — run ccx-init';
+    else if (err instanceof TimeoutError) msg = `Timed out after ${config.timeoutSeconds}s`;
+    else if (err instanceof NetworkError) msg = 'No connection';
+    await spinnerStop('error', msg);
+    busy = false;
+    return;
+  }
 
-  onSubmit: (_line) => {},
+  await spinnerStop('success', 'Enhanced');
 
-  onPassthrough: (chunk) => ptyProcess.write(chunk),
+  // Clear any existing text in Claude Code's input line, then inject enhanced text
+  ptyProcess.write('\x15'); // Ctrl+U = kill line (clears Claude Code's current input)
+  // Small pause so Claude Code processes the Ctrl+U before we type the new text
+  await new Promise(r => setTimeout(r, 30));
+  ptyProcess.write(improved);
+  busy = false;
+}
 
-  onCtrlC: () => {
-    spinnerClear();
-    handler.reset();
-  },
-});
+// ── Stdin routing ──────────────────────────────────────────────────────────────
+process.stdin.setRawMode(true);
+process.stdin.resume();
 
-process.stdin.on('data', chunk => handler.processChunk(chunk));
+process.stdin.on('data', chunk => {
+  if (busy) return; // swallow input during enhancement
+  if (isAltM(chunk)) { handleEnhance(); return; }
+  ptyProcess.write(chunk);
+});
 
+// ── Cleanup ────────────────────────────────────────────────────────────────────
 function cleanupAndExit(code) {
   try { if (process.stdin.isTTY) process.stdin.setRawMode(false); } catch (_) {}
   process.exit(code == null ? 0 : code);

package/package.json

@@ -1,7 +1,7 @@
 {
   "type": "module",
   "name": "ccx-relay",
-  "version": "2.1.0",
+  "version": "2.3.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

@@ -25,11 +25,13 @@ export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough,
   let lineBuffer = '';
   let cursor = 0;
   let busy = false;
+  let inPaste = false;
 
   function reset() {
     lineBuffer = '';
     cursor = 0;
     busy = false;
+    inPaste = false;
   }
 
   function setBusy(b) {
@@ -101,7 +103,7 @@ export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough,
           continue;
         }
 
-        // 3. Standard CSI sequences (arrows, Home, End, etc.)
+        // 3. Standard CSI sequences (arrows, Home, End, bracketed paste, etc.)
         const csi = parseCsiSeq(chunk, i);
         if (csi !== null) {
           if      (csi.final === 'D' && !csi.params) cursor = Math.max(0, cursor - 1);
@@ -110,6 +112,8 @@ export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough,
           else if (csi.final === 'F' && !csi.params) cursor = lineBuffer.length;
           else if (csi.final === '~' && csi.params === '1') cursor = 0;
           else if (csi.final === '~' && csi.params === '4') cursor = lineBuffer.length;
+          else if (csi.final === '~' && csi.params === '200') inPaste = true;
+          else if (csi.final === '~' && csi.params === '201') inPaste = false;
           onPassthrough(chunk.slice(i, i + csi.consumed));
           i += csi.consumed;
           continue;
@@ -119,7 +123,13 @@ export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough,
         onPassthrough(chunk.slice(i));
         return;
       } else if (byte === 0x0d) {
-        if (lineBuffer.endsWith(marker) && lineBuffer.trim().length > marker.length) {
+        if (inPaste) {
+          // Inside bracketed paste: CR = newline, accumulate
+          lineBuffer += '\n';
+          cursor = lineBuffer.length;
+          i++;
+          if (i < chunk.length && chunk[i] === 0x0a) i++; // skip CRLF's LF
+        } else if (lineBuffer.endsWith(marker) && lineBuffer.trim().length > marker.length) {
           onEnhance(lineBuffer, cursor);
           return;
         } else {
@@ -127,6 +137,15 @@ export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough,
           onPassthrough(Buffer.from([byte]));
           lineBuffer = '';
           cursor = 0;
+          i++;
+        }
+      } else if (byte === 0x0a) {
+        if (inPaste) {
+          // LF inside paste (after CR already handled, or standalone LF)
+          lineBuffer += '\n';
+          cursor = lineBuffer.length;
+        } else {
+          onPassthrough(Buffer.from([byte]));
         }
         i++;
       } else if (byte === 0x03) {

package/src/popup.js

@@ -0,0 +1,241 @@
+// Self-contained popup for clean multi-line prompt input.
+// Owns its own raw-mode data listener — no shadow buffer, no drift.
+
+const c = {
+  reset: '\x1b[0m', dim: '\x1b[2m', bold: '\x1b[1m',
+  cyan: '\x1b[36m', gray: '\x1b[90m',
+};
+
+// ── Win32 / CSI parsers (inlined to keep popup self-contained) ────────────────
+function parseW32(buf, i) {
+  if (buf[i + 1] !== 0x5b) return null;
+  let j = i + 2;
+  while (j < buf.length && ((buf[j] >= 0x30 && buf[j] <= 0x39) || buf[j] === 0x3b)) j++;
+  if (j >= buf.length || buf[j] !== 0x5f || j === i + 2) return null;
+  const parts = buf.slice(i + 2, j).toString('ascii').split(';').map(Number);
+  if (parts.length !== 6 || parts.some(Number.isNaN)) return null;
+  const [vk, sc, uc, kd, cs] = parts;
+  return { consumed: j + 1 - i, vk, kd, cs };
+}
+
+function parseCsi(buf, i) {
+  if (buf[i + 1] !== 0x5b) return null;
+  let j = i + 2;
+  while (j < buf.length && buf[j] >= 0x20 && buf[j] <= 0x3f) j++;
+  if (j >= buf.length || buf[j] < 0x40 || buf[j] > 0x7e) return null;
+  return { consumed: j + 1 - i, params: buf.slice(i + 2, j).toString('ascii'), final: String.fromCharCode(buf[j]) };
+}
+
+// ── Render ────────────────────────────────────────────────────────────────────
+function render(lines, cursorLine, cursorCol) {
+  const cols  = Math.max((process.stdout.columns || 80) - 2, 20);
+  const rows  = process.stdout.rows || 24;
+  const MAX_VISIBLE = 8;
+  const visLines    = lines.length;
+  const popupH      = Math.min(visLines, MAX_VISIBLE) + 2; // header + content rows + footer hint
+  const startRow    = Math.max(1, rows - popupH);
+
+  // Show last MAX_VISIBLE lines
+  const offset   = Math.max(0, visLines - MAX_VISIBLE);
+  const visible  = lines.slice(offset);
+  const relLine  = cursorLine - offset; // cursor row within visible slice
+
+  const hint = `${c.dim}Shift+Enter: new line  ·  Ctrl+C / Esc: cancel${c.reset}`;
+  const bar  = '─'.repeat(cols);
+
+  let out = '\x1b[s'; // save cursor
+
+  // Header
+  out += `\x1b[${startRow};1H\x1b[2K`;
+  out += `${c.cyan}◆${c.reset} ${c.bold}Enhance${c.reset}  ${hint}`;
+
+  // Separator
+  out += `\x1b[${startRow + 1};1H\x1b[2K${c.gray}${bar}${c.reset}`;
+
+  // Content lines
+  for (let r = 0; r < visible.length; r++) {
+    out += `\x1b[${startRow + 2 + r};1H\x1b[2K`;
+    out += `${c.gray}▶${c.reset} ${visible[r]}`;
+  }
+
+  // Position cursor
+  const curRow = startRow + 2 + relLine;
+  const curCol = 3 + cursorCol; // 3 = "▶ " prefix width
+  out += `\x1b[${curRow};${curCol}H`;
+
+  return out;
+}
+
+function clearArea(lines) {
+  const rows   = process.stdout.rows || 24;
+  const MAX_V  = 8;
+  const popupH = Math.min(lines.length, MAX_V) + 2;
+  const start  = Math.max(1, rows - popupH);
+  let out = '';
+  for (let r = start; r <= rows; r++) out += `\x1b[${r};1H\x1b[2K`;
+  out += '\x1b[u'; // restore original cursor
+  return out;
+}
+
+// ── Public API ────────────────────────────────────────────────────────────────
+// Returns: string (the composed text) or null (cancelled).
+export function openPopup() {
+  return new Promise(resolve => {
+    // State
+    const lines  = [''];   // array of line strings
+    let curLine  = 0;      // which line cursor is on
+    let curCol   = 0;      // column within that line
+    let inPaste  = false;
+
+    function line()  { return lines[curLine]; }
+    function redraw() { process.stdout.write(render(lines, curLine, curCol)); }
+
+    function done(result) {
+      process.stdout.write(clearArea(lines));
+      process.stdin.removeListener('data', onData);
+      resolve(result && result.trim() ? result : null);
+    }
+
+    function insertChar(ch) {
+      lines[curLine] = line().slice(0, curCol) + ch + line().slice(curCol);
+      curCol++;
+    }
+
+    function backspace() {
+      if (curCol > 0) {
+        lines[curLine] = line().slice(0, curCol - 1) + line().slice(curCol);
+        curCol--;
+      } else if (curLine > 0) {
+        // Merge with previous line
+        const prev = lines[curLine - 1];
+        curCol = prev.length;
+        lines[curLine - 1] = prev + lines[curLine];
+        lines.splice(curLine, 1);
+        curLine--;
+      }
+    }
+
+    function newLine() {
+      // Split current line at cursor
+      const before = line().slice(0, curCol);
+      const after  = line().slice(curCol);
+      lines[curLine] = before;
+      lines.splice(curLine + 1, 0, after);
+      curLine++;
+      curCol = 0;
+    }
+
+    redraw();
+
+    function onData(buf) {
+      let i = 0;
+      while (i < buf.length) {
+        const byte = buf[i];
+
+        // ── ESC sequences ──
+        if (byte === 0x1b) {
+          // Win32 input mode
+          const w = parseW32(buf, i);
+          if (w && w.kd === 1) {
+            i += w.consumed;
+            switch (w.vk) {
+              case 13: // Enter / Shift+Enter
+                if (w.cs & 0x0010) { newLine(); redraw(); }
+                else { done(lines.join('\n')); return; }
+                break;
+              case 8:  // Backspace
+                backspace(); redraw(); break;
+              case 37: // Left
+                if (curCol > 0) { curCol--; redraw(); }
+                break;
+              case 39: // Right
+                if (curCol < line().length) { curCol++; redraw(); }
+                break;
+              case 36: // Home
+                curCol = 0; redraw(); break;
+              case 35: // End
+                curCol = line().length; redraw(); break;
+              case 27: // Esc
+                done(null); return;
+            }
+            continue;
+          }
+
+          // CSI sequences
+          const csi = parseCsi(buf, i);
+          if (csi) {
+            i += csi.consumed;
+            if      (csi.final === 'D' && !csi.params) { if (curCol > 0) { curCol--; redraw(); } }
+            else if (csi.final === 'C' && !csi.params) { if (curCol < line().length) { curCol++; redraw(); } }
+            else if (csi.final === 'H' && !csi.params) { curCol = 0; redraw(); }
+            else if (csi.final === 'F' && !csi.params) { curCol = line().length; redraw(); }
+            else if (csi.final === '~' && csi.params === '200') { inPaste = true; }
+            else if (csi.final === '~' && csi.params === '201') { inPaste = false; }
+            continue;
+          }
+
+          // ESC alone → cancel
+          if (i + 1 >= buf.length || buf[i + 1] < 0x20) { done(null); return; }
+          i += 2; // skip unknown ESC+byte
+          continue;
+        }
+
+        // ── CR ──
+        if (byte === 0x0d) {
+          i++;
+          if (inPaste) {
+            newLine();
+            if (i < buf.length && buf[i] === 0x0a) i++; // skip CRLF's LF
+            redraw();
+          } else {
+            done(lines.join('\n')); return;
+          }
+          continue;
+        }
+
+        // ── LF ──
+        if (byte === 0x0a) {
+          i++;
+          if (inPaste) { newLine(); redraw(); }
+          continue;
+        }
+
+        // ── Ctrl+C ──
+        if (byte === 0x03) { done(null); return; }
+
+        // ── Ctrl+U (clear line) ──
+        if (byte === 0x15) {
+          lines[curLine] = line().slice(curCol);
+          curCol = 0;
+          i++; redraw(); continue;
+        }
+
+        // ── Ctrl+W (delete word) ──
+        if (byte === 0x17) {
+          let s = line().slice(0, curCol);
+          s = s.replace(/\S+\s*$/, '');
+          lines[curLine] = s + line().slice(curCol);
+          curCol = s.length;
+          i++; redraw(); continue;
+        }
+
+        // ── Ctrl+A / Ctrl+E ──
+        if (byte === 0x01) { curCol = 0; i++; redraw(); continue; }
+        if (byte === 0x05) { curCol = line().length; i++; redraw(); continue; }
+
+        // ── Backspace ──
+        if (byte === 0x7f || byte === 0x08) { backspace(); i++; redraw(); continue; }
+
+        // ── Printable ──
+        if (byte >= 0x20) {
+          insertChar(String.fromCharCode(byte));
+          i++; redraw(); continue;
+        }
+
+        i++; // skip unknown control byte
+      }
+    }
+
+    process.stdin.on('data', onData);
+  });
+}