claude-yes 1.17.1 → 1.18.0

package/idleWaiter.ts

@@ -0,0 +1,31 @@
+/**
+ * A utility class to wait for idle periods based on activity pings.
+ *
+ * @example
+ * const idleWaiter = new IdleWaiter();
+ *
+ * // Somewhere in your code, when activity occurs:
+ * idleWaiter.ping();
+ *
+ * // To wait for an idle period of 5 seconds:
+ * await idleWaiter.wait(5000);
+ * console.log('System has been idle for 5 seconds');
+ */
+export class IdleWaiter {
+  lastActivityTime = Date.now();
+  checkInterval = 100; // Default check interval in milliseconds
+
+  constructor() {
+    this.ping();
+  }
+
+  ping() {
+    this.lastActivityTime = Date.now();
+    return this;
+  }
+
+  async wait(ms: number) {
+    while (this.lastActivityTime >= Date.now() - ms)
+      await new Promise((resolve) => setTimeout(resolve, this.checkInterval));
+  }
+}

package/index.ts

@@ -1,37 +1,90 @@
 import { fromReadable, fromWritable } from 'from-node-stream';
+import { mkdir, writeFile } from 'fs/promises';
+import path from 'path';
+import DIE from 'phpdie';
 import sflow from 'sflow';
-import { createIdleWatcher } from './createIdleWatcher';
-import { removeControlCharacters } from './removeControlCharacters';
-import { sleepms } from './utils';
 import { TerminalTextRender } from 'terminal-render';
-import { writeFile } from 'fs/promises';
-import path from 'path';
-import { mkdir } from 'fs/promises';
+import { IdleWaiter } from './idleWaiter';
 import { ReadyManager } from './ReadyManager';
+import { removeControlCharacters } from './removeControlCharacters';
 
+export const CLI_CONFIGURES = {
+  claude: {
+    ready: /^> /, // regex matcher for stdin ready,
+    enter: [/❯ 1. Yes/, /❯ 1. Dark mode✔/, /Press Enter to continue…/],
+    fatal: [
+      /No conversation found to continue/,
+      /⎿ {2}Claude usage limit reached\./,
+    ],
+  },
+  gemini: {
+    // 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/],
+  },
+  codex: {
+    ready: /⏎ send/,
+    enter: [/ > 1. Approve/, /> 1. Yes, allow Codex to work in this folder/],
+    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: {
+    ready: /^  > /,
+    enter: [/ │ ❯ 1. Yes, proceed/, /❯ 1. Yes/],
+  },
+  cursor: {
+    // map logical "cursor" cli name to actual binary name
+    binary: 'cursor-agent',
+    ready: /\/ commands/,
+    enter: [/→ Run \(once\) \(y\) \(enter\)/, /▶ \[a\] Trust this workspace/],
+  },
+};
 /**
- * Main function to run Claude with automatic yes/no respojnses
+ * Main function to run Claude with automatic yes/no responses
  * @param options Configuration options
  * @param options.continueOnCrash - If true, automatically restart Claude when it crashes:
  *   1. Shows message 'Claude crashed, restarting..'
  *   2. Spawns a new 'claude --continue' process
  *   3. Re-attaches the new process to the shell stdio (pipes new process stdin/stdout)
  *   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.exitOnIdle - Exit when Claude is idle. Boolean or timeout in milliseconds, recommended 5000 - 60000, default is false
  * @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
+ *
+ * @example
+ * ```typescript
+ * import claudeYes from 'claude-yes';
+ * await claudeYes({
+ *   prompt: 'help me solve all todos in my codebase',
+ *
+ *   // optional
+ *   cli: 'claude',
+ *   cliArgs: ['--verbose'], // additional args to pass to claude
+ *   exitOnIdle: 30000, // exit after 30 seconds of idle
+ *   continueOnCrash: true, // restart if claude crashes, default is true
+ *   logFile: 'claude.log', // save logs to file
+ * });
+ * ```
  */
 export default async function claudeYes({
-  claudeArgs = [],
+  cli = 'claude',
+  cliArgs = [],
+  prompt,
   continueOnCrash,
   cwd,
   env,
-  exitOnIdle = 60e3,
+  exitOnIdle,
   logFile,
   removeControlCharactersFromStdout = false, // = !process.stdout.isTTY,
   verbose = false,
 }: {
-  claudeArgs?: string[];
+  cli?: (string & {}) | keyof typeof CLI_CONFIGURES;
+  cliArgs?: string[];
+  prompt?: string;
   continueOnCrash?: boolean;
   cwd?: string;
   env?: Record<string, string>;
@@ -40,52 +93,60 @@ export default async function claudeYes({
   removeControlCharactersFromStdout?: boolean;
   verbose?: boolean;
 } = {}) {
-  if (verbose) {
-    console.log('calling claudeYes: ', {
-      continueOnCrash,
-      exitOnIdle,
-      claudeArgs,
-      cwd,
-      removeControlCharactersFromStdout,
-      logFile,
-      verbose,
-    });
-  }
-  console.log(
-    '⭐ 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.'
-  );
-
-  process.stdin.setRawMode?.(true); //must be called any stdout/stdin usage
-  const prefix = ''; // "YESC|"
-  const PREFIXLENGTH = prefix.length;
-  let errorNoConversation = false; // match 'No conversation found to continue'
-  const shellReady = new ReadyManager();
+  const continueArgs = {
+    codex: 'resume --last'.split(' '),
+    claude: '--continue'.split(' '),
+    gemini: [], // not possible yet
+  };
+
+  // if (verbose) {
+  //   console.log('calling claudeYes: ', {
+  //     cli,
+  //     continueOnCrash,
+  //     exitOnIdle,
+  //     cliArgs,
+  //     cwd,
+  //     removeControlCharactersFromStdout,
+  //     logFile,
+  //     verbose,
+  //   });
+  // }
+  // console.log(
+  //   `⭐ Starting ${cli}, 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.'
+  // );
+
+  process.stdin.setRawMode?.(true); // must be called any stdout/stdin usage
+  let isFatal = false; // match 'No conversation found to continue'
+  const stdinReady = new ReadyManager();
 
   const shellOutputStream = new TransformStream<string, string>();
   const outputWriter = shellOutputStream.writable.getWriter();
   // const pty = await import('node-pty');
 
-  // recommened to use bun pty in windows
-  const pty = process.versions.bun
-    ? await import('bun-pty').catch(() => {
-        throw new Error('Please install bun-pty');
-      })
-    : await import('node-pty').catch(() => {
-        throw new Error('Please install node-pty');
-      });
+  // its recommened to use bun-pty in windows
+  const pty = await import('node-pty')
+    .catch(async () => await import('bun-pty'))
+    .catch(async () =>
+      DIE('Please install node-pty or bun-pty, run this: bun install bun-pty'),
+    );
 
   const getPtyOptions = () => ({
     name: 'xterm-color',
-    cols: process.stdout.columns - PREFIXLENGTH,
-    rows: process.stdout.rows,
+    ...getTerminalDimensions(),
     cwd: cwd ?? process.cwd(),
     env: env ?? (process.env as Record<string, string>),
   });
-  let shell = pty.spawn('claude', claudeArgs, getPtyOptions());
-  let pendingExitCode = Promise.withResolvers<number | null>();
+
+  // Apply CLI specific configurations (moved to CLI_CONFIGURES)
+  const cliConf = (CLI_CONFIGURES as Record<string, any>)[cli] || {};
+  cliArgs = cliConf.ensureArgs?.(cliArgs) ?? cliArgs;
+  const cliCommand = cliConf?.binary || cli;
+
+  let shell = pty.spawn(cliCommand, cliArgs, getPtyOptions());
+  const pendingExitCode = Promise.withResolvers<number | null>();
   let pendingExitCodeValue = null;
 
   // TODO handle error if claude is not installed, show msg:
@@ -94,23 +155,29 @@ export default async function claudeYes({
   async function onData(data: string) {
     // append data to the buffer, so we can process it later
     await outputWriter.write(data);
-    shellReady.ready(); // shell has output, also means ready for stdin
   }
 
   shell.onData(onData);
   shell.onExit(function onExit({ exitCode }) {
-    shellReady.unready(); // start buffer stdin
-    const claudeCrashed = exitCode !== 0;
-    if (claudeCrashed && continueOnCrash) {
-      if (errorNoConversation) {
+    stdinReady.unready(); // start buffer stdin
+    const agentCrashed = exitCode !== 0;
+    const continueArg = (continueArgs as Record<string, string[]>)[cli];
+
+    if (agentCrashed && continueOnCrash && continueArg) {
+      if (!continueArg) {
+        return console.warn(
+          `continueOnCrash is only supported for ${Object.keys(continueArgs).join(', ')} currently, not ${cli}`,
+        );
+      }
+      if (isFatal) {
         console.log(
-          'Claude crashed with "No conversation found to continue", exiting...'
+          `${cli} crashed with "No conversation found to continue", exiting...`,
         );
         return pendingExitCode.resolve((pendingExitCodeValue = exitCode));
       }
-      console.log('Claude crashed, restarting...');
+      console.log(`${cli} crashed, restarting...`);
 
-      shell = pty.spawn('claude', ['--continue', 'continue'], getPtyOptions());
+      shell = pty.spawn(cli, continueArg, getPtyOptions());
       shell.onData(onData);
       shell.onExit(onExit);
       return;
@@ -118,112 +185,197 @@ export default async function claudeYes({
     return pendingExitCode.resolve((pendingExitCodeValue = exitCode));
   });
 
-  const exitClaudeCode = async () => {
-    continueOnCrash = false;
-    // send exit command to the shell, must sleep a bit to avoid claude treat it as pasted input
-    await sflow(['\r', '/exit', '\r'])
-      .forEach(async () => await sleepms(200))
-      .forEach(async (e) => shell.write(e))
-      .run();
-
-    // wait for shell to exit or kill it with a timeout
-    let exited = false;
-    await Promise.race([
-      pendingExitCode.promise.then(() => (exited = true)), // resolve when shell exits
-      // if shell doesn't exit in 5 seconds, kill it
-      new Promise<void>((resolve) =>
-        setTimeout(() => {
-          if (exited) return; // if shell already exited, do nothing
-          shell.kill(); // kill the shell process if it doesn't exit in time
-          resolve();
-        }, 5000)
-      ), // 5 seconds timeout
-    ]);
-  };
-
   // when current tty resized, resize the pty
   process.stdout.on('resize', () => {
-    const { columns, rows } = process.stdout;
-    shell.resize(columns - PREFIXLENGTH, rows);
+    const { cols, rows } = getTerminalDimensions(); // minimum 80 columns to avoid layout issues
+    shell.resize(cols, rows); // minimum 80 columns to avoid layout issues
   });
 
-  const render = new TerminalTextRender();
-  const idleWatcher = !exitOnIdle
-    ? null
-    : createIdleWatcher(async () => {
-        if (
-          render
-            .render()
-            .replace(/\s+/g, ' ')
-            .match(/esc to interrupt|to run in background/)
-        ) {
-          console.log(
-            '[claude-yes] Claude is idle, but seems still working, not exiting yet'
-          );
-        } else {
-          console.log('[claude-yes] Claude is idle, exiting...');
-          await exitClaudeCode();
-        }
-      }, exitOnIdle);
-  const confirm = async () => {
-    await sleepms(200);
-    shell.write('\r');
-  };
+  const terminalRender = new TerminalTextRender();
+  const isStillWorkingQ = () =>
+    terminalRender
+      .render()
+      .replace(/\s+/g, ' ')
+      .match(/esc to interrupt|to run in background/);
 
+  const idleWaiter = new IdleWaiter();
+  if (exitOnIdle)
+    idleWaiter.wait(exitOnIdle).then(async () => {
+      if (isStillWorkingQ()) {
+        console.log(
+          '[${cli}-yes] ${cli} is idle, but seems still working, not exiting yet',
+        );
+        return;
+      }
+
+      console.log('[${cli}-yes] ${cli} is idle, exiting...');
+      await exitAgent();
+    });
+
+  // Message streaming
   sflow(fromReadable<Buffer>(process.stdin))
     .map((buffer) => buffer.toString())
+    // .map((e) => e.replaceAll('\x1a', '')) // remove ctrl+z from user's input (seems bug)
     // .forEach(e => appendFile('.cache/io.log', "input |" + JSON.stringify(e) + '\n')) // for debugging
     // pipe
     .by({
       writable: new WritableStream<string>({
         write: async (data) => {
-          await shellReady.wait();
+          await stdinReady.wait();
+          // await idleWaiter.wait(20); // wait for idle for 200ms to avoid messing up claude's input
           shell.write(data);
         },
       }),
       readable: shellOutputStream.readable,
     })
-    // handle terminal render
-    .forEach((text) => render.write(text))
+    .forEach(() => idleWaiter.ping())
+    .forEach((text) => {
+      terminalRender.write(text);
+      // todo: .onStatus((msg)=> shell.write(msg))
+      if (process.stdin.isTTY) return; // only handle it when stdin is not tty
+      if (text.includes('\u001b[6n')) return; // only asked
+
+      // todo: use terminalRender API to get cursor position when new version is available
+      // xterm replies CSI row; column R if asked cursor position
+      // https://en.wikipedia.org/wiki/ANSI_escape_code#:~:text=citation%20needed%5D-,xterm%20replies,-CSI%20row%C2%A0%3B
+      // when agent asking position, respond with row; col
+      const rendered = terminalRender.render();
+      const row = rendered.split('\n').length + 1;
+      const col = (rendered.split('\n').slice(-1)[0]?.length || 0) + 1;
+      shell.write(`\u001b[${row};${col}R`);
+    })
 
-    // handle idle
-    .forEach(() => idleWatcher?.ping()) // ping the idle watcher on output for last active time to keep track of claude status
     // auto-response
     .forkTo((e) =>
       e
-        .map((e) => removeControlCharacters(e as string))
+        .map((e) => removeControlCharacters(e))
         .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…/))
-            return await confirm();
-          if (e.match(/No conversation found to continue/)) {
-            errorNoConversation = true; // set flag to true if error message is found
+        .lines({ EOL: 'NONE' })
+        // Generic auto-response handler driven by CLI_CONFIGURES
+        .forEach(async (e, i) => {
+          const conf = (CLI_CONFIGURES as Record<string, any>)[cli] || {};
+          if (!conf) return;
+
+          // ready matcher: if matched, mark stdin ready
+          try {
+            if (conf.ready) {
+              // special-case gemini to avoid initial prompt noise: only after many lines
+              if (cli === 'gemini' && conf.ready instanceof RegExp) {
+                if (e.match(conf.ready) && i > 80) return stdinReady.ready();
+              } else if (e.match(conf.ready)) {
+                return stdinReady.ready();
+              }
+            }
+
+            // enter matchers: send Enter when any enter regex matches
+            if (conf.enter && Array.isArray(conf.enter)) {
+              for (const rx of conf.enter) {
+                if (e.match(rx)) return await sendEnter();
+              }
+            } else if (conf.enter && conf.enter instanceof RegExp) {
+              if (e.match(conf.enter)) return await sendEnter();
+            }
+
+            // fatal matchers: set isFatal flag when matched
+            if (conf.fatal && Array.isArray(conf.fatal)) {
+              for (const rx of conf.fatal) {
+                if (e.match(rx)) return (isFatal = true);
+              }
+            } else if (conf.fatal && conf.fatal instanceof RegExp) {
+              if (e.match(conf.fatal)) return (isFatal = true);
+            }
+          } catch (err) {
+            // defensive: if e.match throws (e.g., not a string), ignore
             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
     .map((e) =>
-      removeControlCharactersFromStdout ? removeControlCharacters(e) : e
+      removeControlCharactersFromStdout ? removeControlCharacters(e) : e,
     )
-    .to(fromWritable(process.stdout));
+    .to(fromWritable(process.stdout))
+    .then(() => null); // run it immediately without await
+
+  // wait for cli ready and send prompt if provided
+  if (prompt)
+    (async () => {
+      // console.log(`[${cli}-yes] Ready to send prompt to ${cli}: ${prompt}`);
+      // idleWaiter.ping();
+      // console.log(
+      //   'await idleWaiter.wait(1000); // wait a bit for claude to start'
+      // );
+      // await idleWaiter.wait(1000); // wait a bit for claude to start
+      // console.log('await stdinReady.wait();');
+      // await stdinReady.wait();
+      // console.log(`[${cli}-yes] Waiting for ${cli} to be ready...`);
+      // console.log('await idleWaiter.wait(200);');
+      // await idleWaiter.wait(200);
+      // console.log(`[${cli}-yes] Sending prompt to ${cli}: ${prompt}`);
+      await sendMessage(prompt);
+    })();
 
   const exitCode = await pendingExitCode.promise; // wait for the shell to exit
-  console.log(`[claude-yes] claude exited with code ${exitCode}`);
+  console.log(`[${cli}-yes] ${cli} exited with code ${exitCode}`);
 
   if (logFile) {
-    verbose && console.log(`[claude-yes] Writing rendered logs to ${logFile}`);
+    verbose && console.log(`[${cli}-yes] Writing rendered logs to ${logFile}`);
     const logFilePath = path.resolve(logFile);
     await mkdir(path.dirname(logFilePath), { recursive: true }).catch(
-      () => null
+      () => null,
     );
-    await writeFile(logFilePath, render.render());
+    await writeFile(logFilePath, terminalRender.render());
+  }
+
+  return { exitCode, logs: terminalRender.render() };
+
+  async function sendEnter(waitms = 1000) {
+    // wait for idle for a bit to let agent cli finish rendering
+    const st = Date.now();
+
+    await idleWaiter.wait(waitms);
+    const et = Date.now();
+    process.stdout.write(`\ridleWaiter.wait(${waitms}) took ${et - st}ms\r`);
+
+    shell.write('\r');
+  }
+
+  async function sendMessage(message: string) {
+    await stdinReady.wait();
+    // show in-place message: write msg and move cursor back start
+    shell.write(message);
+    idleWaiter.ping(); // just sent a message, wait for echo
+    await sendEnter();
+  }
+
+  async function exitAgent() {
+    continueOnCrash = false;
+    // send exit command to the shell, must sleep a bit to avoid claude treat it as pasted input
+    await sendMessage('/exit');
+
+    // wait for shell to exit or kill it with a timeout
+    let exited = false;
+    await Promise.race([
+      pendingExitCode.promise.then(() => (exited = true)), // resolve when shell exits
+
+      // if shell doesn't exit in 5 seconds, kill it
+      new Promise<void>((resolve) =>
+        setTimeout(() => {
+          if (exited) return; // if shell already exited, do nothing
+          shell.kill(); // kill the shell process if it doesn't exit in time
+          resolve();
+        }, 5000),
+      ), // 5 seconds timeout
+    ]);
   }
 
-  return { exitCode, logs: render.render() };
+  function getTerminalDimensions() {
+    return {
+      cols: Math.max(process.stdout.columns, 80),
+      rows: process.stdout.rows,
+    };
+  }
 }
 
 export { removeControlCharacters };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-yes",
-  "version": "1.17.1",
+  "version": "1.18.0",
   "description": "A wrapper tool that automates interactions with the Claude CLI by automatically handling common prompts and responses.",
   "keywords": [
     "claude",
@@ -31,7 +31,11 @@
   "module": "index.ts",
   "types": "./index.ts",
   "bin": {
-    "claude-yes": "dist/cli.js"
+    "claude-yes": "dist/claude-yes.js",
+    "codex-yes": "dist/codex-yes.js",
+    "gemini-yes": "dist/gemini-yes.js",
+    "cursor-yes": "dist/cursor-yes.js",
+    "copilot-yes": "dist/copilot-yes.js"
   },
   "directories": {
     "doc": "docs"
@@ -41,18 +45,21 @@
     "dist"
   ],
   "scripts": {
-    "build": "bun build index.ts cli.ts --outdir=dist --external=node-pty --external=bun-pty --target=node --sourcemap",
+    "build": "bun build index.ts cli.ts --packages=external --outdir=dist --target=node --sourcemap",
+    "postbuild": "bun ./postbuild.ts",
     "dev": "tsx index.ts",
-    "fmt": "prettier -w .",
-    "prepare": "husky",
+    "fmt": "bunx @biomejs/biome check --fix",
+    "prepack": "bun run build",
+    "prepare": "bunx husky",
     "test": "vitest"
   },
   "lint-staged": {
     "*.{ts,js,json,md}": [
-      "prettier --write"
+      "bunx @biomejs/biome check --fix"
     ]
   },
   "devDependencies": {
+    "@biomejs/biome": "^2.2.5",
     "@types/bun": "^1.2.18",
     "@types/jest": "^30.0.0",
     "@types/node": "^24.0.10",
@@ -62,7 +69,6 @@
     "from-node-stream": "^0.0.11",
     "husky": "^9.1.7",
     "lint-staged": "^16.1.4",
-    "prettier": "^3.6.2",
     "rambda": "^10.3.2",
     "semantic-release": "^24.2.6",
     "sflow": "^1.20.2",
@@ -77,6 +83,8 @@
     "node-pty": "^1.0.0"
   },
   "dependencies": {
-    "bun-pty": "^0.3.2"
+    "bun-pty": "^0.3.2",
+    "p-map": "^7.0.3",
+    "phpdie": "^1.7.0"
   }
 }

package/postbuild.ts

@@ -0,0 +1,6 @@
+#! /usr/bin/env bun
+import { copyFile } from 'fs/promises';
+import * as pkg from './package.json';
+
+const src = 'dist/cli.js';
+await Promise.all(Object.values(pkg.bin).map((dst) => copyFile(src, dst)));

package/removeControlCharacters.ts

@@ -1,4 +1,7 @@
 export function removeControlCharacters(str: string): string {
-    // Matches control characters in the C0 and C1 ranges, including Delete (U+007F)
-    return str.replace(/[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g, '');
+  // Matches control characters in the C0 and C1 ranges, including Delete (U+007F)
+  return str.replace(
+    /[\u001b\u009b][[()#;?]*(?:[0-9]{1,4}(?:;[0-9]{0,4})*)?[0-9A-ORZcf-nqry=><]/g,
+    '',
+  );
 }

package/sleep.ts

@@ -1,3 +1,3 @@
 export function sleep(ms: number) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/utils.ts

@@ -1,3 +1,3 @@
 export function sleepms(ms: number) {
-    return new Promise(resolve => setTimeout(resolve, ms));
+  return new Promise((resolve) => setTimeout(resolve, ms));
 }

package/createIdleWatcher.spec.ts

@@ -1,41 +0,0 @@
-import { expect, it } from 'vitest';
-import { createIdleWatcher } from "./createIdleWatcher";
-import { sleepms } from "./utils";
-
-it('createIdleWatcher should trigger onIdle after timeout', async () => {
-    let idleTriggered = false;
-    const watcher = createIdleWatcher(() => {
-        idleTriggered = true;
-    }, 100);
-
-    watcher.ping();
-    await sleepms(150);
-    expect(idleTriggered).toBe(true);
-}, 1000);
-
-it.concurrent('createIdleWatcher should reset timeout on ping', async () => {
-    let idleTriggered = false;
-    const watcher = createIdleWatcher(() => {
-        idleTriggered = true;
-    }, 100);
-
-    watcher.ping();
-    await sleepms(50);
-    watcher.ping();
-    await sleepms(50);
-    expect(idleTriggered).toBe(false);
-    await sleepms(100);
-    expect(idleTriggered).toBe(true);
-}, 1000);
-
-it.concurrent('createIdleWatcher should update lastActiveTime on ping', async () => {
-    const watcher = createIdleWatcher(() => { }, 1000);
-
-    const initialTime = watcher.getLastActiveTime();
-    await sleepms(50);
-    watcher.ping();
-    const updatedTime = watcher.getLastActiveTime();
-
-    expect(updatedTime.getTime()).toBeGreaterThan(initialTime.getTime());
-}, 1000);
-