claude-yes 1.12.1 → 1.14.0

package/dist/cli.js

@@ -5075,12 +5075,245 @@ 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,
   exitOnIdle,
   claudeArgs = [],
-  cwd = process.cwd()
+  cwd = process.cwd(),
+  removeControlCharactersFromStdout = false
 } = {}) {
   const defaultTimeout = 5000;
   const idleTimeout = typeof exitOnIdle === "number" ? exitOnIdle : defaultTimeout;
@@ -5154,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().includes("esc to interrupt")) {
+        console.log("Claude is idle, but seems still working, not exiting yet");
+      } else {
+        console.log("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…/))
@@ -5173,7 +5411,8 @@ async function claudeYes({
       errorNoConversation = true;
       return;
     }
-  }).run()).replaceAll(/.*(?:\r\n?|\r?\n)/g, (line) => prefix + line).forEach(() => idleWatcher.ping()).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,12 +4855,245 @@ 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,
   exitOnIdle,
   claudeArgs = [],
-  cwd = process.cwd()
+  cwd = process.cwd(),
+  removeControlCharactersFromStdout = false
 } = {}) {
   const defaultTimeout = 5000;
   const idleTimeout = typeof exitOnIdle === "number" ? exitOnIdle : defaultTimeout;
@@ -4934,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().includes("esc to interrupt")) {
+        console.log("Claude is idle, but seems still working, not exiting yet");
+      } else {
+        console.log("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…/))
@@ -4953,7 +5191,8 @@ async function claudeYes({
       errorNoConversation = true;
       return;
     }
-  }).run()).replaceAll(/.*(?:\r\n?|\r?\n)/g, (line) => prefix + line).forEach(() => idleWatcher.ping()).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

@@ -3,7 +3,7 @@ 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() {
@@ -24,17 +24,21 @@ import { sleepms } from "./utils";
  *   4. If it crashes with "No conversation found to continue", exits the process
  * @param options.exitOnIdle - Exit when Claude is idle. Boolean or timeout in milliseconds
  * @param options.claudeArgs - Additional arguments to pass to the Claude CLI
+ * @param options.removeControlCharactersFromStdout - Remove ANSI control characters from stdout. Defaults to !process.stdout.isTTY
  */
 export default async function claudeYes({
   continueOnCrash,
   exitOnIdle,
   claudeArgs = [],
   cwd = process.cwd(),
+  // removeControlCharactersFromStdout = !process.stdout.isTTY,
+  removeControlCharactersFromStdout = false,
 }: {
   continueOnCrash?: boolean;
   exitOnIdle?: boolean | number;
   claudeArgs?: string[];
   cwd?: string;
+  removeControlCharactersFromStdout?: boolean;
 } = {}) {
   const defaultTimeout = 5e3; // 5 seconds idle timeout
   const idleTimeout =
@@ -139,10 +143,15 @@ 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().includes("esc to interrupt")) {
+        console.log("Claude is idle, but seems still working, not exiting yet");
+      } else {
+        console.log("Claude is idle, exiting...");
+        await exitClaudeCode();
+      }
     }
   }, idleTimeout);
   const confirm = async () => {
@@ -150,7 +159,9 @@ export default async function claudeYes({
     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) =>
@@ -166,13 +177,17 @@ export default async function claudeYes({
             return;
           }
         })
+
         // .forEach(e => appendFile('.cache/io.log', "output|" + JSON.stringify(e) + '\n')) // for debugging
         .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) => (!process.stdout.isTTY ? removeControlCharacters(e) : e))  // remove control characters if output is not a TTY
+    .map((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.12.1",
+  "version": "1.14.0",
   "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}": [