claude-yes 1.25.0 → 1.27.0

package/ts/index.ts

@@ -6,6 +6,11 @@ import sflow from 'sflow';
 import { TerminalTextRender } from 'terminal-render';
 import tsaComposer from 'tsa-composer';
 import rawConfig from '../cli-yes.config.js';
+import {
+  extractSessionId,
+  getSessionForCwd,
+  storeSessionForCwd,
+} from './codexSessionManager.js';
 import { defineCliYesConfig } from './defineConfig.js';
 import { IdleWaiter } from './idleWaiter';
 import { ReadyManager } from './ReadyManager';
@@ -171,6 +176,25 @@ export default async function cliYes({
     ? [...cliConf.defaultArgs, ...cliArgs]
     : cliArgs;
 
+  // Handle --continue flag for codex session restoration
+  const continueIndex = cliArgs.indexOf('--continue');
+  if (continueIndex !== -1 && cli === 'codex') {
+    // Remove the --continue flag from args
+    cliArgs.splice(continueIndex, 1);
+
+    // Try to get stored session for this directory
+    const storedSessionId = await getSessionForCwd(workingDir);
+    if (storedSessionId) {
+      // Replace or add resume args
+      cliArgs = ['resume', storedSessionId, ...cliArgs];
+      await yesLog`continue|using stored session ID: ${storedSessionId}`;
+    } else {
+      // Fallback to --last if no stored session
+      cliArgs = ['resume', '--last', ...cliArgs];
+      await yesLog`continue|no stored session, using --last`;
+    }
+  }
+
   if (prompt && cliConf.promptArg) {
     if (cliConf.promptArg === 'first-arg') {
       cliArgs = [prompt, ...cliArgs];
@@ -221,7 +245,7 @@ export default async function cliYes({
   }
 
   shell.onData(onData);
-  shell.onExit(function onExit({ exitCode }) {
+  shell.onExit(async function onExit({ exitCode }) {
     stdinReady.unready(); // start buffer stdin
     const agentCrashed = exitCode !== 0;
 
@@ -240,7 +264,20 @@ export default async function cliYes({
 
       console.log(`${cli} crashed, restarting...`);
 
-      shell = pty.spawn(cli, conf.restoreArgs, getPtyOptions());
+      // For codex, try to use stored session ID for this directory
+      let restoreArgs = conf.restoreArgs;
+      if (cli === 'codex') {
+        const storedSessionId = await getSessionForCwd(workingDir);
+        if (storedSessionId) {
+          // Use specific session ID instead of --last
+          restoreArgs = ['resume', storedSessionId];
+          await yesLog`restore|using stored session ID: ${storedSessionId}`;
+        } else {
+          await yesLog`restore|no stored session, using default restore args`;
+        }
+      }
+
+      shell = pty.spawn(cli, restoreArgs, getPtyOptions());
       shell.onData(onData);
       shell.onExit(onExit);
       return;
@@ -346,6 +383,15 @@ export default async function cliYes({
             isFatal = true;
             await exitAgent();
           }
+
+          // session ID capture for codex
+          if (cli === 'codex') {
+            const sessionId = extractSessionId(e);
+            if (sessionId) {
+              await yesLog`session|captured session ID: ${sessionId}`;
+              await storeSessionForCwd(workingDir, sessionId);
+            }
+          }
         })
         .run(),
     )

package/ts/parseCliArgs.spec.ts

@@ -0,0 +1,232 @@
+import { describe, expect, it } from 'vitest';
+import { parseCliArgs } from './parseCliArgs';
+
+describe('CLI argument parsing', () => {
+  it('should parse cli name from first positional argument', () => {
+    const result = parseCliArgs(['node', '/path/to/cli', 'claude']);
+
+    expect(result.cli).toBe('claude');
+  });
+
+  it('should parse prompt from --prompt flag', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--prompt',
+      'hello world',
+      'claude',
+    ]);
+
+    expect(result.prompt).toBe('hello world');
+  });
+
+  it('should parse prompt from -- separator', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      'claude',
+      '--',
+      'hello',
+      'world',
+    ]);
+
+    expect(result.prompt).toBe('hello world');
+  });
+
+  it('should parse prompt from only -- separator with -yes cli', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/claude-yes',
+      '--',
+      'hello',
+      'world',
+    ]);
+
+    expect(result.prompt).toBe('hello world');
+  });
+
+  it('should combine --prompt and -- prompt', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--prompt',
+      'part1',
+      'claude',
+      '--',
+      'part2',
+    ]);
+
+    expect(result.prompt).toBe('part1 part2');
+  });
+
+  it('should parse --idle flag', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--idle',
+      '30s',
+      'claude',
+    ]);
+
+    expect(result.exitOnIdle).toBe(30000);
+  });
+
+  it('should parse --exit-on-idle flag (deprecated)', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--exit-on-idle',
+      '1m',
+      'claude',
+    ]);
+
+    expect(result.exitOnIdle).toBe(60000);
+  });
+
+  it('should parse --robust flag', () => {
+    const result = parseCliArgs(['node', '/path/to/cli', '--robust', 'claude']);
+
+    expect(result.robust).toBe(true);
+  });
+
+  it('should parse --no-robust flag', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--no-robust',
+      'claude',
+    ]);
+
+    expect(result.robust).toBe(false);
+  });
+
+  it('should parse --queue flag', () => {
+    const result = parseCliArgs(['node', '/path/to/cli', '--queue', 'claude']);
+
+    expect(result.queue).toBe(true);
+  });
+
+  it('should parse --no-queue flag', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--no-queue',
+      'claude',
+    ]);
+
+    expect(result.queue).toBe(false);
+  });
+
+  it('should parse --logFile flag', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--logFile',
+      './output.log',
+      'claude',
+    ]);
+
+    expect(result.logFile).toBe('./output.log');
+  });
+
+  it('should parse --verbose flag', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--verbose',
+      'claude',
+    ]);
+
+    expect(result.verbose).toBe(true);
+  });
+
+  it('should pass through unknown CLI args to cliArgs', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      'claude',
+      '--unknown-flag',
+      'value',
+    ]);
+
+    expect(result.cliArgs).toContain('--unknown-flag');
+    expect(result.cliArgs).toContain('value');
+  });
+
+  it('should separate cli-yes args from cli args before --', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      '--robust',
+      'claude',
+      '--claude-arg',
+      '--',
+      'prompt',
+    ]);
+
+    expect(result.cli).toBe('claude');
+    expect(result.robust).toBe(true);
+    expect(result.cliArgs).toContain('--claude-arg');
+    expect(result.prompt).toBe('prompt');
+  });
+
+  it('should detect cli name from script name (claude-yes)', () => {
+    const result = parseCliArgs([
+      '/usr/bin/node',
+      '/usr/local/bin/claude-yes',
+      '--prompt',
+      'test',
+    ]);
+
+    expect(result.cli).toBe('claude');
+  });
+
+  it('should detect cli name from script name (codex-yes)', () => {
+    const result = parseCliArgs([
+      '/usr/bin/node',
+      '/usr/local/bin/codex-yes',
+      '--prompt',
+      'test',
+    ]);
+
+    expect(result.cli).toBe('codex');
+  });
+
+  it('should prefer script name over explicit cli argument', () => {
+    const result = parseCliArgs([
+      '/usr/bin/node',
+      '/usr/local/bin/claude-yes',
+      '--prompt',
+      'test',
+      'gemini',
+    ]);
+
+    // cliName (from script) takes precedence over positional arg
+    expect(result.cli).toBe('claude');
+  });
+
+  it('should handle empty cliArgs when no positional cli is provided', () => {
+    const result = parseCliArgs([
+      '/usr/bin/node',
+      '/usr/local/bin/claude-yes',
+      '--prompt',
+      'prompt',
+    ]);
+
+    expect(result.cliArgs).toEqual([]);
+    expect(result.prompt).toBe('prompt');
+  });
+
+  it('should include all args when no -- separator is present', () => {
+    const result = parseCliArgs([
+      'node',
+      '/path/to/cli',
+      'claude',
+      '--some-flag',
+      '--another-flag',
+    ]);
+
+    expect(result.cliArgs).toContain('--some-flag');
+    expect(result.cliArgs).toContain('--another-flag');
+  });
+});

package/ts/parseCliArgs.ts

@@ -0,0 +1,114 @@
+import enhancedMs from 'enhanced-ms';
+import yargs from 'yargs';
+import { hideBin } from 'yargs/helpers';
+import { SUPPORTED_CLIS } from '.';
+
+/**
+ * Parse CLI arguments the same way cli.ts does
+ * This is a test helper that mirrors the parsing logic in cli.ts
+ */
+export function parseCliArgs(argv: string[]) {
+  // Detect cli name from script name (same logic as cli.ts:10-14)
+  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$/, '');
+  })(scriptName);
+
+  // Parse args with yargs (same logic as cli.ts:16-73)
+  const parsedArgv = yargs(hideBin(argv))
+    .usage('Usage: $0 [cli] [cli-yes args] [agent-cli args] [--] [prompts...]')
+    .example(
+      '$0 claude --idle=30s -- solve all todos in my codebase, commit one by one',
+      'Run Claude with a 30 seconds idle timeout, and the prompt is everything after `--`',
+    )
+    .option('robust', {
+      type: 'boolean',
+      default: true,
+      description:
+        're-spawn Claude with --continue if it crashes, only works for claude yet',
+      alias: 'r',
+    })
+    .option('logFile', {
+      type: 'string',
+      description: 'Rendered log file to write to.',
+    })
+    .option('prompt', {
+      type: 'string',
+      description: 'Prompt to send to Claude (also can be passed after --)',
+      alias: 'p',
+    })
+    .option('verbose', {
+      type: 'boolean',
+      description: 'Enable verbose logging, will emit ./agent-yes.log',
+      default: false,
+    })
+    .option('exit-on-idle', {
+      type: 'string',
+      description: 'Exit after a period of inactivity, e.g., "5s" or "1m"',
+      deprecated: 'use --idle instead',
+      default: '60s',
+      alias: 'e',
+    })
+    .option('idle', {
+      type: 'string',
+      description: 'Exit after a period of inactivity, e.g., "5s" or "1m"',
+      alias: 'i',
+    })
+    .option('queue', {
+      type: 'boolean',
+      description:
+        'Queue Agent when spawning multiple agents in the same directory/repo, can be disabled with --no-queue',
+      default: true,
+    })
+    .positional('cli', {
+      describe:
+        'The AI CLI to run, e.g., claude, codex, copilot, cursor, gemini',
+      type: 'string',
+      choices: SUPPORTED_CLIS,
+      demandOption: false,
+      default: cliName,
+    })
+    .help()
+    .version()
+    .parserConfiguration({
+      'unknown-options-as-args': true,
+      'halt-at-non-option': true,
+    })
+    .parseSync();
+
+  // Extract cli args and dash prompt (same logic as cli.ts:76-91)
+  const optionalIndex = (e: number) => (0 <= e ? e : undefined);
+  const rawArgs = argv.slice(2);
+  const cliArgIndex = optionalIndex(rawArgs.indexOf(String(parsedArgv._[0])));
+  const dashIndex = optionalIndex(rawArgs.indexOf('--'));
+
+  const cliArgsForSpawn = parsedArgv._[0]
+    ? rawArgs.slice(cliArgIndex ?? 0, dashIndex ?? undefined)
+    : [];
+  const dashPrompt: string | undefined =
+    dashIndex !== undefined
+      ? rawArgs.slice(dashIndex + 1).join(' ')
+      : undefined;
+
+  // Return the config object that would be passed to cliYes (same logic as cli.ts:99-121)
+  return {
+    cli: (cliName ||
+      parsedArgv.cli ||
+      parsedArgv._[0]
+        ?.toString()
+        ?.replace?.(/-yes$/, '')) as (typeof SUPPORTED_CLIS)[number],
+    cliArgs: cliArgsForSpawn,
+    prompt:
+      [parsedArgv.prompt, dashPrompt].filter(Boolean).join(' ') || undefined,
+    exitOnIdle: Number(
+      (parsedArgv.idle || parsedArgv.exitOnIdle)?.replace(/.*/, (e) =>
+        String(enhancedMs(e)),
+      ) || 0,
+    ),
+    queue: parsedArgv.queue,
+    robust: parsedArgv.robust,
+    logFile: parsedArgv.logFile,
+    verbose: parsedArgv.verbose,
+  };
+}

package/ts/session-integration.spec.ts

@@ -0,0 +1,101 @@
+import { describe, expect, it } from 'bun:test';
+import {
+  extractSessionId,
+  extractSessionIdFromSessionMeta,
+} from './codexSessionManager';
+
+describe('Session Extraction Test', () => {
+  it('should extract session IDs from various codex output formats', async () => {
+    console.log('\n=== Session ID Extraction Test ===');
+
+    // Test different formats where session IDs might appear
+    const testCases = [
+      {
+        name: 'Direct UUID in output',
+        output: 'Session started with ID: 0199e659-0e5f-7843-8876-5a65c64e77c0',
+        expected: '0199e659-0e5f-7843-8876-5a65c64e77c0',
+      },
+      {
+        name: 'UUID in brackets',
+        output:
+          'Using session [0199e659-0e5f-7843-8876-5a65c64e77c0] for this conversation',
+        expected: '0199e659-0e5f-7843-8876-5a65c64e77c0',
+      },
+      {
+        name: 'Mixed case UUID',
+        output: 'SESSION_ID: 0199E659-0E5F-7843-8876-5A65C64E77C0',
+        expected: '0199E659-0E5F-7843-8876-5A65C64E77C0',
+      },
+      {
+        name: 'No UUID present',
+        output: 'Welcome to codex! Type your message and press enter.',
+        expected: null,
+      },
+      {
+        name: 'Multiple UUIDs (should get first)',
+        output:
+          'Old: 1111e659-0e5f-7843-8876-5a65c64e77c0 New: 2222e659-0e5f-7843-8876-5a65c64e77c0',
+        expected: '1111e659-0e5f-7843-8876-5a65c64e77c0',
+      },
+    ];
+
+    for (const testCase of testCases) {
+      console.log(`Testing: ${testCase.name}`);
+      const result = extractSessionId(testCase.output);
+      console.log(`  Input: ${testCase.output}`);
+      console.log(`  Expected: ${testCase.expected}`);
+      console.log(`  Got: ${result}`);
+      expect(result).toBe(testCase.expected);
+    }
+
+    console.log('✅ All session extraction tests passed!\n');
+  });
+
+  it('should extract session ID from session metadata JSON', async () => {
+    console.log('\n=== Session Metadata Extraction Test ===');
+
+    const sessionMetaJson = `{"timestamp":"2025-10-15T05:30:20.265Z","type":"session_meta","payload":{"id":"0199e659-0e5f-7843-8876-5a65c64e77c0","timestamp":"2025-10-15T05:30:20.127Z","cwd":"/v1/code/project","originator":"codex_cli_rs"}}
+{"timestamp":"2025-10-15T05:30:20.415Z","type":"response_item","payload":{"type":"message","role":"user"}}`;
+
+    const sessionId = extractSessionIdFromSessionMeta(sessionMetaJson);
+    console.log(`Extracted session ID: ${sessionId}`);
+    expect(sessionId).toBe('0199e659-0e5f-7843-8876-5a65c64e77c0');
+
+    console.log('✅ Session metadata extraction test passed!\n');
+  });
+
+  it('should demonstrate session tracking workflow', async () => {
+    console.log('\n=== Session Tracking Workflow Demo ===');
+
+    // Simulate codex output that would contain session information
+    const mockCodexOutputs = [
+      {
+        directory: 'logs/cwd1',
+        output:
+          'Starting new conversation... Session ID: aaaa1111-2222-3333-4444-bbbbccccdddd',
+      },
+      {
+        directory: 'logs/cwd2',
+        output:
+          'Resuming session... Using ID: bbbb2222-3333-4444-5555-ccccddddeeee',
+      },
+    ];
+
+    console.log('Simulating session capture from codex output:');
+
+    for (const mock of mockCodexOutputs) {
+      const sessionId = extractSessionId(mock.output);
+      console.log(`Directory: ${mock.directory}`);
+      console.log(`Output: ${mock.output}`);
+      console.log(`Captured Session ID: ${sessionId}`);
+      console.log('---');
+
+      expect(sessionId).toBeTruthy();
+      expect(sessionId).toMatch(
+        /^[a-f0-9]{8}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{4}-[a-f0-9]{12}$/i,
+      );
+    }
+
+    console.log('✅ Workflow demonstration completed!\n');
+  });
+});

package/ts/cli.spec.ts

@@ -1,18 +0,0 @@
-import { vi } from 'vitest';
-
-// Mock cliYes function
-const mockCliYes = vi.fn(async ({ prompt }) => {
-  return { exitCode: 0, logs: 'mocked logs' };
-});
-
-test('CLI args parsing', () => {
-  const rawArgs = ['claude', '--verbose', '--idle=5m', '--', 'write tests'];
-  const optionalIndex = (e: number) => (0 <= e ? e : undefined);
-  const dashIndex = optionalIndex(rawArgs.indexOf('--'));
-  const dashPrompt = dashIndex
-    ? rawArgs.slice(dashIndex + 1).join(' ')
-    : undefined;
-
-  expect(dashPrompt).toBe('write tests');
-  expect(mockCliYes).toBeDefined();
-});