claude-yes 1.29.2 → 1.31.0

package/ts/codexSessionManager.ts

@@ -1,13 +1,22 @@
-import { mkdir, readFile, writeFile } from 'fs/promises';
+import { mkdir, readdir, readFile, writeFile } from 'fs/promises';
 import { homedir } from 'os';
 import path from 'path';
 
-const SESSIONS_FILE = path.join(
-  homedir(),
-  '.config',
-  'cli-yes',
-  'codex-sessions.json',
-);
+// Allow overriding for testing
+export const getSessionsFile = () =>
+  process.env.CLI_YES_TEST_HOME
+    ? path.join(
+        process.env.CLI_YES_TEST_HOME,
+        '.config',
+        'cli-yes',
+        'codex-sessions.json',
+      )
+    : path.join(homedir(), '.config', 'cli-yes', 'codex-sessions.json');
+
+export const getCodexSessionsDir = () =>
+  process.env.CLI_YES_TEST_HOME
+    ? path.join(process.env.CLI_YES_TEST_HOME, '.codex', 'sessions')
+    : path.join(homedir(), '.codex', 'sessions');
 
 export interface CodexSessionMap {
   [cwd: string]: {
@@ -16,12 +25,24 @@ export interface CodexSessionMap {
   };
 }
 
+export interface CodexSession {
+  id: string;
+  timestamp: string;
+  cwd: string;
+  filePath: string;
+  git?: {
+    commit_hash: string;
+    branch: string;
+    repository_url: string;
+  };
+}
+
 /**
  * Load the session map from the config file
  */
 export async function loadSessionMap(): Promise<CodexSessionMap> {
   try {
-    const content = await readFile(SESSIONS_FILE, 'utf-8');
+    const content = await readFile(getSessionsFile(), 'utf-8');
     return JSON.parse(content);
   } catch (error) {
     // File doesn't exist or is invalid, return empty map
@@ -36,9 +57,10 @@ export async function saveSessionMap(
   sessionMap: CodexSessionMap,
 ): Promise<void> {
   try {
+    const sessionsFile = getSessionsFile();
     // Ensure the directory exists
-    await mkdir(path.dirname(SESSIONS_FILE), { recursive: true });
-    await writeFile(SESSIONS_FILE, JSON.stringify(sessionMap, null, 2));
+    await mkdir(path.dirname(sessionsFile), { recursive: true });
+    await writeFile(sessionsFile, JSON.stringify(sessionMap, null, 2));
   } catch (error) {
     console.warn('Failed to save codex session map:', error);
   }
@@ -59,10 +81,122 @@ export async function storeSessionForCwd(
   await saveSessionMap(sessionMap);
 }
 
+/**
+ * Parse a codex session file to extract session metadata
+ */
+async function parseCodexSessionFile(
+  filePath: string,
+): Promise<CodexSession | null> {
+  try {
+    const content = await readFile(filePath, 'utf-8');
+    const lines = content.trim().split('\n');
+
+    // Find the session_meta line
+    for (const line of lines) {
+      if (!line.trim()) continue;
+
+      const data = JSON.parse(line);
+      if (data.type === 'session_meta' && data.payload) {
+        const payload = data.payload;
+        return {
+          id: payload.id,
+          timestamp: payload.timestamp || data.timestamp,
+          cwd: payload.cwd,
+          filePath,
+          git: payload.git,
+        };
+      }
+    }
+
+    return null;
+  } catch (error) {
+    // Ignore files that can't be parsed
+    return null;
+  }
+}
+
+/**
+ * Get all codex sessions from the .codex/sessions directory
+ */
+async function getAllCodexSessions(): Promise<CodexSession[]> {
+  const sessions: CodexSession[] = [];
+  const codexSessionsDir = getCodexSessionsDir();
+
+  try {
+    // Walk through year/month/day structure
+    const years = await readdir(codexSessionsDir);
+
+    for (const year of years) {
+      const yearPath = path.join(codexSessionsDir, year);
+      try {
+        const months = await readdir(yearPath);
+
+        for (const month of months) {
+          const monthPath = path.join(yearPath, month);
+          try {
+            const days = await readdir(monthPath);
+
+            for (const day of days) {
+              const dayPath = path.join(monthPath, day);
+              try {
+                const files = await readdir(dayPath);
+
+                for (const file of files) {
+                  if (file.endsWith('.jsonl')) {
+                    const sessionPath = path.join(dayPath, file);
+                    const session = await parseCodexSessionFile(sessionPath);
+                    if (session) {
+                      sessions.push(session);
+                    }
+                  }
+                }
+              } catch (error) {
+                // Skip directories we can't read
+              }
+            }
+          } catch (error) {
+            // Skip directories we can't read
+          }
+        }
+      } catch (error) {
+        // Skip directories we can't read
+      }
+    }
+  } catch (error) {
+    // .codex/sessions directory doesn't exist or can't be read
+    return [];
+  }
+
+  return sessions.sort(
+    (a, b) => new Date(b.timestamp).getTime() - new Date(a.timestamp).getTime(),
+  );
+}
+
+/**
+ * Get the most recent session for a specific working directory from actual codex files
+ */
+async function getMostRecentCodexSessionForCwd(
+  targetCwd: string,
+): Promise<CodexSession | null> {
+  const allSessions = await getAllCodexSessions();
+  const sessionsForCwd = allSessions.filter(
+    (session) => session.cwd === targetCwd,
+  );
+  return sessionsForCwd[0] || null;
+}
+
 /**
  * Get the last session ID for a specific working directory
+ * Now checks actual codex session files first, falls back to stored mapping
  */
 export async function getSessionForCwd(cwd: string): Promise<string | null> {
+  // First try to get the most recent session from actual codex files
+  const recentSession = await getMostRecentCodexSessionForCwd(cwd);
+  if (recentSession) {
+    return recentSession.id;
+  }
+
+  // Fall back to stored mapping
   const sessionMap = await loadSessionMap();
   return sessionMap[cwd]?.sessionId || null;
 }
@@ -101,6 +235,52 @@ export function extractSessionIdFromSessionMeta(
   return extractSessionId(sessionContent);
 }
 
+/**
+ * Get recent sessions for a specific working directory from actual codex files
+ */
+export async function getRecentSessionsForCwd(
+  targetCwd: string,
+  limit = 5,
+): Promise<CodexSession[]> {
+  const allSessions = await getAllCodexSessions();
+  const sessionsForCwd = allSessions.filter(
+    (session) => session.cwd === targetCwd,
+  );
+  return sessionsForCwd.slice(0, limit);
+}
+
+/**
+ * Get all working directories with session counts from actual codex files
+ */
+export async function getAllWorkingDirectories(): Promise<
+  { cwd: string; count: number; lastSession: string }[]
+> {
+  const allSessions = await getAllCodexSessions();
+  const cwdMap = new Map<string, { count: number; lastSession: string }>();
+
+  for (const session of allSessions) {
+    const existing = cwdMap.get(session.cwd);
+    if (existing) {
+      existing.count++;
+      if (new Date(session.timestamp) > new Date(existing.lastSession)) {
+        existing.lastSession = session.timestamp;
+      }
+    } else {
+      cwdMap.set(session.cwd, {
+        count: 1,
+        lastSession: session.timestamp,
+      });
+    }
+  }
+
+  return Array.from(cwdMap.entries())
+    .map(([cwd, data]) => ({ cwd, ...data }))
+    .sort(
+      (a, b) =>
+        new Date(b.lastSession).getTime() - new Date(a.lastSession).getTime(),
+    );
+}
+
 /**
  * Clean up old sessions (keep only the most recent 10 per directory)
  */

package/ts/index.ts

@@ -1,3 +1,4 @@
+import { execaCommand, execaCommandSync, parseCommandString } from 'execa';
 import { fromReadable, fromWritable } from 'from-node-stream';
 import { mkdir, writeFile } from 'fs/promises';
 import path from 'path';
@@ -5,6 +6,7 @@ import DIE from 'phpdie';
 import sflow from 'sflow';
 import { TerminalTextRender } from 'terminal-render';
 import rawConfig from '../cli-yes.config.js';
+import { catcher } from './catcher.js';
 import {
   extractSessionId,
   getSessionForCwd,
@@ -19,7 +21,6 @@ import {
   shouldUseLock,
   updateCurrentTaskStatus,
 } from './runningLock';
-import { catcher } from './tryCatch';
 import { yesLog } from './yesLog';
 
 export { parseCliArgs } from './parseCliArgs';
@@ -36,6 +37,7 @@ export type AgentCliConfig = {
   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
+  bunx?: boolean; // if true, use bunx to run the binary
 };
 export type CliYesConfig = {
   clis: { [key: string]: AgentCliConfig };
@@ -91,6 +93,7 @@ export default async function cliYes({
   removeControlCharactersFromStdout = false, // = !process.stdout.isTTY,
   verbose = false,
   queue = true,
+  install = false,
 }: {
   cli: SUPPORTED_CLIS;
   cliArgs?: string[];
@@ -103,6 +106,7 @@ export default async function cliYes({
   removeControlCharactersFromStdout?: boolean;
   verbose?: boolean;
   queue?: boolean;
+  install?: boolean; // if true, install the cli tool if not installed, e.g. will run `npm install -g cursor-agent`
 }) {
   // those overrides seems only works in bun
   // await Promise.allSettled([
@@ -118,7 +122,11 @@ export default async function cliYes({
   //   });
 
   if (!cli) throw new Error(`cli is required`);
-  const conf = CLIS_CONFIG[cli] || DIE(`Unsupported cli tool: ${cli}`);
+  const conf =
+    CLIS_CONFIG[cli] ||
+    DIE(
+      `Unsupported cli tool: ${cli}, current process.argv: ${process.argv.join(' ')}`,
+    );
 
   // Acquire lock before starting agent (if in git repo or same cwd and lock is not disabled)
   const workingDir = cwd ?? process.cwd();
@@ -157,12 +165,12 @@ export default async function cliYes({
   // const pty = await import('node-pty');
 
   // its recommened to use bun-pty in windows
-  const pty = await (globalThis.Bun ? import('bun-pty') : import('node-pty'))
-    // .catch(async () => await import('node-pty'))
-    .catch(async () =>
-      DIE('Please install node-pty or bun-pty, run this: bun install bun-pty'),
-    );
-  console.log(globalThis.Bun);
+  const pty = await (globalThis.Bun
+    ? import('bun-pty')
+    : import('node-pty')
+  ).catch(async () =>
+    DIE('Please install node-pty or bun-pty, run this: bun install bun-pty'),
+  );
 
   // Detect if running as sub-agent
   const isSubAgent = !!process.env.CLAUDE_PPID;
@@ -223,34 +231,60 @@ export default async function cliYes({
   }
   const cliCommand = cliConf?.binary || cli;
 
+  const spawn = () => {
+    // const [bin, ...args] = [...parseCommandString((cliConf.bunx ? 'bunx --bun ' : '') + cliCommand), ...(cliArgs)];
+    // console.log(`Spawning ${bin} with args: ${JSON.stringify(args)}`);
+    // return pty.spawn(bin!, args, getPtyOptions());
+    return pty.spawn(cliCommand, cliArgs, getPtyOptions());
+  };
   let shell = catcher(
-    (error: unknown) => {
+    // error handler
+    (error: unknown, fn, ...args) => {
       console.error(`Fatal: Failed to start ${cliCommand}.`);
+
       if (cliConf?.install && isCommandNotFoundError(error))
+        if (install) {
+          console.log(`Attempting to install ${cli}...`);
+          execaCommandSync(cliConf.install, { stdio: 'inherit' });
+          console.log(
+            `${cli} installed successfully. Please rerun the command.`,
+          );
+          return spawn();
+        }
+      console.error(
+        `If you did not installed it yet, Please install it first: ${cliConf.install}`,
+      );
+
+      if (
+        globalThis.Bun &&
+        error instanceof Error &&
+        error.stack?.includes('bun-pty')
+      ) {
+        // try to fix bun-pty issues
         console.error(
-          `If you did not installed it yet, Please install it first: ${cliConf.install}`,
+          `Detected bun-pty issue, attempted to fix it. Please try again.`,
         );
+        require('./fix-pty.js');
+        // unable to retry with same process, so exit here.
+      }
       throw error;
 
       function isCommandNotFoundError(e: unknown) {
         if (e instanceof Error) {
           return (
-            e.message.includes('command not found') ||
-            e.message.includes('ENOENT') ||
+            e.message.includes('command not found') || // unix
+            e.message.includes('ENOENT') || // unix
             e.message.includes('spawn') // windows
           );
         }
         return false;
       }
     },
-    () => pty.spawn(cliCommand, cliArgs, getPtyOptions()),
+    spawn,
   )();
   const pendingExitCode = Promise.withResolvers<number | null>();
   let pendingExitCodeValue = null;
 
-  // TODO handle error if claude is not installed, show msg:
-  // npm install -g @anthropic-ai/claude-code
-
   async function onData(data: string) {
     // append data to the buffer, so we can process it later
     await outputWriter.write(data);

package/ts/parseCliArgs.ts

@@ -1,4 +1,4 @@
-import enhancedMs from 'enhanced-ms';
+import ms from 'ms';
 import yargs from 'yargs';
 import { hideBin } from 'yargs/helpers';
 import { SUPPORTED_CLIS } from '.';
@@ -12,7 +12,7 @@ export function parseCliArgs(argv: string[]) {
   const scriptName = argv[1]?.split(/[\/\\]/).pop();
   const cliName = ((e?: string) => {
     if (e === 'cli' || e === 'cli.ts' || e === 'cli.js') return undefined;
-    return e?.replace(/-yes$/, '');
+    return e?.replace(/-yes(\.[jt]s)?$/, '');
   })(scriptName);
 
   // Parse args with yargs (same logic as cli.ts:16-73)
@@ -105,7 +105,7 @@ export function parseCliArgs(argv: string[]) {
       [parsedArgv.prompt, dashPrompt].filter(Boolean).join(' ') || undefined,
     exitOnIdle: Number(
       (parsedArgv.idle || parsedArgv.exitOnIdle)?.replace(/.*/, (e) =>
-        String(enhancedMs(e)),
+        String(ms(e as ms.StringValue)),
       ) || 0,
     ),
     queue: parsedArgv.queue,

package/ts/yesLog.ts

@@ -1,6 +1,6 @@
 import { appendFileSync, rmSync } from 'node:fs';
 import tsaComposer from 'tsa-composer';
-import { catcher } from './tryCatch';
+import { catcher } from './catcher';
 
 let initial = true;
 

package/ts/tryCatch.ts

@@ -1,25 +0,0 @@
-// curried overload
-export function catcher<F extends (...args: any[]) => any, R>(
-  catchFn: (error: unknown) => R,
-): (fn: F) => (...args: Parameters<F>) => ReturnType<F> | R;
-
-// direct overload
-export function catcher<F extends (...args: any[]) => any, R>(
-  catchFn: (error: unknown) => R,
-  fn: F,
-): (...args: Parameters<F>) => ReturnType<F> | R;
-
-// implementation
-export function catcher<F extends (...args: any[]) => any, R>(
-  catchFn: (error: unknown) => R,
-  fn?: F,
-) {
-  if (!fn) return (fn: F) => catcher(catchFn, fn) as any;
-  return (...args: Parameters<F>) => {
-    try {
-      return fn(...args);
-    } catch (error) {
-      return catchFn(error);
-    }
-  };
-}