ccx-relay 1.6.1 → 1.7.1

package/README.md

@@ -78,6 +78,11 @@ 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-init.js

@@ -72,9 +72,10 @@ async function runWizard() {
   const key = await promptHidden('  API key: ');
   if (!key) { console.log('No key entered. Aborting.'); process.exit(1); }
 
+  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: 'gemini-2.5-flash', timeoutSeconds: 10 });
+    await enhance('hello', { geminiApiKey: key, geminiModel: testModel, timeoutSeconds: 10 });
     console.log('\x1b[32m✓ Valid\x1b[0m');
   } catch (err) {
     if (err instanceof RateLimitError) {

package/bin/ccx.js

@@ -116,10 +116,40 @@ 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) => {
+  onEnhance: async (line, cursor, token) => {
     const toSend = line.endsWith(config.marker) ? line.slice(0, -config.marker.length) : line;
     handler.setBusy(true);
     spinnerStart();
@@ -128,6 +158,10 @@ 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';
@@ -139,19 +173,20 @@ const handler = createInputHandler({
       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);
+      writeTextPreservingLines(toSend);
       handler.setLine(toSend);
+      handler.setBusy(false);
       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));
-    ptyProcess.write(improved);
-    handler.setBusy(false);
+    writeTextPreservingLines(improved);
     handler.setLine(improved);
+    handler.setBusy(false);
   },
 
   onSubmit: (_line) => {},

package/package.json

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

@@ -13,15 +13,25 @@ const SYSTEM_PROMPT =
   'points, markdown formatting, quotes, explanations, or any commentary. ' +
   'Output must contain nothing but the rewritten line itself.';
 
+function isGroq(apiKey) { return apiKey.startsWith('gsk_'); }
+
 function buildAuthHeaders(apiKey) {
-  // The x-goog-api-key header authenticates both "Auth key" (AQ.-prefixed)
-  // and legacy "Standard key" (AIza-prefixed) formats. Authorization: Bearer
-  // does NOT work here - AQ. keys are not OAuth2 access tokens and return
-  // 401 Unauthorized when sent that way (confirmed against the live API).
-  return { 'x-goog-api-key': apiKey };
+  return isGroq(apiKey)
+    ? { 'Authorization': `Bearer ${apiKey}` }
+    : { 'x-goog-api-key': apiKey };
 }
 
 export async function listModels(apiKey) {
+  if (isGroq(apiKey)) {
+    return [
+      'llama-3.1-8b-instant',
+      'llama-3.3-70b-versatile',
+      'gemma2-9b-it',
+      'llama3-8b-8192',
+      'llama-3.1-70b-versatile',
+    ];
+  }
+
   const controller = new AbortController();
   const timeoutId = setTimeout(() => controller.abort(), 10000);
   try {
@@ -45,7 +55,56 @@ export async function listModels(apiKey) {
   }
 }
 
-export async function enhance(text, config, context = null) {
+async function enhanceGroq(text, config, context) {
+  const { geminiApiKey: apiKey, geminiModel: model, timeoutSeconds } = config;
+  const url = 'https://api.groq.com/openai/v1/chat/completions';
+  const controller = new AbortController();
+  let timeoutId;
+
+  const userContent = context
+    ? `Recent terminal context:\n${context}\n\nText:\n${text}`
+    : text;
+
+  try {
+    timeoutId = setTimeout(() => controller.abort(), timeoutSeconds * 1000);
+
+    const response = await fetch(url, {
+      method: 'POST',
+      signal: controller.signal,
+      headers: { 'Content-Type': 'application/json', 'Authorization': `Bearer ${apiKey}` },
+      body: JSON.stringify({
+        model,
+        messages: [
+          { role: 'system', content: SYSTEM_PROMPT },
+          { role: 'user', content: userContent },
+        ],
+        max_tokens: 256,
+      }),
+    });
+
+    if (!response.ok) {
+      if (response.status === 429) throw new RateLimitError('Quota exceeded');
+      else if (response.status === 401 || response.status === 403) throw new AuthError('Invalid key — run ccx-init');
+      else if (response.status === 404) throw new ModelError('Model not found — run ccx-init');
+      else throw new NetworkError(`API error ${response.status}`);
+    }
+
+    const data = await response.json();
+    const result = data.choices[0].message.content.trim();
+    if (!result) throw new NetworkError('Empty response');
+    return result;
+  } catch (err) {
+    if (err.name === 'AbortError') throw new TimeoutError(`Timed out after ${timeoutSeconds}s`);
+    if (err instanceof RateLimitError || err instanceof AuthError ||
+        err instanceof ModelError || err instanceof NetworkError ||
+        err instanceof TimeoutError) throw err;
+    throw new NetworkError('No connection');
+  } finally {
+    clearTimeout(timeoutId);
+  }
+}
+
+async function enhanceGemini(text, config, context) {
   const { geminiApiKey, geminiModel, timeoutSeconds } = config;
   const url = `https://generativelanguage.googleapis.com/v1beta/models/${geminiModel}:generateContent`;
   const controller = new AbortController();
@@ -68,8 +127,8 @@ export async function enhance(text, config, context = null) {
     if (!response.ok) {
       const body = await response.text();
       if (response.status === 429) throw new RateLimitError('Quota exceeded');
-      else if (response.status === 401 || response.status === 403) throw new AuthError('Invalid key — run ccx init');
-      else if (response.status === 404) throw new ModelError('Model not found — run ccx init');
+      else if (response.status === 401 || response.status === 403) throw new AuthError('Invalid key — run ccx-init');
+      else if (response.status === 404) throw new ModelError('Model not found — run ccx-init');
       else throw new NetworkError(`API error ${response.status}: ${body.substring(0, 200)}`);
     }
 
@@ -87,3 +146,9 @@ export async function enhance(text, config, context = null) {
     clearTimeout(timeoutId);
   }
 }
+
+export async function enhance(text, config, context = null) {
+  return isGroq(config.geminiApiKey)
+    ? enhanceGroq(text, config, context)
+    : enhanceGemini(text, config, context);
+}

package/src/input.js

@@ -21,19 +21,42 @@ 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)
@@ -43,7 +66,21 @@ export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough,
   }
 
   function processChunk(chunk) {
-    if (busy) { onPassthrough(chunk); return; }
+    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;
+    }
 
     let i = 0;
     while (i < chunk.length) {
@@ -55,8 +92,13 @@ 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) {
-                onEnhance(lineBuffer, cursor);
+              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);
                 return;
               } else {
                 onSubmit(lineBuffer);
@@ -77,7 +119,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); return; }
+              if (lineBuffer.length > 0) { onEnhance(lineBuffer, cursor, epoch); return; }
             }
           }
           onPassthrough(chunk.slice(i, i + seq.consumed));
@@ -88,7 +130,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);
+            onEnhance(lineBuffer, cursor, epoch);
             return;
           } else {
             onPassthrough(chunk.slice(i, i + 2));
@@ -116,7 +158,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);
+          onEnhance(lineBuffer, cursor, epoch);
           return;
         } else {
           onSubmit(lineBuffer);
@@ -147,5 +189,5 @@ export function createInputHandler({ marker, onEnhance, onSubmit, onPassthrough,
     }
   }
 
-  return { processChunk, setBusy, reset, setLine };
+  return { processChunk, setBusy, reset, setLine, isCurrent };
 }