ccx-relay 1.9.0 → 2.3.0

package/bin/ccx-init.js

@@ -7,128 +7,222 @@ import { enhance, listModels, RateLimitError } from '../src/gemini.js';
 
 const args = process.argv.slice(2);
 
-async function promptHidden(question) {
+// ── ANSI ──────────────────────────────────────────────────────────────────────
+const c = {
+  reset: '\x1b[0m',  dim:   '\x1b[2m',   bold:  '\x1b[1m',
+  green: '\x1b[32m', red:   '\x1b[31m',  cyan:  '\x1b[36m', gray:  '\x1b[90m',
+};
+const s = {
+  active: `${c.cyan}◆${c.reset}`,  done: `${c.gray}◇${c.reset}`,
+  pipe:   `${c.gray}│${c.reset}`,   end:  `${c.gray}└${c.reset}`,
+  ok:     `${c.green}✓${c.reset}`,  err:  `${c.red}✗${c.reset}`,
+};
+
+// ── Banner ────────────────────────────────────────────────────────────────────
+function banner() {
+  const title = '  ccx-relay  ·  prompt relay setup  ';
+  const bar = '─'.repeat(title.length);
+  console.log(`\n   ╭${bar}╮`);
+  console.log(`   │${title}│`);
+  console.log(`   ╰${bar}╯\n`);
+}
+
+// ── Primitives ────────────────────────────────────────────────────────────────
+const pipe = () => console.log(s.pipe);
+const info = (m) => console.log(`${s.pipe}  ${c.dim}${m}${c.reset}`);
+const good = (m) => console.log(`${s.pipe}  ${s.ok}  ${m}`);
+const bad  = (m) => console.log(`${s.pipe}  ${s.err}  ${c.red}${m}${c.reset}`);
+const head = (label) => console.log(`${s.active}  ${c.bold}${label}${c.reset}`);
+
+// ── Hidden input (●●● masking) ────────────────────────────────────────────────
+async function promptHidden() {
   return new Promise(resolve => {
-    process.stdout.write(question);
+    process.stdout.write(`${s.pipe}  `);
     const rl = createInterface({ input: process.stdin, output: null, terminal: false });
     if (process.stdin.isTTY) process.stdin.setRawMode(true);
     let input = '';
     process.stdin.on('data', function onData(buf) {
       for (let i = 0; i < buf.length; i++) {
-        const byte = buf[i];
-        if (byte === 0x0d || byte === 0x0a) {
+        const b = buf[i];
+        if (b === 0x0d || b === 0x0a) {
           if (process.stdin.isTTY) process.stdin.setRawMode(false);
           process.stdout.write('\n');
           process.stdin.removeListener('data', onData);
           rl.close();
           resolve(input);
           return;
-        } else if (byte === 0x7f || byte === 0x08) {
+        } else if (b === 0x7f || b === 0x08) {
           if (input.length > 0) { input = input.slice(0, -1); process.stdout.write('\b \b'); }
-        } else if (byte === 0x03) {
+        } else if (b === 0x03) {
           process.exit(0);
-        } else if (byte >= 0x20) {
-          input += String.fromCharCode(byte);
-          process.stdout.write('*');
+        } else if (b >= 0x20) {
+          input += String.fromCharCode(b);
+          process.stdout.write(`${c.dim}●${c.reset}`);
         }
       }
     });
   });
 }
 
-async function prompt(rl, question) {
-  return new Promise(resolve => rl.question(question, resolve));
-}
-
-function maskKey(key) {
-  if (!key) return '(not set)';
-  if (key.length <= 6) return key + '****...';
-  return key.slice(0, 6) + '****...';
+// ── Plain prompt ──────────────────────────────────────────────────────────────
+async function ask(question, defaultVal = '') {
+  return new Promise(resolve => {
+    const rl = createInterface({ input: process.stdin, output: process.stdout });
+    rl.question(question, answer => {
+      rl.close();
+      resolve(answer.trim() || defaultVal);
+    });
+  });
 }
 
-function showConfig() {
-  const config = load();
-  const path = configPath();
-  console.log(`Config: ${path}\n`);
-  console.log(`  geminiApiKey:   ${maskKey(config.geminiApiKey)}`);
-  console.log(`  geminiModel:    ${config.geminiModel}`);
-  console.log(`  marker:         ${config.marker}`);
-  console.log(`  timeoutSeconds: ${config.timeoutSeconds}`);
+// ── Spinner ───────────────────────────────────────────────────────────────────
+const FRAMES = ['⠋','⠙','⠹','⠸','⠼','⠴','⠦','⠧','⠇','⠏'];
+function spin(msg) {
+  let f = 0;
+  process.stdout.write(`${s.pipe}  `);
+  const id = setInterval(() => {
+    process.stdout.write(`\r${s.pipe}  ${c.dim}${FRAMES[f++ % FRAMES.length]}${c.reset}  ${msg}`);
+  }, 80);
+  return () => { clearInterval(id); process.stdout.write('\r\x1b[2K'); };
 }
 
-function resetConfig() {
-  const path = configPath();
-  if (existsSync(path)) {
-    rmSync(path);
-    console.log('Config reset. Run `ccx-init` to set up again.');
-  } else {
-    console.log('No config file found — nothing to reset.');
-  }
+// ── Model metadata ────────────────────────────────────────────────────────────
+const MODEL_META = {
+  'llama-3.1-8b-instant':    { note: 'fastest',  quota: '14,400/day' },
+  'llama-3.3-70b-versatile': { note: 'smarter',  quota: ' 1,000/day' },
+  'gemma2-9b-it':            { note: 'balanced', quota: '14,400/day' },
+  'llama3-8b-8192':          { note: 'classic',  quota: '14,400/day' },
+  'llama-3.1-70b-versatile': { note: 'large',    quota: ' 1,000/day' },
+  'gemini-2.5-flash':        { note: 'latest',   quota: 'limited'    },
+  'gemini-2.0-flash-lite':   { note: 'fast',     quota: 'limited'    },
+  'gemini-1.5-flash':        { note: 'stable',   quota: '1,500/day'  },
+  'gemini-2.5-pro':          { note: 'powerful', quota: 'limited'    },
+};
+
+function modelRow(m, i, isDefault) {
+  const meta = MODEL_META[m] || { note: '', quota: '' };
+  const num  = `${i + 1}`.padStart(2);
+  const name = m.padEnd(34);
+  const note = meta.note.padEnd(10);
+  const tag  = isDefault ? `  ${c.dim}← default${c.reset}` : '';
+  return `${s.pipe}  ${c.dim}${num}${c.reset}  ${name}${c.dim}${note}  ${meta.quota}${c.reset}${tag}`;
 }
 
+// ── Wizard ────────────────────────────────────────────────────────────────────
 async function runWizard() {
-  console.log('\n  Welcome to ccx setup\n');
-
-  const key = await promptHidden('  API key: ');
-  if (!key) { console.log('No key entered. Aborting.'); process.exit(1); }
-
+  banner();
+
+  // ── Key ──
+  head('API key');
+  info('Groq (gsk_...)   → 14,400 req/day free  ← recommended');
+  info('Gemini (AIza...) → limited free tier');
+  pipe();
+
+  const key = await promptHidden();
+  if (!key) { bad('No key entered.'); process.exit(1); }
+  const provider = key.startsWith('gsk_') ? 'Groq' : 'Gemini';
+  pipe();
+
+  // ── Validate ──
+  head(`Validating ${provider} key`);
+  const stopValidate = spin('Connecting...');
   const testModel = key.startsWith('gsk_') ? 'llama-3.1-8b-instant' : 'gemini-2.5-flash';
-  process.stdout.write('  Testing key... ');
   try {
     await enhance('hello', { geminiApiKey: key, geminiModel: testModel, timeoutSeconds: 10 });
-    console.log('\x1b[32m✓ Valid\x1b[0m');
+    stopValidate();
+    good(`${provider} key valid`);
   } catch (err) {
     if (err instanceof RateLimitError) {
-      console.log('\x1b[32m✓ Valid\x1b[0m \x1b[2m(quota exceeded — key authenticated)\x1b[0m');
+      stopValidate();
+      good(`${provider} key valid  ${c.dim}(quota hit — authenticated)${c.reset}`);
     } else {
-      console.log(`\x1b[31m✗ Invalid key\x1b[0m — ${err.message}`);
+      stopValidate();
+      bad(`Invalid key — ${err.message}`);
+      console.log(`${s.end}  Run ${c.bold}ccx-init${c.reset} again with a valid key.\n`);
       process.exit(1);
     }
   }
+  pipe();
 
-  // Fetch available models, fall back to hardcoded list
+  // ── Models ──
+  head('Model');
+  const stopFetch = spin('Fetching available models...');
   let models;
-  process.stdout.write('  Fetching available models... ');
   try {
     const all = await listModels(key);
-    models = all.slice(0, 10);
-    if (models.length === 0) throw new Error('empty');
-    console.log(`\x1b[32m✓\x1b[0m ${models.length} found`);
+    models = all.slice(0, 8);
+    if (!models.length) throw new Error('empty');
+    stopFetch();
   } catch (_) {
+    stopFetch();
     models = key.startsWith('gsk_')
-      ? ['llama-3.1-8b-instant', 'llama-3.3-70b-versatile', 'gemma2-9b-it']
-      : ['gemini-2.5-flash', 'gemini-1.5-flash', 'gemini-2.5-pro'];
-    console.log('(using defaults)');
+      ? ['llama-3.1-8b-instant', 'llama-3.3-70b-versatile', 'gemma2-9b-it', 'llama3-8b-8192']
+      : ['gemini-2.5-flash', 'gemini-2.0-flash-lite', 'gemini-1.5-flash', 'gemini-2.5-pro'];
   }
 
-  const rl = createInterface({ input: process.stdin, output: process.stdout });
+  models.forEach((m, i) => console.log(modelRow(m, i, i === 0)));
+  pipe();
 
-  console.log('');
-  console.log('  Model:');
-  models.forEach((m, i) => {
-    console.log(`  ${i + 1}) ${m}${i === 0 ? ' (default)' : ''}`);
-  });
-
-  const modelChoice = await prompt(rl, '  Choice [1]: ');
-  const idx = parseInt(modelChoice.trim(), 10);
-  const modelIndex = (!idx || idx < 1 || idx > models.length) ? 0 : idx - 1;
+  const modelInput = await ask(`${s.pipe}  Choice ${c.dim}[1]${c.reset}: `, '1');
+  const mIdx = parseInt(modelInput, 10);
+  const modelIndex = (!mIdx || mIdx < 1 || mIdx > models.length) ? 0 : mIdx - 1;
   const model = models[modelIndex];
+  good(model);
+  pipe();
+
+  // ── Marker ──
+  head('Trigger marker');
+  info('Type at end of your prompt + Enter to enhance  (Alt+M also works anywhere)');
+  const marker = await ask(`${s.pipe}  Default ${c.dim}[;;]${c.reset}: `, ';;');
+  pipe();
+
+  // ── Timeout ──
+  head('Request timeout');
+  info('Seconds before giving up and restoring original text');
+  const timeoutInput = await ask(`${s.pipe}  Default ${c.dim}[8]${c.reset}: `, '8');
+  const timeoutSeconds = parseInt(timeoutInput, 10) || 8;
+  pipe();
+
+  // ── Save ──
+  save({ geminiApiKey: key, geminiModel: model, marker, timeoutSeconds });
+  const path = configPath();
+  console.log(`${s.end}  ${s.ok}  ${c.bold}${c.green}Config saved${c.reset}`);
+  console.log(`      ${c.dim}${path}${c.reset}`);
+  console.log(`\n      Run  ${c.bold}ccx claude${c.reset}  to start\n`);
+}
 
-  const markerAnswer = await prompt(rl, '  Trigger marker [;;]: ');
-  const marker = markerAnswer.trim() || ';;';
-
-  const timeoutAnswer = await prompt(rl, '  Timeout seconds [8]: ');
-  const timeoutSeconds = timeoutAnswer.trim() === '' ? 8 : (parseInt(timeoutAnswer, 10) || 8);
+// ── Sub-commands ──────────────────────────────────────────────────────────────
+function maskKey(key) {
+  if (!key) return '(not set)';
+  return key.slice(0, 6) + '****...';
+}
 
-  rl.close();
+function showConfig() {
+  const cfg = load();
+  const path = configPath();
+  const provider = cfg.geminiApiKey?.startsWith('gsk_') ? 'Groq' : 'Gemini';
+  banner();
+  console.log(`${s.pipe}  ${c.dim}Path${c.reset}      ${path}`);
+  console.log(`${s.pipe}  ${c.dim}Provider${c.reset}  ${provider}`);
+  console.log(`${s.pipe}  ${c.dim}Key${c.reset}       ${maskKey(cfg.geminiApiKey)}`);
+  console.log(`${s.pipe}  ${c.dim}Model${c.reset}     ${cfg.geminiModel}`);
+  console.log(`${s.pipe}  ${c.dim}Marker${c.reset}    ${cfg.marker}`);
+  console.log(`${s.end}  ${c.dim}Timeout${c.reset}   ${cfg.timeoutSeconds}s\n`);
+}
 
-  save({ geminiApiKey: key, geminiModel: model, marker, timeoutSeconds });
-  console.log(`\n  Config saved to ${configPath()}`);
-  console.log('  Run `ccx claude` to start.\n');
+function resetConfig() {
+  const path = configPath();
+  if (existsSync(path)) {
+    rmSync(path);
+    console.log(`${s.ok}  Config reset. Run ${c.bold}ccx-init${c.reset} to set up again.`);
+  } else {
+    console.log('No config file found — nothing to reset.');
+  }
 }
 
+// ── Entry ─────────────────────────────────────────────────────────────────────
 if (args.length === 0) {
-  runWizard();
+  runWizard().catch(err => { console.error(err.message); process.exit(1); });
 } else if (args[0] === '--show') {
   showConfig();
 } else if (args[0] === '--reset') {

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,59 +111,69 @@ process.stdout.on('resize', () => {
   ptyProcess.resize(process.stdout.columns, process.stdout.rows);
 });
 
+// ── 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;
+}
+
+// ── 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;
+  }
+
+  await spinnerStop('success', 'Enhanced');
+
+  // 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;
+}
+
+// ── Stdin routing ──────────────────────────────────────────────────────────────
 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;
-    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);
-      // Move cursor to end of line then erase, restore original
-      const charsAfterCursor = line.length - cursor;
-      if (charsAfterCursor > 0) ptyProcess.write(`\x1b[${charsAfterCursor}C`);
-      ptyProcess.write(Buffer.alloc(line.length, 0x7f));
-      ptyProcess.write(toSend);
-      handler.setBusy(false);
-      handler.setLine(toSend);
-      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));
-    ptyProcess.write(improved);
-    handler.setBusy(false);
-    handler.setLine(improved);
-  },
-
-  onSubmit: (_line) => {},
-
-  onPassthrough: (chunk) => ptyProcess.write(chunk),
-
-  onCtrlC: () => {
-    spinnerClear();
-    handler.reset();
-  },
+process.stdin.on('data', chunk => {
+  if (busy) return; // swallow input during enhancement
+  if (isAltM(chunk)) { handleEnhance(); return; }
+  ptyProcess.write(chunk);
 });
 
-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": "1.9.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/gemini.js

@@ -7,11 +7,11 @@ export class NetworkError extends Error {}
 const SYSTEM_PROMPT =
   'Rewrite the following text to be grammatically correct and clearer, ' +
   'while preserving its original intent and meaning exactly. ' +
-  'This is a single line typed into a terminal prompt, not a chat message - ' +
-  'respond with EXACTLY ONE rewritten version as a single plain-text line. ' +
+  'This is text typed into a terminal prompt — it may be one line or multiple lines. ' +
+  'Respond with EXACTLY ONE rewritten version preserving the same line structure and count. ' +
   'Do not offer multiple options or alternatives. Do not add headings, bullet ' +
   'points, markdown formatting, quotes, explanations, or any commentary. ' +
-  'Output must contain nothing but the rewritten line itself.';
+  'Output must contain nothing but the rewritten text itself.';
 
 function isGroq(apiKey) { return apiKey.startsWith('gsk_'); }
 
@@ -78,7 +78,7 @@ async function enhanceGroq(text, config, context) {
           { role: 'system', content: SYSTEM_PROMPT },
           { role: 'user', content: userContent },
         ],
-        max_tokens: 256,
+        max_tokens: 2048,
       }),
     });
 

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) {
@@ -55,7 +57,11 @@ export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough,
         if (seq !== null) {
           if (seq.kd === 1) {
             if (seq.vk === 13) {
-              if (lineBuffer.endsWith(marker) && lineBuffer.trim().length > marker.length) {
+              if (seq.cs & 0x0010) {
+                // Shift+Enter: append newline, accumulate multi-line buffer
+                lineBuffer += '\n';
+                cursor = lineBuffer.length;
+              } else if (lineBuffer.endsWith(marker) && lineBuffer.trim().length > marker.length) {
                 onEnhance(lineBuffer, cursor);
                 return;
               } else {
@@ -97,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);
@@ -106,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;
@@ -115,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 {
@@ -123,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);
+  });
+}