groundcrew-cli 0.15.9 → 0.15.11

package/dist/index.js

@@ -426,8 +426,14 @@ function setupInlineSuggestions(rl) {
       buf.push(`\x1B[${dropdownLines}A`);
       dropdownLines = 0;
     }
-    buf.push("\x1B[K");
-    ghostLen = 0;
+    if (ghostLen > 0) {
+      buf.push("\x1B[s");
+      buf.push("\x1B[999C");
+      buf.push(`\x1B[${ghostLen}D`);
+      buf.push("\x1B[K");
+      buf.push("\x1B[u");
+      ghostLen = 0;
+    }
     if (buf.length) process.stdout.write(buf.join(""));
   };
   const showGhost = () => {
@@ -456,13 +462,14 @@ function setupInlineSuggestions(rl) {
       }
       dropdownLines = count;
       buf.push(`\x1B[${count}A`);
-      const prompt = rl._prompt || "";
-      const inputLine = rl.line || "";
-      buf.push(`\r${prompt}${inputLine}`);
+      buf.push(`\r`);
     }
     process.stdout.write(buf.join(""));
-    if (dropdownLines > 0 && remainder) {
-      process.stdout.write(`\x1B[K\x1B[2m${remainder}\x1B[0m\x1B[${remainder.length}D`);
+    if (dropdownLines > 0) {
+      rl._refreshLine();
+      if (remainder) {
+        process.stdout.write(`\x1B[K\x1B[2m${remainder}\x1B[0m\x1B[${remainder.length}D`);
+      }
     }
   };
   process.stdin.on("keypress", (_ch, key) => {
@@ -474,18 +481,55 @@ function setupInlineSuggestions(rl) {
   });
 }
 async function chat(explicitSession) {
-  process.stdout.write("\x1B[>1u");
+  process.stdout.write("\x1B[?2004h\x1B[>1u");
   const originalStdinEmit = process.stdin.emit.bind(process.stdin);
-  let pendingShiftEnter = false;
+  let pasteBuffer = "";
+  let isPasting = false;
   process.stdin.emit = function(event, ...args) {
     if (event === "data") {
       const data = args[0];
-      const str = typeof data === "string" ? data : data.toString();
+      let str = typeof data === "string" ? data : data.toString();
+      const pasteStart = str.indexOf("\x1B[200~");
+      if (pasteStart !== -1) {
+        isPasting = true;
+        if (pasteStart > 0) {
+          originalStdinEmit(event, Buffer.from(str.slice(0, pasteStart)));
+        }
+        str = str.slice(pasteStart + 6);
+      }
+      if (isPasting) {
+        const pasteEnd = str.indexOf("\x1B[201~");
+        if (pasteEnd !== -1) {
+          pasteBuffer += str.slice(0, pasteEnd);
+          const afterPaste = str.slice(pasteEnd + 6);
+          isPasting = false;
+          const pasted = pasteBuffer.replace(/[\r\n]+$/, "");
+          pasteBuffer = "";
+          if (pasted.includes("\n") || pasted.includes("\r")) {
+            const lines = pasted.split(/\r?\n/);
+            for (let i = 0; i < lines.length - 1; i++) {
+              originalStdinEmit(event, Buffer.from(lines[i] + "\\\r"));
+            }
+            originalStdinEmit(event, Buffer.from(lines[lines.length - 1]));
+          } else {
+            originalStdinEmit(event, Buffer.from(pasted));
+          }
+          if (afterPaste) {
+            return originalStdinEmit(event, Buffer.from(afterPaste));
+          }
+          return false;
+        } else {
+          pasteBuffer += str;
+          return false;
+        }
+      }
       if (str.includes("\x1B[13;2u")) {
-        pendingShiftEnter = true;
         const replaced = str.replace(/\x1b\[13;2u/g, "\\\r");
         return originalStdinEmit(event, Buffer.from(replaced));
       }
+      if (str === "\x1B\r" || str === "\x1B\n") {
+        return originalStdinEmit(event, Buffer.from("\\\r"));
+      }
     }
     return originalStdinEmit(event, ...args);
   };
@@ -543,7 +587,7 @@ async function chat(explicitSession) {
   console.log();
   let continuationBuffer = [];
   rl.on("close", () => {
-    process.stdout.write("\x1B[<u");
+    process.stdout.write("\x1B[?2004l\x1B[<u");
     console.log(dim("\nBye."));
     process.exit(0);
   });

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "groundcrew-cli",
-  "version": "0.15.9",
+  "version": "0.15.11",
   "description": "CLI companion for Groundcrew — queue tasks, send feedback, monitor your Copilot agent from another terminal.",
   "type": "module",
   "bin": {

package/src/index.ts

@@ -559,10 +559,17 @@ function setupInlineSuggestions(rl: readline.Interface): void {
       buf.push(`\x1b[${dropdownLines}A`); // back up to prompt line
       dropdownLines = 0;
     }
-    // Clear inline ghost: readline already repositioned cursor at end of
-    // typed text after processing the keypress, so just clear to EOL
-    buf.push("\x1b[K");
-    ghostLen = 0;
+    // Clear inline ghost only if one is showing — save cursor, jump to
+    // ghost start (far right), erase it, then restore cursor position.
+    // This avoids nuking typed text when cursor is mid-line (left arrow).
+    if (ghostLen > 0) {
+      buf.push("\x1b[s");                   // save cursor position
+      buf.push("\x1b[999C");                // jump to far right of line
+      buf.push(`\x1b[${ghostLen}D`);        // back up to ghost start
+      buf.push("\x1b[K");                   // clear from ghost start to EOL
+      buf.push("\x1b[u");                   // restore cursor position
+      ghostLen = 0;
+    }
     if (buf.length) process.stdout.write(buf.join(""));
   };
 
@@ -604,25 +611,28 @@ function setupInlineSuggestions(rl: readline.Interface): void {
       }
       dropdownLines = count;
 
-      // Move back up to prompt line
+      // Back to prompt line and restore horizontal position
+      // Move up to prompt line
       buf.push(`\x1b[${count}A`);
-      // Redraw prompt line manually (NOT _refreshLine — it clears screen below)
-      const prompt = (rl as any)._prompt || "";
-      const inputLine = (rl as any).line || "";
-      buf.push(`\r${prompt}${inputLine}`);
+      // Move to column 1, then rewrite prompt+line to position cursor correctly
+      buf.push(`\r`);
+      // Let readline handle cursor positioning
     }
 
     process.stdout.write(buf.join(""));
-    // Re-draw inline ghost after prompt redraw (for dropdown case)
-    if (dropdownLines > 0 && remainder) {
-      process.stdout.write(`\x1b[K\x1b[2m${remainder}\x1b[0m\x1b[${remainder.length}D`);
+    // After dropdown, force readline to redraw prompt line to fix cursor position
+    if (dropdownLines > 0) {
+      (rl as any)._refreshLine();
+      // Re-draw inline ghost since _refreshLine cleared it
+      if (remainder) {
+        process.stdout.write(`\x1b[K\x1b[2m${remainder}\x1b[0m\x1b[${remainder.length}D`);
+      }
     }
   };
 
   process.stdin.on("keypress", (_ch: string, key: any) => {
     if (!key) return;
 
-
     clearGhost();
     if (key.name !== "return" && key.name !== "tab") {
       setImmediate(showGhost);
@@ -631,25 +641,74 @@ function setupInlineSuggestions(rl: readline.Interface): void {
 }
 
 async function chat(explicitSession?: string): Promise<void> {
-  // Enable Kitty keyboard protocol for Shift+Enter detection
-  // iTerm2, Kitty, WezTerm, and other modern terminals support this
-  process.stdout.write("\x1b[>1u");
+  // Enable bracketed paste mode + Kitty keyboard protocol (Shift+Enter detection)
+  process.stdout.write("\x1b[?2004h\x1b[>1u");
 
-  // Intercept raw stdin to detect Shift+Enter (\x1b[13;2u) before readline
-  // Transform it into backslash + Enter for line continuation
+  // Intercept raw stdin for:
+  // 1. Bracketed paste (\x1b[200~ ... \x1b[201~) — buffer paste, submit as single task
+  // 2. Shift+Enter (\x1b[13;2u via Kitty protocol) — line continuation
+  // 3. Alt+Enter (\x1b\r — universal fallback) — line continuation
   const originalStdinEmit = process.stdin.emit.bind(process.stdin);
-  let pendingShiftEnter = false;
+  let pasteBuffer = "";
+  let isPasting = false;
+
   process.stdin.emit = function (event: string, ...args: any[]) {
     if (event === "data") {
       const data = args[0] as Buffer | string;
-      const str = typeof data === "string" ? data : data.toString();
+      let str = typeof data === "string" ? data : data.toString();
+
+      // --- Bracketed paste handling ---
+      const pasteStart = str.indexOf("\x1b[200~");
+      if (pasteStart !== -1) {
+        isPasting = true;
+        if (pasteStart > 0) {
+          originalStdinEmit(event, Buffer.from(str.slice(0, pasteStart)));
+        }
+        str = str.slice(pasteStart + 6); // skip \x1b[200~
+      }
+
+      if (isPasting) {
+        const pasteEnd = str.indexOf("\x1b[201~");
+        if (pasteEnd !== -1) {
+          pasteBuffer += str.slice(0, pasteEnd);
+          const afterPaste = str.slice(pasteEnd + 6);
+          isPasting = false;
+
+          const pasted = pasteBuffer.replace(/[\r\n]+$/, "");
+          pasteBuffer = "";
+
+          if (pasted.includes("\n") || pasted.includes("\r")) {
+            // Multi-line paste: use backslash continuation for each internal line
+            const lines = pasted.split(/\r?\n/);
+            for (let i = 0; i < lines.length - 1; i++) {
+              originalStdinEmit(event, Buffer.from(lines[i] + "\\\r"));
+            }
+            // Last line: insert without auto-submit
+            originalStdinEmit(event, Buffer.from(lines[lines.length - 1]));
+          } else {
+            originalStdinEmit(event, Buffer.from(pasted));
+          }
+
+          if (afterPaste) {
+            return originalStdinEmit(event, Buffer.from(afterPaste));
+          }
+          return false;
+        } else {
+          pasteBuffer += str;
+          return false;
+        }
+      }
+
+      // --- Shift+Enter (Kitty protocol: \x1b[13;2u) ---
       if (str.includes("\x1b[13;2u")) {
-        // Shift+Enter detected — append backslash and submit for continuation
-        pendingShiftEnter = true;
-        // Replace the Kitty sequence with backslash + carriage return
         const replaced = str.replace(/\x1b\[13;2u/g, "\\\r");
         return originalStdinEmit(event, Buffer.from(replaced));
       }
+
+      // --- Alt+Enter (universal fallback: ESC + CR) ---
+      if (str === "\x1b\r" || str === "\x1b\n") {
+        return originalStdinEmit(event, Buffer.from("\\\r"));
+      }
     }
     return originalStdinEmit(event, ...args);
   } as any;
@@ -714,9 +773,9 @@ async function chat(explicitSession?: string): Promise<void> {
 
   let continuationBuffer: string[] = [];
 
-  // Handle Ctrl+C gracefully — disable Kitty protocol on exit
+  // Handle Ctrl+C gracefully
   rl.on("close", () => {
-    process.stdout.write("\x1b[<u"); // disable Kitty keyboard protocol
+    process.stdout.write("\x1b[?2004l\x1b[<u"); // disable bracketed paste + Kitty
     console.log(dim("\nBye."));
     process.exit(0);
   });