claude-overnight 1.16.5 → 1.16.7

package/dist/cli.js

@@ -144,6 +144,9 @@ export function backspaceSegments(segs) {
         return;
     }
 }
+function stripAnsi(s) {
+    return s.replace(/\x1B\[[0-9;]*[a-zA-Z]/g, "");
+}
 // ── Interactive primitives ──
 /**
  * Read a line from the user with bracketed-paste awareness.
@@ -158,12 +161,22 @@ export function ask(question) {
     }
     return new Promise((resolve) => {
         const segs = [];
-        // DEC save/restore cursor + clear-to-end-of-screen so redraws don't pile
-        // up when the input wraps past the terminal width onto additional rows.
+        const tail = question.split("\n").pop() ?? "";
+        const tailVisibleLen = stripAnsi(tail).length;
+        let prevWrapRows = 0;
+        // Only rewrite the input line (and any wrapped continuation rows). The
+        // question header above is never touched, so redraws can't stack copies
+        // even if the initial write scrolled the viewport.
         const redraw = () => {
-            stdout.write("\x1B8\x1B[J" + question + renderSegments(segs));
+            const cols = stdout.columns || 80;
+            if (prevWrapRows > 0)
+                stdout.write(`\x1B[${prevWrapRows}A`);
+            stdout.write("\r\x1B[J");
+            const rendered = renderSegments(segs);
+            stdout.write(tail + rendered);
+            const visible = tailVisibleLen + stripAnsi(rendered).length;
+            prevWrapRows = visible > 0 ? Math.floor((visible - 1) / cols) : 0;
         };
-        stdout.write("\x1B7");
         stdout.write(question);
         stdout.write("\x1B[?2004h");
         try {
@@ -188,7 +201,8 @@ export function ask(question) {
                     redraw();
                     continue;
                 }
-                for (const ch of seg.text) {
+                for (let ci = 0; ci < seg.text.length; ci++) {
+                    const ch = seg.text[ci];
                     if (ch === "\r" || ch === "\n") {
                         stdout.write("\n");
                         cleanup();
@@ -202,11 +216,20 @@ export function ask(question) {
                     }
                     if (ch === "\x7F" || ch === "\b") {
                         backspaceSegments(segs);
+                        redraw();
+                        continue;
+                    }
+                    // Skip ESC and any bytes that are part of an ANSI escape sequence
+                    // (arrow keys, function keys, etc. arrive as \x1B [ ... letter)
+                    if (ch === "\x1B") {
                         continue;
                     }
                     const code = ch.charCodeAt(0);
-                    if (ch !== "\x1B" && code >= 0x20)
-                        appendCharToSegments(segs, ch);
+                    if (code < 0x20)
+                        continue; // control chars
+                    if (code >= 0x7F && code < 0xA0)
+                        continue; // DEL + C1 controls
+                    appendCharToSegments(segs, ch);
                 }
                 redraw();
             }
@@ -241,15 +264,10 @@ export async function select(label, items, defaultIdx = 0) {
         };
         const handler = (buf) => {
             const s = buf.toString();
-            if (s === "\x1B[A") {
-                idx = (idx - 1 + items.length) % items.length;
-                draw();
-            }
-            else if (s === "\x1B[B") {
-                idx = (idx + 1) % items.length;
-                draw();
-            }
-            else if (s === "\r")
+            // Ignore ANSI escape sequences (arrow keys etc.)
+            if (s[0] === "\x1B")
+                return;
+            if (s === "\r")
                 done(items[idx].value);
             else if (s === "\x03") {
                 stdin.setRawMode(false);
@@ -277,6 +295,9 @@ export async function selectKey(label, options) {
         stdin.resume();
         const handler = (buf) => {
             const s = buf.toString().toLowerCase();
+            // Ignore ANSI escape sequences
+            if (s[0] === "\x1B")
+                return;
             if (s === "\x03") {
                 stdin.setRawMode(false);
                 process.exit(0);
@@ -288,7 +309,7 @@ export async function selectKey(label, options) {
                 resolve(keys[0]);
                 return;
             }
-            if (keys.includes(s)) {
+            if (s.length === 1 && keys.includes(s)) {
                 stdin.setRawMode(false);
                 stdin.removeListener("data", handler);
                 stdin.pause();

package/dist/index.js

@@ -166,7 +166,7 @@ async function main() {
     }
     if (argv.includes("-h") || argv.includes("--help")) {
         console.log(`
-  ${chalk.bold("🌙  claude-overnight")} ${chalk.dim("— fire off Claude agents, come back to shipped work")}
+  ${chalk.bold("🌙  claude-overnight")} ${chalk.dim("— background lane for your Claude Max plan")}
   ${chalk.dim("─".repeat(60))}
 
   ${chalk.cyan("Usage")}

package/dist/ui.js

@@ -282,7 +282,13 @@ export class RunDisplay {
                     this.inputSegs = [];
                     return true;
                 }
-                if (ch === "\x1B" || ch === "\x03") {
+                if (ch === "\x03") {
+                    this.inputMode = "none";
+                    this.inputSegs = [];
+                    return true;
+                }
+                // ESC cancels input mode
+                if (ch === "\x1B") {
                     this.inputMode = "none";
                     this.inputSegs = [];
                     return true;
@@ -301,7 +307,8 @@ export class RunDisplay {
         }
         if (this.inputMode === "steer" || this.inputMode === "ask") {
             let dirty = false;
-            for (const ch of s) {
+            for (let ci = 0; ci < s.length; ci++) {
+                const ch = s[ci];
                 if (ch === "\r" || ch === "\n") {
                     const text = segmentsToString(this.inputSegs).trim();
                     const wasAsk = this.inputMode === "ask";
@@ -320,10 +327,18 @@ export class RunDisplay {
                     this.inputSegs = [];
                     return true;
                 }
-                // Ignore raw ESC only — let ANSI sequences (arrows etc.) fall through
-                if (ch === "\x1B" && s.length === 1) {
+                // ESC cancels — consume this byte and any following ANSI sequence bytes
+                if (ch === "\x1B") {
                     this.inputMode = "none";
                     this.inputSegs = [];
+                    // Skip any remaining ANSI sequence bytes (e.g. [A for arrow keys)
+                    while (ci + 1 < s.length) {
+                        const next = s[ci + 1];
+                        const nc = next.charCodeAt(0);
+                        ci++;
+                        if ((nc >= 0x40 && nc <= 0x7E) || nc === 0x7F)
+                            break; // final byte
+                    }
                     return true;
                 }
                 if (ch === "\x7F" || ch === "\b") {
@@ -332,6 +347,10 @@ export class RunDisplay {
                     continue;
                 }
                 const code = ch.charCodeAt(0);
+                if (code < 0x20)
+                    continue; // control chars
+                if (code >= 0x7F && code < 0xA0)
+                    continue; // DEL + C1 controls
                 if (code >= 0x20 && code <= 0x7E && segmentsToString(this.inputSegs).length < MAX_INPUT_LEN) {
                     appendCharToSegments(this.inputSegs, ch);
                     dirty = true;
@@ -339,17 +358,26 @@ export class RunDisplay {
             }
             return dirty;
         }
-        // Hotkey mode
-        if (s === "\x1B" && this.askState && !this.askState.streaming) {
+        // Hotkey mode — only accept single printable ASCII characters
+        // Skip ESC and ANSI sequences entirely
+        if (s.length > 1 && (s[0] === "\x1B" || s.charCodeAt(0) < 0x20))
+            return false;
+        if (s.length !== 1)
+            return false;
+        const key = s[0];
+        const code = key.charCodeAt(0);
+        if (code < 0x20 || code > 0x7E)
+            return false;
+        if (key === "\x1B" && this.askState && !this.askState.streaming) {
             this.askState = undefined;
             return false;
         }
-        if (s === "b" || s === "B") {
+        if (key === "b" || key === "B") {
             this.inputMode = "budget";
             this.inputSegs = [];
             return true;
         }
-        if (s === "t" || s === "T") {
+        if (key === "t" || key === "T") {
             if (this.swarm) {
                 this.inputMode = "threshold";
                 this.inputSegs = [];
@@ -357,7 +385,7 @@ export class RunDisplay {
             }
             return false;
         }
-        if (s === "c" || s === "C") {
+        if (key === "c" || key === "C") {
             if (this.swarm) {
                 this.inputMode = "concurrency";
                 this.inputSegs = [];
@@ -365,7 +393,7 @@ export class RunDisplay {
             }
             return false;
         }
-        if (s === "e" || s === "E") {
+        if (key === "e" || key === "E") {
             if (this.swarm) {
                 this.inputMode = "extra";
                 this.inputSegs = [];
@@ -373,7 +401,7 @@ export class RunDisplay {
             }
             return false;
         }
-        if (s === "p" || s === "P") {
+        if (key === "p" || key === "P") {
             if (this.swarm) {
                 const next = !this.swarm.paused;
                 this.swarm.setPaused(next);
@@ -383,20 +411,20 @@ export class RunDisplay {
             }
             return false;
         }
-        if ((s === "f" || s === "F") && this.swarm && this.swarm.failed > 0 && this.swarm.active > 0) {
+        if ((key === "f" || key === "F") && this.swarm && this.swarm.failed > 0 && this.swarm.active > 0) {
             this.swarm.requeueFailed();
             return false;
         }
-        if ((s === "r" || s === "R") && this.swarm && this.swarm.rateLimitPaused > 0) {
+        if ((key === "r" || key === "R") && this.swarm && this.swarm.rateLimitPaused > 0) {
             this.swarm.retryRateLimitNow();
             return true;
         }
-        if ((s === "s" || s === "S") && this.onSteer) {
+        if ((key === "s" || key === "S") && this.onSteer) {
             this.inputMode = "steer";
             this.inputSegs = [];
             return true;
         }
-        if (s === "?" && this.onAsk && this.swarm && !this.askBusy) {
+        if (key === "?" && this.onAsk && this.swarm && !this.askBusy) {
             if (this.askState && !this.askState.streaming) {
                 this.askState = undefined;
                 return false;
@@ -405,7 +433,7 @@ export class RunDisplay {
             this.inputSegs = [];
             return true;
         }
-        if (s === "q" || s === "Q" || s === "\x03") {
+        if (key === "q" || key === "Q" || key === "\x03") {
             if (this.swarm) {
                 if (this.swarm.aborted)
                     process.exit(0);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-overnight",
-  "version": "1.16.5",
+  "version": "1.16.7",
   "description": "Background lane for your Claude Max plan. Parallel Claude Agent SDK sessions in git worktrees with a usage cap that reserves headroom for your interactive Claude Code. Crash-safe resume. Opus/Sonnet/Haiku + Qwen/OpenRouter.",
   "type": "module",
   "bin": {