ccx-relay 2.1.0 → 2.4.0

package/bin/ccx.js

@@ -8,7 +8,7 @@ import { createInputHandler } from '../src/input.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,30 +111,36 @@ process.stdout.on('resize', () => {
   ptyProcess.resize(process.stdout.columns, process.stdout.rows);
 });
 
-process.stdin.setRawMode(true);
-process.stdin.resume();
-
+// ── Erase current input (single or multi-line) ────────────────────────────────
 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`);
+  const extra = parts.length - 1;
+  if (extra === 0) {
+    const after = line.length - cursor;
+    if (after > 0) ptyProcess.write(`\x1b[${after}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');
+    for (let i = 0; i < extra; i++) ptyProcess.write('\x1b[1A\x1b[2K');
     ptyProcess.write('\x1b[G');
   }
 }
 
+// ── Input handler ──────────────────────────────────────────────────────────────
+process.stdin.setRawMode(true);
+process.stdin.resume();
+
 const handler = createInputHandler({
   marker: config.marker,
 
   onEnhance: async (line, cursor) => {
-    const toSend = line.endsWith(config.marker) ? line.slice(0, -config.marker.length) : line;
+    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;
@@ -155,6 +159,7 @@ const handler = createInputHandler({
       handler.setLine(toSend);
       return;
     }
+
     await spinnerStop('success', 'Enhanced');
     eraseInput(line, cursor);
     ptyProcess.write(improved);
@@ -162,7 +167,7 @@ const handler = createInputHandler({
     handler.setLine(improved);
   },
 
-  onSubmit: (_line) => {},
+  onSubmit: () => {},
 
   onPassthrough: (chunk) => ptyProcess.write(chunk),
 
@@ -174,6 +179,7 @@ const handler = createInputHandler({
 
 process.stdin.on('data', chunk => handler.processChunk(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.4.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);
+  });
+}