claude-yes 1.13.0 → 1.14.1

package/dist/cli.js

@@ -5075,6 +5075,238 @@ function sleepms(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// node_modules/terminal-render/dist/index.js
+class TerminalTextRender {
+  lines = [""];
+  cursorRow = 0;
+  cursorCol = 0;
+  savedCursorRow = 0;
+  savedCursorCol = 0;
+  isAtRestoredPosition = false;
+  write(data) {
+    for (let i = 0;i < data.length; i++) {
+      const char = data[i];
+      switch (char) {
+        case "\r":
+          this.cursorCol = 0;
+          break;
+        case `
+`:
+          this.cursorRow++;
+          this.cursorCol = 0;
+          while (this.lines.length <= this.cursorRow) {
+            this.lines.push("");
+          }
+          break;
+        case "\b":
+          if (this.cursorCol > 0) {
+            this.cursorCol--;
+          }
+          break;
+        case "\t":
+          this.cursorCol = Math.floor((this.cursorCol + 8) / 8) * 8;
+          break;
+        default:
+          if (char === "\x1B") {
+            if (this.isEraseSequence(data, i)) {
+              i = this.handleEraseSequence(data, i) - 1;
+            } else if (i + 1 < data.length && data[i + 1] === "[") {
+              const escapeStart = i;
+              i += 2;
+              let escapeEnd = i;
+              while (escapeEnd < data.length && !/[a-zA-Z]/.test(data[escapeEnd])) {
+                escapeEnd++;
+              }
+              if (escapeEnd < data.length) {
+                const escapeCode = data.slice(escapeStart + 2, escapeEnd);
+                const command = data[escapeEnd];
+                this.handleAnsiEscape(escapeCode, command);
+                i = escapeEnd;
+              }
+            } else if (i + 1 < data.length && data[i + 1] === "c") {
+              this.lines = [""];
+              this.cursorRow = 0;
+              this.cursorCol = 0;
+              this.savedCursorRow = 0;
+              this.savedCursorCol = 0;
+              i++;
+            }
+          } else {
+            this.ensureLine(this.cursorRow);
+            const line = this.lines[this.cursorRow];
+            if (this.isAtRestoredPosition && this.cursorCol < line.length) {
+              this.lines[this.cursorRow] = line.substring(0, this.cursorCol) + char + line.substring(this.cursorCol);
+              this.isAtRestoredPosition = false;
+            } else if (this.cursorCol >= line.length) {
+              this.lines[this.cursorRow] = line + " ".repeat(this.cursorCol - line.length) + char;
+            } else {
+              this.lines[this.cursorRow] = line.substring(0, this.cursorCol) + char + line.substring(this.cursorCol + 1);
+            }
+            this.cursorCol++;
+          }
+          break;
+      }
+    }
+    return this;
+  }
+  ensureLine(row) {
+    while (this.lines.length <= row) {
+      this.lines.push("");
+    }
+  }
+  handleAnsiEscape(escapeCode, command) {
+    switch (command) {
+      case "A": {
+        const upLines = parseInt(escapeCode) || 1;
+        this.cursorRow = Math.max(0, this.cursorRow - upLines);
+        break;
+      }
+      case "B": {
+        const downLines = parseInt(escapeCode) || 1;
+        const originalRow = this.cursorRow;
+        this.cursorRow += downLines;
+        if (this.cursorRow > originalRow + 1) {
+          this.cursorCol = 0;
+        }
+        this.ensureLine(this.cursorRow);
+        break;
+      }
+      case "C": {
+        const forwardCols = parseInt(escapeCode) || 1;
+        this.cursorCol += forwardCols;
+        break;
+      }
+      case "D": {
+        const backwardCols = parseInt(escapeCode) || 1;
+        this.cursorCol = Math.max(0, this.cursorCol - backwardCols);
+        break;
+      }
+      case "E": {
+        const nextLines = parseInt(escapeCode) || 1;
+        this.cursorRow += nextLines;
+        this.cursorCol = 0;
+        this.ensureLine(this.cursorRow);
+        break;
+      }
+      case "F": {
+        const prevLines = parseInt(escapeCode) || 1;
+        this.cursorRow = Math.max(0, this.cursorRow - prevLines);
+        this.cursorCol = 0;
+        break;
+      }
+      case "G": {
+        if (escapeCode === "") {
+          const currentLine = this.lines[this.cursorRow] || "";
+          if (this.cursorRow === 0 && this.lines.length === 1 && this.cursorCol === currentLine.length && currentLine.length > 0) {
+            this.cursorCol = Math.max(0, this.cursorCol - 1);
+          } else {
+            this.cursorCol = 0;
+          }
+        } else {
+          const col = parseInt(escapeCode) || 1;
+          this.cursorCol = Math.max(0, col - 1);
+        }
+        break;
+      }
+      case "H":
+      case "f": {
+        const parts = escapeCode.split(";");
+        this.cursorRow = Math.max(0, (parseInt(parts[0]) || 1) - 1);
+        this.cursorCol = Math.max(0, (parseInt(parts[1]) || 1) - 1);
+        this.isAtRestoredPosition = false;
+        this.ensureLine(this.cursorRow);
+        break;
+      }
+      case "J":
+        if (escapeCode === "2") {
+          this.lines = [""];
+          this.cursorRow = 0;
+          this.cursorCol = 0;
+        }
+        break;
+      case "K":
+        if (escapeCode === "" || escapeCode === "0") {
+          this.ensureLine(this.cursorRow);
+          this.lines[this.cursorRow] = this.lines[this.cursorRow].substring(0, this.cursorCol);
+        } else if (escapeCode === "1") {
+          this.ensureLine(this.cursorRow);
+          this.lines[this.cursorRow] = " ".repeat(this.cursorCol) + this.lines[this.cursorRow].substring(this.cursorCol);
+        } else if (escapeCode === "2") {
+          this.ensureLine(this.cursorRow);
+          this.lines[this.cursorRow] = "";
+        }
+        break;
+      case "s":
+        this.savedCursorRow = this.cursorRow;
+        this.savedCursorCol = this.cursorCol;
+        break;
+      case "u":
+        this.cursorRow = this.savedCursorRow;
+        this.cursorCol = this.savedCursorCol;
+        this.isAtRestoredPosition = true;
+        this.ensureLine(this.cursorRow);
+        break;
+    }
+  }
+  render() {
+    const trimmedLines = [...this.lines];
+    while (trimmedLines.length > 1 && trimmedLines[trimmedLines.length - 1] === "") {
+      trimmedLines.pop();
+    }
+    return trimmedLines.join(`
+`);
+  }
+  clear() {
+    this.lines = [""];
+    this.cursorRow = 0;
+    this.cursorCol = 0;
+    this.savedCursorRow = 0;
+    this.savedCursorCol = 0;
+  }
+  isEraseSequence(data, i) {
+    const remaining = data.slice(i);
+    if (!remaining.startsWith("\x1B[2K")) {
+      return false;
+    }
+    let pos = 4;
+    while (pos < remaining.length && remaining.slice(pos, pos + 8) === "\x1B[1A\x1B[2K") {
+      pos += 8;
+    }
+    return pos < remaining.length && remaining.slice(pos, pos + 3) === "\x1B[G";
+  }
+  handleEraseSequence(data, i) {
+    const remaining = data.slice(i);
+    if (!remaining.startsWith("\x1B[2K")) {
+      return i;
+    }
+    let pos = 4;
+    let linesToClear = 1;
+    while (pos < remaining.length && remaining.slice(pos, pos + 8) === "\x1B[1A\x1B[2K") {
+      pos += 8;
+      linesToClear++;
+    }
+    if (pos >= remaining.length || remaining.slice(pos, pos + 3) !== "\x1B[G") {
+      return i;
+    }
+    pos += 3;
+    const currentRow = this.cursorRow;
+    if (linesToClear === 2 && remaining === "\x1B[2K\x1B[1A\x1B[2K\x1B[G") {
+      for (let i2 = 0;i2 < 2 && currentRow + i2 < this.lines.length; i2++) {
+        this.lines[currentRow + i2] = "";
+      }
+      this.cursorCol = 0;
+    } else {
+      const startRow = Math.max(0, currentRow - linesToClear + 1);
+      for (let row = startRow;row <= currentRow && row < this.lines.length; row++) {
+        this.lines[row] = "";
+      }
+      this.cursorRow = startRow;
+      this.cursorCol = 0;
+    }
+    return i + pos;
+  }
+}
+
 // index.ts
 async function claudeYes({
   continueOnCrash,
@@ -5155,17 +5387,22 @@ async function claudeYes({
     }),
     readable: shellOutputStream.readable
   };
+  const ttr = new TerminalTextRender;
   const idleWatcher = createIdleWatcher(async () => {
     if (exitOnIdle) {
-      console.log("Claude is idle, exiting...");
-      await exitClaudeCode();
+      if (ttr.render().match(/esc to interrupt|to run in background/)) {
+        console.warn("[CLAUDE-YES] Claude is idle, but seems still working, not exiting yet");
+      } else {
+        console.warn("[CLAUDE-YES] Claude is idle, exiting...");
+        await exitClaudeCode();
+      }
     }
   }, idleTimeout);
   const confirm = async () => {
     await sleepms(200);
     shell.write("\r");
   };
-  await src_default(fromReadable(process.stdin)).map((buffer2) => buffer2.toString()).by(shellStdio).forkTo((e) => e.map((e2) => removeControlCharacters(e2)).map((e2) => e2.replaceAll("\r", "")).forEach(async (e2) => {
+  await src_default(fromReadable(process.stdin)).forEach(() => idleWatcher.ping()).map((buffer2) => buffer2.toString()).forEach((text) => ttr.write(text)).by(shellStdio).forkTo((e) => e.map((e2) => removeControlCharacters(e2)).map((e2) => e2.replaceAll("\r", "")).forEach(async (e2) => {
     if (e2.match(/❯ 1. Yes/))
       return await confirm();
     if (e2.match(/❯ 1. Dark mode✔|Press Enter to continue…/))
@@ -5174,7 +5411,8 @@ async function claudeYes({
       errorNoConversation = true;
       return;
     }
-  }).run()).replaceAll(/.*(?:\r\n?|\r?\n)/g, (line) => prefix + line).forEach(() => idleWatcher.ping()).map((e) => removeControlCharactersFromStdout ? removeControlCharacters(e) : e).to(fromWritable(process.stdout));
+  }).run()).replaceAll(/.*(?:\r\n?|\r?\n)/g, (line) => prefix + line).map((e) => removeControlCharactersFromStdout ? removeControlCharacters(e) : e).to(fromWritable(process.stdout));
+  return ttr.render();
 }
 // node_modules/enhanced-ms/dist/index.js
 var units = {

package/dist/index.js

@@ -4855,6 +4855,238 @@ function sleepms(ms) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
 
+// node_modules/terminal-render/dist/index.js
+class TerminalTextRender {
+  lines = [""];
+  cursorRow = 0;
+  cursorCol = 0;
+  savedCursorRow = 0;
+  savedCursorCol = 0;
+  isAtRestoredPosition = false;
+  write(data) {
+    for (let i = 0;i < data.length; i++) {
+      const char = data[i];
+      switch (char) {
+        case "\r":
+          this.cursorCol = 0;
+          break;
+        case `
+`:
+          this.cursorRow++;
+          this.cursorCol = 0;
+          while (this.lines.length <= this.cursorRow) {
+            this.lines.push("");
+          }
+          break;
+        case "\b":
+          if (this.cursorCol > 0) {
+            this.cursorCol--;
+          }
+          break;
+        case "\t":
+          this.cursorCol = Math.floor((this.cursorCol + 8) / 8) * 8;
+          break;
+        default:
+          if (char === "\x1B") {
+            if (this.isEraseSequence(data, i)) {
+              i = this.handleEraseSequence(data, i) - 1;
+            } else if (i + 1 < data.length && data[i + 1] === "[") {
+              const escapeStart = i;
+              i += 2;
+              let escapeEnd = i;
+              while (escapeEnd < data.length && !/[a-zA-Z]/.test(data[escapeEnd])) {
+                escapeEnd++;
+              }
+              if (escapeEnd < data.length) {
+                const escapeCode = data.slice(escapeStart + 2, escapeEnd);
+                const command = data[escapeEnd];
+                this.handleAnsiEscape(escapeCode, command);
+                i = escapeEnd;
+              }
+            } else if (i + 1 < data.length && data[i + 1] === "c") {
+              this.lines = [""];
+              this.cursorRow = 0;
+              this.cursorCol = 0;
+              this.savedCursorRow = 0;
+              this.savedCursorCol = 0;
+              i++;
+            }
+          } else {
+            this.ensureLine(this.cursorRow);
+            const line = this.lines[this.cursorRow];
+            if (this.isAtRestoredPosition && this.cursorCol < line.length) {
+              this.lines[this.cursorRow] = line.substring(0, this.cursorCol) + char + line.substring(this.cursorCol);
+              this.isAtRestoredPosition = false;
+            } else if (this.cursorCol >= line.length) {
+              this.lines[this.cursorRow] = line + " ".repeat(this.cursorCol - line.length) + char;
+            } else {
+              this.lines[this.cursorRow] = line.substring(0, this.cursorCol) + char + line.substring(this.cursorCol + 1);
+            }
+            this.cursorCol++;
+          }
+          break;
+      }
+    }
+    return this;
+  }
+  ensureLine(row) {
+    while (this.lines.length <= row) {
+      this.lines.push("");
+    }
+  }
+  handleAnsiEscape(escapeCode, command) {
+    switch (command) {
+      case "A": {
+        const upLines = parseInt(escapeCode) || 1;
+        this.cursorRow = Math.max(0, this.cursorRow - upLines);
+        break;
+      }
+      case "B": {
+        const downLines = parseInt(escapeCode) || 1;
+        const originalRow = this.cursorRow;
+        this.cursorRow += downLines;
+        if (this.cursorRow > originalRow + 1) {
+          this.cursorCol = 0;
+        }
+        this.ensureLine(this.cursorRow);
+        break;
+      }
+      case "C": {
+        const forwardCols = parseInt(escapeCode) || 1;
+        this.cursorCol += forwardCols;
+        break;
+      }
+      case "D": {
+        const backwardCols = parseInt(escapeCode) || 1;
+        this.cursorCol = Math.max(0, this.cursorCol - backwardCols);
+        break;
+      }
+      case "E": {
+        const nextLines = parseInt(escapeCode) || 1;
+        this.cursorRow += nextLines;
+        this.cursorCol = 0;
+        this.ensureLine(this.cursorRow);
+        break;
+      }
+      case "F": {
+        const prevLines = parseInt(escapeCode) || 1;
+        this.cursorRow = Math.max(0, this.cursorRow - prevLines);
+        this.cursorCol = 0;
+        break;
+      }
+      case "G": {
+        if (escapeCode === "") {
+          const currentLine = this.lines[this.cursorRow] || "";
+          if (this.cursorRow === 0 && this.lines.length === 1 && this.cursorCol === currentLine.length && currentLine.length > 0) {
+            this.cursorCol = Math.max(0, this.cursorCol - 1);
+          } else {
+            this.cursorCol = 0;
+          }
+        } else {
+          const col = parseInt(escapeCode) || 1;
+          this.cursorCol = Math.max(0, col - 1);
+        }
+        break;
+      }
+      case "H":
+      case "f": {
+        const parts = escapeCode.split(";");
+        this.cursorRow = Math.max(0, (parseInt(parts[0]) || 1) - 1);
+        this.cursorCol = Math.max(0, (parseInt(parts[1]) || 1) - 1);
+        this.isAtRestoredPosition = false;
+        this.ensureLine(this.cursorRow);
+        break;
+      }
+      case "J":
+        if (escapeCode === "2") {
+          this.lines = [""];
+          this.cursorRow = 0;
+          this.cursorCol = 0;
+        }
+        break;
+      case "K":
+        if (escapeCode === "" || escapeCode === "0") {
+          this.ensureLine(this.cursorRow);
+          this.lines[this.cursorRow] = this.lines[this.cursorRow].substring(0, this.cursorCol);
+        } else if (escapeCode === "1") {
+          this.ensureLine(this.cursorRow);
+          this.lines[this.cursorRow] = " ".repeat(this.cursorCol) + this.lines[this.cursorRow].substring(this.cursorCol);
+        } else if (escapeCode === "2") {
+          this.ensureLine(this.cursorRow);
+          this.lines[this.cursorRow] = "";
+        }
+        break;
+      case "s":
+        this.savedCursorRow = this.cursorRow;
+        this.savedCursorCol = this.cursorCol;
+        break;
+      case "u":
+        this.cursorRow = this.savedCursorRow;
+        this.cursorCol = this.savedCursorCol;
+        this.isAtRestoredPosition = true;
+        this.ensureLine(this.cursorRow);
+        break;
+    }
+  }
+  render() {
+    const trimmedLines = [...this.lines];
+    while (trimmedLines.length > 1 && trimmedLines[trimmedLines.length - 1] === "") {
+      trimmedLines.pop();
+    }
+    return trimmedLines.join(`
+`);
+  }
+  clear() {
+    this.lines = [""];
+    this.cursorRow = 0;
+    this.cursorCol = 0;
+    this.savedCursorRow = 0;
+    this.savedCursorCol = 0;
+  }
+  isEraseSequence(data, i) {
+    const remaining = data.slice(i);
+    if (!remaining.startsWith("\x1B[2K")) {
+      return false;
+    }
+    let pos = 4;
+    while (pos < remaining.length && remaining.slice(pos, pos + 8) === "\x1B[1A\x1B[2K") {
+      pos += 8;
+    }
+    return pos < remaining.length && remaining.slice(pos, pos + 3) === "\x1B[G";
+  }
+  handleEraseSequence(data, i) {
+    const remaining = data.slice(i);
+    if (!remaining.startsWith("\x1B[2K")) {
+      return i;
+    }
+    let pos = 4;
+    let linesToClear = 1;
+    while (pos < remaining.length && remaining.slice(pos, pos + 8) === "\x1B[1A\x1B[2K") {
+      pos += 8;
+      linesToClear++;
+    }
+    if (pos >= remaining.length || remaining.slice(pos, pos + 3) !== "\x1B[G") {
+      return i;
+    }
+    pos += 3;
+    const currentRow = this.cursorRow;
+    if (linesToClear === 2 && remaining === "\x1B[2K\x1B[1A\x1B[2K\x1B[G") {
+      for (let i2 = 0;i2 < 2 && currentRow + i2 < this.lines.length; i2++) {
+        this.lines[currentRow + i2] = "";
+      }
+      this.cursorCol = 0;
+    } else {
+      const startRow = Math.max(0, currentRow - linesToClear + 1);
+      for (let row = startRow;row <= currentRow && row < this.lines.length; row++) {
+        this.lines[row] = "";
+      }
+      this.cursorRow = startRow;
+      this.cursorCol = 0;
+    }
+    return i + pos;
+  }
+}
+
 // index.ts
 async function claudeYes({
   continueOnCrash,
@@ -4935,17 +5167,22 @@ async function claudeYes({
     }),
     readable: shellOutputStream.readable
   };
+  const ttr = new TerminalTextRender;
   const idleWatcher = createIdleWatcher(async () => {
     if (exitOnIdle) {
-      console.log("Claude is idle, exiting...");
-      await exitClaudeCode();
+      if (ttr.render().match(/esc to interrupt|to run in background/)) {
+        console.warn("[CLAUDE-YES] Claude is idle, but seems still working, not exiting yet");
+      } else {
+        console.warn("[CLAUDE-YES] Claude is idle, exiting...");
+        await exitClaudeCode();
+      }
     }
   }, idleTimeout);
   const confirm = async () => {
     await sleepms(200);
     shell.write("\r");
   };
-  await src_default(fromReadable(process.stdin)).map((buffer2) => buffer2.toString()).by(shellStdio).forkTo((e) => e.map((e2) => removeControlCharacters(e2)).map((e2) => e2.replaceAll("\r", "")).forEach(async (e2) => {
+  await src_default(fromReadable(process.stdin)).forEach(() => idleWatcher.ping()).map((buffer2) => buffer2.toString()).forEach((text) => ttr.write(text)).by(shellStdio).forkTo((e) => e.map((e2) => removeControlCharacters(e2)).map((e2) => e2.replaceAll("\r", "")).forEach(async (e2) => {
     if (e2.match(/❯ 1. Yes/))
       return await confirm();
     if (e2.match(/❯ 1. Dark mode✔|Press Enter to continue…/))
@@ -4954,7 +5191,8 @@ async function claudeYes({
       errorNoConversation = true;
       return;
     }
-  }).run()).replaceAll(/.*(?:\r\n?|\r?\n)/g, (line) => prefix + line).forEach(() => idleWatcher.ping()).map((e) => removeControlCharactersFromStdout ? removeControlCharacters(e) : e).to(fromWritable(process.stdout));
+  }).run()).replaceAll(/.*(?:\r\n?|\r?\n)/g, (line) => prefix + line).map((e) => removeControlCharactersFromStdout ? removeControlCharacters(e) : e).to(fromWritable(process.stdout));
+  return ttr.render();
 }
 export {
   removeControlCharacters,

package/index.ts

@@ -1,9 +1,9 @@
-import { fromReadable, fromWritable } from "from-node-stream";
-import sflow from "sflow";
-import { createIdleWatcher } from "./createIdleWatcher";
-import { removeControlCharacters } from "./removeControlCharacters";
-import { sleepms } from "./utils";
-
+import { fromReadable, fromWritable } from 'from-node-stream';
+import sflow from 'sflow';
+import { createIdleWatcher } from './createIdleWatcher';
+import { removeControlCharacters } from './removeControlCharacters';
+import { sleepms } from './utils';
+import { TerminalTextRender } from 'terminal-render';
 // for debug only
 // if (import.meta.main) await main();
 // async function main() {
@@ -42,27 +42,27 @@ export default async function claudeYes({
 } = {}) {
   const defaultTimeout = 5e3; // 5 seconds idle timeout
   const idleTimeout =
-    typeof exitOnIdle === "number" ? exitOnIdle : defaultTimeout;
+    typeof exitOnIdle === 'number' ? exitOnIdle : defaultTimeout;
 
   console.log(
-    "⭐ Starting claude, automatically responding to yes/no prompts...",
+    '⭐ Starting claude, automatically responding to yes/no prompts...'
   );
   console.log(
-    "⚠️ Important Security Warning: Only run this on trusted repositories. This tool automatically responds to prompts and can execute commands without user confirmation. Be aware of potential prompt injection attacks where malicious code or instructions could be embedded in files or user inputs to manipulate the automated responses.",
+    '⚠️ Important Security Warning: Only run this on trusted repositories. This tool automatically responds to prompts and can execute commands without user confirmation. Be aware of potential prompt injection attacks where malicious code or instructions could be embedded in files or user inputs to manipulate the automated responses.'
   );
 
   process.stdin.setRawMode?.(true); //must be called any stdout/stdin usage
-  const prefix = ""; // "YESC|"
+  const prefix = ''; // "YESC|"
   const PREFIXLENGTH = prefix.length;
   let errorNoConversation = false; // match 'No conversation found to continue'
 
   const shellOutputStream = new TransformStream<string, string>();
   const outputWriter = shellOutputStream.writable.getWriter();
   const pty = globalThis.Bun
-    ? await import("bun-pty")
-    : await import("node-pty");
-  let shell = pty.spawn("claude", claudeArgs, {
-    name: "xterm-color",
+    ? await import('bun-pty')
+    : await import('node-pty');
+  let shell = pty.spawn('claude', claudeArgs, {
+    name: 'xterm-color',
     cols: process.stdout.columns - PREFIXLENGTH,
     rows: process.stdout.rows,
     cwd,
@@ -81,13 +81,13 @@ export default async function claudeYes({
     if (continueOnCrash && exitCode !== 0) {
       if (errorNoConversation) {
         console.log(
-          'Claude crashed with "No conversation found to continue", exiting...',
+          'Claude crashed with "No conversation found to continue", exiting...'
         );
         void process.exit(exitCode);
       }
-      console.log("Claude crashed, restarting...");
-      shell = pty.spawn("claude", ["continue", "--continue"], {
-        name: "xterm-color",
+      console.log('Claude crashed, restarting...');
+      shell = pty.spawn('claude', ['continue', '--continue'], {
+        name: 'xterm-color',
         cols: process.stdout.columns - PREFIXLENGTH,
         rows: process.stdout.rows,
         cwd,
@@ -102,7 +102,7 @@ export default async function claudeYes({
 
   const exitClaudeCode = async () => {
     // send exit command to the shell, must sleep a bit to avoid claude treat it as pasted input
-    await sflow(["\r", "/exit", "\r"])
+    await sflow(['\r', '/exit', '\r'])
       .forEach(async (e) => {
         await sleepms(200);
         shell.write(e);
@@ -116,7 +116,7 @@ export default async function claudeYes({
         shell.onExit(() => {
           resolve();
           exited = true;
-        }),
+        })
       ), // resolve when shell exits
       // if shell doesn't exit in 5 seconds, kill it
       new Promise<void>((resolve) =>
@@ -124,13 +124,13 @@ export default async function claudeYes({
           if (exited) return; // if shell already exited, do nothing
           shell.kill(); // kill the shell process if it doesn't exit in time
           resolve();
-        }, 5000),
+        }, 5000)
       ), // 5 seconds timeout
     ]);
   };
 
   // when current tty resized, resize the pty
-  process.stdout.on("resize", () => {
+  process.stdout.on('resize', () => {
     const { columns, rows } = process.stdout;
     shell.resize(columns - PREFIXLENGTH, rows);
   });
@@ -143,24 +143,33 @@ export default async function claudeYes({
     readable: shellOutputStream.readable,
   };
 
+  const ttr = new TerminalTextRender();
   const idleWatcher = createIdleWatcher(async () => {
     if (exitOnIdle) {
-      console.log("Claude is idle, exiting...");
-      await exitClaudeCode();
+      if (ttr.render().match(/esc to interrupt|to run in background/)) {
+        console.warn(
+          '[CLAUDE-YES] Claude is idle, but seems still working, not exiting yet'
+        );
+      } else {
+        console.warn('[CLAUDE-YES] Claude is idle, exiting...');
+        await exitClaudeCode();
+      }
     }
   }, idleTimeout);
   const confirm = async () => {
     await sleepms(200);
-    shell.write("\r");
+    shell.write('\r');
   };
   await sflow(fromReadable<Buffer>(process.stdin))
+    .forEach(() => idleWatcher.ping()) // ping the idle watcher on output for last active time to keep track of claude status
     .map((buffer) => buffer.toString())
+    .forEach((text) => ttr.write(text))
     // .forEach(e => appendFile('.cache/io.log', "input |" + JSON.stringify(e) + '\n')) // for debugging
     .by(shellStdio)
     .forkTo((e) =>
       e
         .map((e) => removeControlCharacters(e as string))
-        .map((e) => e.replaceAll("\r", "")) // remove carriage return
+        .map((e) => e.replaceAll('\r', '')) // remove carriage return
         .forEach(async (e) => {
           if (e.match(/❯ 1. Yes/)) return await confirm();
           if (e.match(/❯ 1. Dark mode✔|Press Enter to continue…/))
@@ -170,15 +179,17 @@ export default async function claudeYes({
             return;
           }
         })
+
         // .forEach(e => appendFile('.cache/io.log', "output|" + JSON.stringify(e) + '\n')) // for debugging
-        .run(),
+        .run()
     )
     .replaceAll(/.*(?:\r\n?|\r?\n)/g, (line) => prefix + line) // add prefix
-    .forEach(() => idleWatcher.ping()) // ping the idle watcher on output for last active time to keep track of claude status
     .map((e) =>
-      removeControlCharactersFromStdout ? removeControlCharacters(e) : e,
+      removeControlCharactersFromStdout ? removeControlCharacters(e) : e
     )
     .to(fromWritable(process.stdout));
+
+  return ttr.render(); // return full rendered logs
 }
 
 export { removeControlCharacters };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-yes",
-  "version": "1.13.0",
+  "version": "1.14.1",
   "homepage": "https://github.com/snomiao/claude-yes#readme",
   "license": "MIT",
   "author": "snomiao <snomiao@gmail.com>",
@@ -62,7 +62,8 @@
   "types": "./index.ts",
   "dependencies": {
     "bun-pty": "^0.3.2",
-    "node-pty": "^1.0.0"
+    "node-pty": "^1.0.0",
+    "terminal-render": "^1.1.0"
   },
   "lint-staged": {
     "*.{ts,js,json,md}": [