claude-yes 1.24.1 → 1.25.0

package/{index.ts → ts/index.ts}

@@ -5,6 +5,8 @@ import DIE from 'phpdie';
 import sflow from 'sflow';
 import { TerminalTextRender } from 'terminal-render';
 import tsaComposer from 'tsa-composer';
+import rawConfig from '../cli-yes.config.js';
+import { defineCliYesConfig } from './defineConfig.js';
 import { IdleWaiter } from './idleWaiter';
 import { ReadyManager } from './ReadyManager';
 import { removeControlCharacters } from './removeControlCharacters';
@@ -14,74 +16,36 @@ import {
   shouldUseLock,
   updateCurrentTaskStatus,
 } from './runningLock';
-
-// const yesLog = tsaComposer()(async function yesLog(msg: string) {
-//   // await rm('agent-yes.log').catch(() => null); // ignore error if file doesn't exist
-//   await appendFile("agent-yes.log", `${msg}\n`).catch(() => null);
-// });
-
-export const CLI_CONFIGURES: Record<
-  string,
-  {
-    install?: string; // hint user for install command if not installed
-    binary?: string; // actual binary name if different from cli
-    ready?: RegExp[]; // regex matcher for stdin ready, or line index for gemini
-    enter?: RegExp[]; // array of regex to match for sending Enter
-    fatal?: RegExp[]; // array of regex to match for fatal errors
-    ensureArgs?: (args: string[]) => string[]; // function to ensure certain args are present
-  }
-> = {
-  grok: {
-    install: 'npm install -g @vibe-kit/grok-cli',
-    ready: [/^  │ ❯ /],
-    enter: [/^   1. Yes/],
-  },
-  claude: {
-    install: 'npm install -g @anthropic-ai/claude-code',
-    // ready: [/^> /], // regex matcher for stdin ready
-    ready: [/\? for shortcuts/], // regex matcher for stdin ready
-    enter: [/❯ 1. Yes/, /❯ 1. Dark mode✔/, /Press Enter to continue…/],
-    fatal: [
-      /No conversation found to continue/,
-      /⎿  Claude usage limit reached\./,
-    ],
-  },
-  gemini: {
-    install: 'npm install -g @google/gemini-cli',
-    // match the agent prompt after initial lines; handled by index logic using line index
-    ready: [/Type your message/], // used with line index check
-    enter: [/│ ● 1. Yes, allow once/],
-    fatal: [],
-  },
-  codex: {
-    install: 'npm install -g @openai/codex-cli',
-    ready: [/⏎ send/],
-    enter: [
-      /> 1. Yes, allow Codex to work in this folder/,
-      /> 1. Approve and run now/,
-    ],
-    fatal: [/Error: The cursor position could not be read within/],
-    // add to codex --search by default when not provided by the user
-    ensureArgs: (args: string[]) => {
-      if (!args.includes('--search')) return ['--search', ...args];
-      return args;
-    },
-  },
-  copilot: {
-    install: 'npm install -g @github/copilot',
-    ready: [/^ +> /, /Ctrl\+c Exit/],
-    enter: [/ │ ❯ 1. Yes, proceed/, /❯ 1. Yes/],
-    fatal: [],
-  },
-  cursor: {
-    install: 'open https://cursor.com/ja/docs/cli/installation',
-    // map logical "cursor" cli name to actual binary name
-    binary: 'cursor-agent',
-    ready: [/\/ commands/],
-    enter: [/→ Run \(once\) \(y\) \(enter\)/, /▶ \[a\] Trust this workspace/],
-    fatal: [/^  Error: You've hit your usage limit/],
-  },
+import { catcher } from './tryCatch';
+import { deepMixin } from './utils';
+import { yesLog } from './yesLog';
+
+export type AgentCliConfig = {
+  install?: string; // hint user for install command if not installed
+  version?: string; // hint user for version command to check if installed
+  binary?: string; // actual binary name if different from cli, e.g. cursor -> cursor-agent
+  ready?: RegExp[]; // regex matcher for stdin ready, or line index for gemini
+  enter?: RegExp[]; // array of regex to match for sending Enter
+  fatal?: RegExp[]; // array of regex to match for fatal errors
+  restoreArgs?: string[]; // arguments to continue the session when crashed
+  defaultArgs?: string[]; // function to ensure certain args are present
+  noEOL?: boolean; // if true, do not split lines by \n, used for codex, which uses cursor-move csi code instead of \n to move lines
+  promptArg?: (string & {}) | 'first-arg' | 'last-arg'; // argument name to pass the prompt, e.g. --prompt, or first-arg for positional arg
 };
+export type CliYesConfig = {
+  clis: { [key: string]: AgentCliConfig };
+};
+
+// load user config from cli-yes.config.ts if exists
+export const config = await rawConfig;
+
+export const CLIS_CONFIG = config.clis as Record<
+  keyof Awaited<typeof config>['clis'],
+  AgentCliConfig
+>;
+export type SUPPORTED_CLIS = keyof typeof CLIS_CONFIG;
+export const SUPPORTED_CLIS = Object.keys(CLIS_CONFIG) as SUPPORTED_CLIS[];
+
 /**
  * Main function to run agent-cli with automatic yes/no responses
  * @param options Configuration options
@@ -97,77 +61,86 @@ export const CLI_CONFIGURES: Record<
  *
  * @example
  * ```typescript
- * import claudeYes from 'claude-yes';
- * await claudeYes({
+ * import cliYes from 'cli-yes';
+ * await cliYes({
  *   prompt: 'help me solve all todos in my codebase',
  *
  *   // optional
- *   cli: 'claude',
- *   cliArgs: ['--verbose'], // additional args to pass to claude
+ *   cliArgs: ['--verbose'], // additional args to pass to agent-cli
  *   exitOnIdle: 30000, // exit after 30 seconds of idle
- *   continueOnCrash: true, // restart if claude crashes, default is true
+ *   robust: true, // auto restart with --continue if claude crashes, default is true
  *   logFile: 'claude.log', // save logs to file
  *   disableLock: false, // disable running lock (default is false)
  * });
  * ```
  */
-export default async function claudeYes({
-  cli = 'claude',
+export default async function cliYes({
+  cli,
   cliArgs = [],
   prompt,
-  continueOnCrash,
+  robust = true,
   cwd,
   env,
   exitOnIdle,
   logFile,
   removeControlCharactersFromStdout = false, // = !process.stdout.isTTY,
   verbose = false,
-  disableLock = false,
+  queue = true,
 }: {
-  cli?: (string & {}) | keyof typeof CLI_CONFIGURES;
+  cli: SUPPORTED_CLIS;
   cliArgs?: string[];
   prompt?: string;
-  continueOnCrash?: boolean;
+  robust?: boolean;
   cwd?: string;
   env?: Record<string, string>;
   exitOnIdle?: number;
   logFile?: string;
   removeControlCharactersFromStdout?: boolean;
   verbose?: boolean;
-  disableLock?: boolean;
-} = {}) {
-  const continueArgs = {
-    codex: 'resume --last'.split(' '),
-    claude: '--continue'.split(' '),
-    gemini: [], // not possible yet
-  };
+  queue?: boolean;
+}) {
+  // those overrides seems only works in bun
+  // await Promise.allSettled([
+  //   import(path.join(process.cwd(), "cli-yes.config")),
+  // ])
+  //   .then((e) => e.flatMap((e) => (e.status === "fulfilled" ? [e.value] : [])))
+  //   .then(e=>e.at(0))
+  //   .then((e) => e.default as ReturnType<typeof defineCliYesConfig>)
+  //   .then(async (override) => deepMixin(config, override || {}))
+  //   .catch((error) => {
+  //     if (process.env.VERBOSE)
+  //       console.warn("Fail to load cli-yes.config.ts", error);
+  //   });
+
+  if (!cli) throw new Error(`cli is required`);
+  const conf = CLIS_CONFIG[cli] || DIE(`Unsupported cli tool: ${cli}`);
 
   // Acquire lock before starting agent (if in git repo or same cwd and lock is not disabled)
   const workingDir = cwd ?? process.cwd();
-  if (!disableLock && shouldUseLock(workingDir)) {
-    await acquireLock(workingDir, prompt ?? 'Interactive session');
-  }
-
-  // Register cleanup handlers for lock release
-  const cleanupLock = async () => {
-    if (!disableLock && shouldUseLock(workingDir)) {
-      await releaseLock().catch(() => null); // Ignore errors during cleanup
+  if (queue) {
+    if (queue && shouldUseLock(workingDir)) {
+      await acquireLock(workingDir, prompt ?? 'Interactive session');
     }
-  };
 
-  process.on('exit', () => {
-    if (!disableLock) {
-      releaseLock().catch(() => null);
-    }
-  });
-  process.on('SIGINT', async () => {
-    await cleanupLock();
-    process.exit(130);
-  });
-  process.on('SIGTERM', async () => {
-    await cleanupLock();
-    process.exit(143);
-  });
+    // Register cleanup handlers for lock release
+    const cleanupLock = async () => {
+      if (queue && shouldUseLock(workingDir)) {
+        await releaseLock().catch(() => null); // Ignore errors during cleanup
+      }
+    };
+
+    process.on('exit', () => {
+      if (queue) releaseLock().catch(() => null);
+    });
+    process.on('SIGINT', async (code) => {
+      await cleanupLock();
+      process.exit(code);
+    });
+    process.on('SIGTERM', async (code) => {
+      await cleanupLock();
+      process.exit(code);
+    });
+  }
 
   process.stdin.setRawMode?.(true); // must be called any stdout/stdin usage
   let isFatal = false; // when true, do not restart on crash, and exit agent
@@ -193,21 +166,49 @@ export default async function claudeYes({
   });
 
   // Apply CLI specific configurations (moved to CLI_CONFIGURES)
-  const cliConf = (CLI_CONFIGURES as Record<string, any>)[cli] || {};
-  cliArgs = cliConf.ensureArgs?.(cliArgs) ?? cliArgs;
+  const cliConf = (CLIS_CONFIG as Record<string, AgentCliConfig>)[cli] || {};
+  cliArgs = cliConf.defaultArgs
+    ? [...cliConf.defaultArgs, ...cliArgs]
+    : cliArgs;
+
+  if (prompt && cliConf.promptArg) {
+    if (cliConf.promptArg === 'first-arg') {
+      cliArgs = [prompt, ...cliArgs];
+      prompt = undefined; // clear prompt to avoid sending later
+    } else if (cliConf.promptArg === 'last-arg') {
+      cliArgs = [...cliArgs, prompt];
+      prompt = undefined; // clear prompt to avoid sending later
+    } else if (cliConf.promptArg.startsWith('--')) {
+      cliArgs = [cliConf.promptArg, prompt, ...cliArgs];
+      prompt = undefined; // clear prompt to avoid sending later
+    } else {
+      console.warn(`Unknown promptArg format: ${cliConf.promptArg}`);
+    }
+  }
   const cliCommand = cliConf?.binary || cli;
 
-  let shell = tryCatch(
-    () => pty.spawn(cliCommand, cliArgs, getPtyOptions()),
+  let shell = catcher(
     (error: unknown) => {
       console.error(`Fatal: Failed to start ${cliCommand}.`);
-      if (cliConf?.install)
+      if (cliConf?.install && isCommandNotFoundError(error))
         console.error(
           `If you did not installed it yet, Please install it first: ${cliConf.install}`,
         );
       throw error;
+
+      function isCommandNotFoundError(e: unknown) {
+        if (e instanceof Error) {
+          return (
+            e.message.includes('command not found') ||
+            e.message.includes('ENOENT') ||
+            e.message.includes('spawn') // windows
+          );
+        }
+        return false;
+      }
     },
-  );
+    () => pty.spawn(cliCommand, cliArgs, getPtyOptions()),
+  )();
   const pendingExitCode = Promise.withResolvers<number | null>();
   let pendingExitCodeValue = null;
 
@@ -215,22 +216,22 @@ export default async function claudeYes({
   // npm install -g @anthropic-ai/claude-code
 
   async function onData(data: string) {
-    nextStdout.ready();
     // append data to the buffer, so we can process it later
     await outputWriter.write(data);
   }
 
   shell.onData(onData);
   shell.onExit(function onExit({ exitCode }) {
-    nextStdout.ready();
     stdinReady.unready(); // start buffer stdin
     const agentCrashed = exitCode !== 0;
-    const continueArg = (continueArgs as Record<string, string[]>)[cli];
 
-    if (agentCrashed && continueOnCrash && continueArg) {
-      if (!continueArg) {
+    if (agentCrashed && robust && conf?.restoreArgs) {
+      if (!conf.restoreArgs) {
         return console.warn(
-          `continueOnCrash is only supported for ${Object.keys(continueArgs).join(', ')} currently, not ${cli}`,
+          `robust is only supported for ${Object.entries(CLIS_CONFIG)
+            .filter(([_, v]) => v.restoreArgs)
+            .map(([k]) => k)
+            .join(', ')} currently, not ${cli}`,
         );
       }
       if (isFatal) {
@@ -239,7 +240,7 @@ export default async function claudeYes({
 
       console.log(`${cli} crashed, restarting...`);
 
-      shell = pty.spawn(cli, continueArg, getPtyOptions());
+      shell = pty.spawn(cli, conf.restoreArgs, getPtyOptions());
       shell.onData(onData);
       shell.onExit(onExit);
       return;
@@ -295,7 +296,8 @@ export default async function claudeYes({
       readable: shellOutputStream.readable,
     })
     .forEach(() => idleWaiter.ping())
-    .forEach((text) => {
+    .forEach(() => nextStdout.ready())
+    .forEach(async (text) => {
       terminalRender.write(text);
       // todo: .onStatus((msg)=> shell.write(msg))
       if (process.stdin.isTTY) return; // only handle it when stdin is not tty
@@ -307,7 +309,7 @@ export default async function claudeYes({
       // const rendered = terminalRender.render();
       const { col, row } = terminalRender.getCursorPosition();
       shell.write(`\u001b[${row};${col}R`); // reply cli when getting cursor position
-      // await yesLog(`cursor|respond position: row=${row}, col=${col}`);
+      await yesLog`cursor|respond position: row=${String(row)}, col=${String(col)}`;
       // const row = rendered.split('\n').length + 1;
       // const col = (rendered.split('\n').slice(-1)[0]?.length || 0) + 1;
     })
@@ -318,33 +320,29 @@ export default async function claudeYes({
         .map((e) => removeControlCharacters(e))
         .map((e) => e.replaceAll('\r', '')) // remove carriage return
         .by((s) => {
-          if (cli === 'codex') return s; // codex use cursor-move csi code insteadof \n to move lines, so the output have no \n at all, this hack prevents stuck on unended line
+          if (conf.noEOL) return s; // codex use cursor-move csi code insteadof \n to move lines, so the output have no \n at all, this hack prevents stuck on unended line
           return s.lines({ EOL: 'NONE' }); // other clis use ink, which is rerendering the block based on \n lines
         })
-        // .forEach((e) => yesLog`output|${e}`) // for debugging
+        .forEach((e) => yesLog`output|${e}`) // for debugging
         // Generic auto-response handler driven by CLI_CONFIGURES
         .forEach(async (e, i) => {
-          const conf =
-            CLI_CONFIGURES[cli as keyof typeof CLI_CONFIGURES] || null;
-          if (!conf) return;
-
           // ready matcher: if matched, mark stdin ready
           if (conf.ready?.some((rx: RegExp) => e.match(rx))) {
-            // await yesLog`ready |${e}`;
+            await yesLog`ready |${e}`;
             if (cli === 'gemini' && i <= 80) return; // gemini initial noise, only after many lines
             stdinReady.ready();
           }
 
           // enter matchers: send Enter when any enter regex matches
           if (conf.enter?.some((rx: RegExp) => e.match(rx))) {
-            // await yesLog`enter |${e}`;
+            await yesLog`enter |${e}`;
             await sendEnter(300); // send Enter after 300ms idle wait
             return;
           }
 
           // fatal matchers: set isFatal flag when matched
           if (conf.fatal?.some((rx: RegExp) => e.match(rx))) {
-            // await yesLog`fatal |${e}`;
+            await yesLog`fatal |${e}`;
             isFatal = true;
             await exitAgent();
           }
@@ -365,7 +363,7 @@ export default async function claudeYes({
   console.log(`[${cli}-yes] ${cli} exited with code ${exitCode}`);
 
   // Update task status and release lock
-  if (!disableLock && shouldUseLock(workingDir)) {
+  if (queue && shouldUseLock(workingDir)) {
     await updateCurrentTaskStatus(
       exitCode === 0 ? 'completed' : 'failed',
     ).catch(() => null);
@@ -389,24 +387,40 @@ export default async function claudeYes({
     await idleWaiter.wait(waitms);
     const et = Date.now();
     // process.stdout.write(`\ridleWaiter.wait(${waitms}) took ${et - st}ms\r`);
-    // await yesLog`sendEn| idleWaiter.wait(${String(waitms)}) took ${String(et - st)}ms`;
-
+    await yesLog`sendEn| idleWaiter.wait(${String(waitms)}) took ${String(et - st)}ms`;
+    nextStdout.unready();
     shell.write('\r');
+    // retry once if not received any output in 1 second after sending Enter
+    await Promise.race([
+      nextStdout.wait(),
+      new Promise<void>((resolve) =>
+        setTimeout(() => {
+          if (!nextStdout.ready) {
+            shell.write('\r');
+          }
+          resolve();
+        }, 1000),
+      ),
+    ]);
   }
 
   async function sendMessage(message: string) {
     await stdinReady.wait();
     // show in-place message: write msg and move cursor back start
-    // await yesLog`send  |${message}`;
-    shell.write(message);
+    yesLog`send  |${message}`;
     nextStdout.unready();
+    shell.write(message);
     idleWaiter.ping(); // just sent a message, wait for echo
+    yesLog`waiting next stdout|${message}`;
     await nextStdout.wait();
-    await sendEnter();
+    yesLog`sending enter`;
+    await sendEnter(1000);
+    yesLog`sent enter`;
   }
 
   async function exitAgent() {
-    continueOnCrash = false;
+    robust = false; // disable robust to avoid auto restart
+
     // send exit command to the shell, must sleep a bit to avoid claude treat it as pasted input
     await sendMessage('/exit');
 
@@ -438,11 +452,3 @@ export default async function claudeYes({
 }
 
 export { removeControlCharacters };
-
-function tryCatch<T, R>(fn: () => T, catchFn: (error: unknown) => R): T | R {
-  try {
-    return fn();
-  } catch (error) {
-    return catchFn(error);
-  }
-}

package/ts/postbuild.ts

@@ -0,0 +1,18 @@
+#! /usr/bin/env bun
+import { execaCommand } from 'execa';
+import { copyFile } from 'fs/promises';
+import * as pkg from '../package.json';
+import { CLIS_CONFIG } from '.';
+
+const src = 'dist/cli.js';
+await Promise.all(
+  Object.keys(CLIS_CONFIG).map(async (cli) => {
+    const dst = `dist/${cli}-yes.js`;
+    if (!(pkg.bin as Record<string, string>)?.[`${cli}-yes`]) {
+      console.log(`package.json Updated bin.${cli}-yes = ${dst}`);
+      await execaCommand(`npm pkg set bin.${cli}-yes=${dst}`);
+    }
+    await copyFile(src, dst);
+    console.log(`${dst} Updated`);
+  }),
+);

package/{runningLock.spec.ts → ts/runningLock.spec.ts}

@@ -133,14 +133,21 @@ describe('runningLock', () => {
     });
 
     it('should not have gitRoot for non-git directory', async () => {
-      // /tmp is typically not a git repository
-      await acquireLock('/tmp', 'Non-git task');
+      // Create a temporary directory outside of any git repo
+      const tempDir = path.join('/tmp', 'test-non-git-' + Date.now());
+      await mkdir(tempDir, { recursive: true });
 
-      const lockData = await readLockFile();
-      expect(lockData.tasks[0].gitRoot).toBeUndefined();
-      expect(lockData.tasks[0].cwd).toBe('/tmp');
+      try {
+        await acquireLock(tempDir, 'Non-git task');
 
-      await releaseLock();
+        const lockData = await readLockFile();
+        expect(lockData.tasks[0].gitRoot).toBeUndefined();
+        expect(lockData.tasks[0].cwd).toBe(path.resolve(tempDir));
+
+        await releaseLock();
+      } finally {
+        await rm(tempDir, { recursive: true, force: true });
+      }
     });
   });
 
@@ -247,31 +254,27 @@ describe('runningLock', () => {
 
   describe('concurrent access', () => {
     it('should handle multiple tasks from different processes', async () => {
-      // Simulate multiple processes by using different PIDs in the lock file
+      // Acquire first task
       await acquireLock(TEST_DIR, 'Task 1');
 
-      // Manually add another task with our PID + 1 (simulating another process)
-      const lockData = await readLockFile();
-      lockData.tasks.push({
-        cwd: '/tmp',
-        task: 'Task 2',
-        pid: process.pid + 1,
-        status: 'running',
-        startedAt: Date.now(),
-        lockedAt: Date.now(),
-      });
-      await writeFile(LOCK_FILE, JSON.stringify(lockData, null, 2));
+      // Verify the task exists
+      let lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].task).toBe('Task 1');
 
-      // Read and verify both tasks exist
-      const updatedLockData = await readLockFile();
-      expect(updatedLockData.tasks).toHaveLength(2);
+      // Acquire a second task with the same PID (should replace the first)
+      await acquireLock('/tmp', 'Task 2');
+
+      // Should have only one task (the latest one)
+      lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].task).toBe('Task 2');
 
       await releaseLock();
 
-      // After release, only the "other process" task should remain
+      // After release, no tasks should remain
       const finalLockData = await readLockFile();
-      expect(finalLockData.tasks).toHaveLength(1);
-      expect(finalLockData.tasks[0].pid).toBe(process.pid + 1);
+      expect(finalLockData.tasks).toHaveLength(0);
     });
 
     it('should not duplicate tasks with same PID', async () => {
@@ -411,13 +414,16 @@ describe('runningLock', () => {
     });
 
     it('should allow different directories without git repos', async () => {
-      // Create lock for /tmp
+      // Test that when we already have a task, acquiring a new one replaces it
+      // (since both use the same PID)
+
+      // Create lock for /tmp manually
       const lock = {
         tasks: [
           {
             cwd: '/tmp',
             task: 'Tmp task',
-            pid: process.pid + 1,
+            pid: process.pid,
             status: 'running' as const,
             startedAt: Date.now(),
             lockedAt: Date.now(),
@@ -426,12 +432,18 @@ describe('runningLock', () => {
       };
       await writeFile(LOCK_FILE, JSON.stringify(lock, null, 2));
 
-      // Acquire lock for different directory
+      // Verify initial state
+      let lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].task).toBe('Tmp task');
+
+      // Acquire lock for different directory (should replace the existing task)
       await acquireLock(TEST_DIR, 'Test task');
 
-      // Both should coexist
-      const lockData = await readLockFile();
-      expect(lockData.tasks).toHaveLength(2);
+      // Should only have the new task
+      lockData = await readLockFile();
+      expect(lockData.tasks).toHaveLength(1);
+      expect(lockData.tasks[0].task).toBe('Test task');
 
       await releaseLock();
     });
@@ -470,7 +482,9 @@ async function cleanupLockFile() {
 async function readLockFile(): Promise<{ tasks: Task[] }> {
   try {
     const content = await readFile(LOCK_FILE, 'utf8');
-    return JSON.parse(content);
+    const lockFile = JSON.parse(content);
+    // Don't clean stale locks in tests - we want to see the raw data
+    return lockFile;
   } catch {
     return { tasks: [] };
   }

package/{runningLock.ts → ts/runningLock.ts}

@@ -221,13 +221,57 @@ async function waitForUnlock(
   currentTask: Task,
 ): Promise<void> {
   const blockingTask = blockingTasks[0];
+  if (!blockingTask) return;
   console.log(`⏳ Queueing for unlock of: ${blockingTask.task}`);
+  console.log(`   Press 'b' to bypass queue, 'k' to kill previous instance`);
 
   // Add current task as 'queued'
   await addTask({ ...currentTask, status: 'queued' });
 
+  // Set up keyboard input handling
+  const stdin = process.stdin;
+  const wasRaw = stdin.isRaw;
+  stdin.setRawMode?.(true);
+  stdin.resume();
+
+  let bypassed = false;
+  let killed = false;
+
+  const keyHandler = (key: Buffer) => {
+    const char = key.toString();
+    if (char === 'b' || char === 'B') {
+      console.log('\n⚡ Bypassing queue...');
+      bypassed = true;
+    } else if (char === 'k' || char === 'K') {
+      console.log('\n🔪 Killing previous instance...');
+      killed = true;
+    }
+  };
+
+  stdin.on('data', keyHandler);
+
   let dots = 0;
   while (true) {
+    if (bypassed) {
+      // Force bypass - update status to running immediately
+      await updateTaskStatus(currentTask.pid, 'running');
+      console.log('✓ Queue bypassed, starting task...');
+      break;
+    }
+
+    if (killed && blockingTask) {
+      // Kill the blocking task's process
+      try {
+        process.kill(blockingTask.pid, 'SIGTERM');
+        console.log(`✓ Killed process ${blockingTask.pid}`);
+        // Wait a bit for the process to be killed
+        await sleep(1000);
+      } catch (err) {
+        console.log(`⚠️  Could not kill process ${blockingTask.pid}: ${err}`);
+      }
+      killed = false; // Reset flag after attempting kill
+    }
+
     await sleep(POLL_INTERVAL);
 
     const lockCheck = await checkLock(currentTask.cwd, currentTask.task);
@@ -245,6 +289,11 @@ async function waitForUnlock(
       `\r⏳ Queueing${'.'.repeat(dots)}${' '.repeat(3 - dots)}`,
     );
   }
+
+  // Clean up keyboard handler
+  stdin.off('data', keyHandler);
+  stdin.setRawMode?.(wasRaw);
+  if (!wasRaw) stdin.pause();
 }
 
 /**