claude-yes 1.31.2 → 1.32.2

package/ts/runningLock.ts

@@ -1,15 +1,15 @@
-import { execSync } from 'child_process';
-import { existsSync } from 'fs';
-import { mkdir, readFile, rename, unlink, writeFile } from 'fs/promises';
-import { homedir } from 'os';
-import path from 'path';
+import { execSync } from "child_process";
+import { existsSync } from "fs";
+import { mkdir, readFile, rename, writeFile } from "fs/promises";
+import { homedir } from "os";
+import path from "path";
 
 export interface Task {
   cwd: string;
   gitRoot?: string;
   task: string;
   pid: number;
-  status: 'running' | 'queued' | 'completed' | 'failed';
+  status: "running" | "queued" | "completed" | "failed";
   startedAt: number;
   lockedAt: number;
 }
@@ -24,8 +24,8 @@ interface LockCheckResult {
   lockKey: string;
 }
 
-const LOCK_DIR = path.join(homedir(), '.claude-yes');
-const LOCK_FILE = path.join(LOCK_DIR, 'running.lock.json');
+const getLockDir = () => path.join(process.env.CLAUDE_YES_HOME || homedir(), ".claude-yes");
+const getLockFile = () => path.join(getLockDir(), "running.lock.json");
 const MAX_RETRIES = 5;
 const RETRY_DELAYS = [50, 100, 200, 400, 800]; // exponential backoff in ms
 const POLL_INTERVAL = 2000; // 2 seconds
@@ -48,10 +48,10 @@ function isProcessRunning(pid: number): boolean {
  */
 function getGitRoot(cwd: string): string | null {
   try {
-    const result = execSync('git rev-parse --show-toplevel', {
+    const result = execSync("git rev-parse --show-toplevel", {
       cwd,
-      encoding: 'utf8',
-      stdio: ['pipe', 'pipe', 'ignore'],
+      encoding: "utf8",
+      stdio: ["pipe", "pipe", "ignore"],
     });
     return result.trim();
   } catch {
@@ -94,13 +94,15 @@ function sleep(ms: number): Promise<void> {
  */
 async function readLockFile(): Promise<LockFile> {
   try {
-    await mkdir(LOCK_DIR, { recursive: true });
+    const lockDir = getLockDir();
+    const lockFilePath = getLockFile();
+    await mkdir(lockDir, { recursive: true });
 
-    if (!existsSync(LOCK_FILE)) {
+    if (!existsSync(lockFilePath)) {
       return { tasks: [] };
     }
 
-    const content = await readFile(LOCK_FILE, 'utf8');
+    const content = await readFile(lockFilePath, "utf8");
     const lockFile = JSON.parse(content) as LockFile;
 
     // Clean stale locks while reading
@@ -110,7 +112,7 @@ async function readLockFile(): Promise<LockFile> {
     });
 
     return lockFile;
-  } catch (error) {
+  } catch {
     // If file is corrupted or doesn't exist, return empty lock file
     return { tasks: [] };
   }
@@ -119,18 +121,17 @@ async function readLockFile(): Promise<LockFile> {
 /**
  * Write lock file atomically with retry logic
  */
-async function writeLockFile(
-  lockFile: LockFile,
-  retryCount = 0,
-): Promise<void> {
+async function writeLockFile(lockFile: LockFile, retryCount = 0): Promise<void> {
   try {
-    await mkdir(LOCK_DIR, { recursive: true });
+    const lockDir = getLockDir();
+    const lockFilePath = getLockFile();
+    await mkdir(lockDir, { recursive: true });
 
-    const tempFile = `${LOCK_FILE}.tmp.${process.pid}`;
-    await writeFile(tempFile, JSON.stringify(lockFile, null, 2), 'utf8');
+    const tempFile = `${lockFilePath}.tmp.${process.pid}`;
+    await writeFile(tempFile, JSON.stringify(lockFile, null, 2), "utf8");
 
     // Atomic rename
-    await rename(tempFile, LOCK_FILE);
+    await rename(tempFile, lockFilePath);
   } catch (error) {
     if (retryCount < MAX_RETRIES) {
       // Exponential backoff retry
@@ -144,10 +145,7 @@ async function writeLockFile(
 /**
  * Check if lock exists for the current working directory
  */
-async function checkLock(
-  cwd: string,
-  prompt: string,
-): Promise<LockCheckResult> {
+async function checkLock(cwd: string, _prompt: string): Promise<LockCheckResult> {
   const resolvedCwd = resolveRealPath(cwd);
   const gitRoot = isGitRepo(resolvedCwd) ? getGitRoot(resolvedCwd) : null;
   const lockKey = gitRoot || resolvedCwd;
@@ -157,7 +155,7 @@ async function checkLock(
   // Find running tasks for this location
   const blockingTasks = lockFile.tasks.filter((task) => {
     if (!isProcessRunning(task.pid)) return false; // Skip stale locks
-    if (task.status !== 'running') return false; // Only check running tasks
+    if (task.status !== "running") return false; // Only check running tasks
 
     if (gitRoot && task.gitRoot) {
       // In git repo: check by git root
@@ -191,10 +189,7 @@ async function addTask(task: Task): Promise<void> {
 /**
  * Update task status
  */
-async function updateTaskStatus(
-  pid: number,
-  status: Task['status'],
-): Promise<void> {
+async function updateTaskStatus(pid: number, status: Task["status"]): Promise<void> {
   const lockFile = await readLockFile();
   const task = lockFile.tasks.find((t) => t.pid === pid);
 
@@ -216,17 +211,14 @@ async function removeTask(pid: number): Promise<void> {
 /**
  * Wait for lock to be released
  */
-async function waitForUnlock(
-  blockingTasks: Task[],
-  currentTask: Task,
-): Promise<void> {
+async function waitForUnlock(blockingTasks: Task[], 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' });
+  await addTask({ ...currentTask, status: "queued" });
 
   // Set up keyboard input handling
   const stdin = process.stdin;
@@ -239,30 +231,30 @@ async function waitForUnlock(
 
   const keyHandler = (key: Buffer) => {
     const char = key.toString();
-    if (char === 'b' || char === 'B') {
-      console.log('\n⚡ Bypassing queue...');
+    if (char === "b" || char === "B") {
+      console.log("\n⚡ Bypassing queue...");
       bypassed = true;
-    } else if (char === 'k' || char === 'K') {
-      console.log('\n🔪 Killing previous instance...');
+    } else if (char === "k" || char === "K") {
+      console.log("\n🔪 Killing previous instance...");
       killed = true;
     }
   };
 
-  stdin.on('data', keyHandler);
+  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...');
+      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');
+        process.kill(blockingTask.pid, "SIGTERM");
         console.log(`✓ Killed process ${blockingTask.pid}`);
         // Wait a bit for the process to be killed
         await sleep(1000);
@@ -278,20 +270,18 @@ async function waitForUnlock(
 
     if (!lockCheck.isLocked) {
       // Lock released, update status to running
-      await updateTaskStatus(currentTask.pid, 'running');
+      await updateTaskStatus(currentTask.pid, "running");
       console.log(`\n✓ Lock released, starting task...`);
       break;
     }
 
     // Show progress indicator
     dots = (dots + 1) % 4;
-    process.stdout.write(
-      `\r⏳ Queueing${'.'.repeat(dots)}${' '.repeat(3 - dots)}`,
-    );
+    process.stdout.write(`\r⏳ Queueing${".".repeat(dots)}${" ".repeat(3 - dots)}`);
   }
 
   // Clean up keyboard handler
-  stdin.off('data', keyHandler);
+  stdin.off("data", keyHandler);
   stdin.setRawMode?.(wasRaw);
   if (!wasRaw) stdin.pause();
 }
@@ -320,7 +310,7 @@ export async function cleanStaleLocks(): Promise<void> {
  */
 export async function acquireLock(
   cwd: string,
-  prompt: string = 'no prompt provided',
+  prompt: string = "no prompt provided",
 ): Promise<void> {
   const resolvedCwd = resolveRealPath(cwd);
   const gitRoot = isGitRepo(resolvedCwd) ? getGitRoot(resolvedCwd) : null;
@@ -330,7 +320,7 @@ export async function acquireLock(
     gitRoot: gitRoot || undefined,
     task: prompt.substring(0, 100), // Limit task description length
     pid: process.pid,
-    status: 'running',
+    status: "running",
     startedAt: Date.now(),
     lockedAt: Date.now(),
   };
@@ -355,7 +345,7 @@ export async function releaseLock(pid: number = process.pid): Promise<void> {
  * Update status of current task
  */
 export async function updateCurrentTaskStatus(
-  status: Task['status'],
+  status: Task["status"],
   pid: number = process.pid,
 ): Promise<void> {
   await updateTaskStatus(pid, status);
@@ -365,8 +355,7 @@ export async function updateCurrentTaskStatus(
  * Check if we should use locking for this directory
  * Only use locking if we're in a git repository
  */
-export function shouldUseLock(cwd: string): boolean {
-  const resolvedCwd = resolveRealPath(cwd);
+export function shouldUseLock(_cwd: string): boolean {
   // Only use lock if in git repo OR if explicitly requested
   // For now, use lock for all cases to handle same-dir conflicts
   return true;

package/ts/session-integration.spec.ts

@@ -1,41 +1,37 @@
-import { describe, expect, it } from 'bun:test';
-import {
-  extractSessionId,
-  extractSessionIdFromSessionMeta,
-} from './codexSessionManager';
+import { describe, expect, it } from "bun:test";
+import { extractSessionId, extractSessionIdFromSessionMeta } from "./resume/codexSessionManager";
 
-describe('Session Extraction Test', () => {
-  it('should extract session IDs from various codex output formats', async () => {
-    console.log('\n=== Session ID Extraction Test ===');
+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: "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: "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: "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.',
+        name: "No UUID present",
+        output: "Welcome to codex! Type your message and press enter.",
         expected: null,
       },
       {
-        name: 'Multiple UUIDs (should get first)',
+        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',
+          "Old: 1111e659-0e5f-7843-8876-5a65c64e77c0 New: 2222e659-0e5f-7843-8876-5a65c64e77c0",
+        expected: "1111e659-0e5f-7843-8876-5a65c64e77c0",
       },
     ];
 
@@ -48,54 +44,50 @@ describe('Session Extraction Test', () => {
       expect(result).toBe(testCase.expected);
     }
 
-    console.log('✅ All session extraction tests passed!\n');
+    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 ===');
+  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');
+    expect(sessionId).toBe("0199e659-0e5f-7843-8876-5a65c64e77c0");
 
-    console.log('✅ Session metadata extraction test passed!\n');
+    console.log("✅ Session metadata extraction test passed!\n");
   });
 
-  it('should demonstrate session tracking workflow', async () => {
-    console.log('\n=== Session Tracking Workflow Demo ===');
+  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/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',
+        directory: "logs/cwd2",
+        output: "Resuming session... Using ID: bbbb2222-3333-4444-5555-ccccddddeeee",
       },
     ];
 
-    console.log('Simulating session capture from codex output:');
+    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('---');
+      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,
-      );
+      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');
+    console.log("✅ Workflow demonstration completed!\n");
   });
 });

package/ts/utils.spec.ts

@@ -1,21 +1,21 @@
-import { describe, expect, it } from 'vitest';
-import { type DeepPartial, deepMixin, sleepms } from './utils';
+import { describe, expect, it } from "vitest";
+import { type DeepPartial, deepMixin, sleepms } from "./utils";
 
-describe('utils', () => {
-  describe('sleepms', () => {
-    it('should return a promise', () => {
+describe("utils", () => {
+  describe("sleepms", () => {
+    it("should return a promise", () => {
       const result = sleepms(100);
       expect(result).toBeInstanceOf(Promise);
     });
 
-    it('should resolve after some time', async () => {
+    it("should resolve after some time", async () => {
       const start = Date.now();
       await sleepms(10);
       const end = Date.now();
       expect(end - start).toBeGreaterThanOrEqual(5); // Allow some margin
     });
 
-    it('should handle zero milliseconds', async () => {
+    it("should handle zero milliseconds", async () => {
       const start = Date.now();
       await sleepms(0);
       const end = Date.now();
@@ -23,8 +23,8 @@ describe('utils', () => {
     });
   });
 
-  describe('deepMixin', () => {
-    it('should merge simple properties', () => {
+  describe("deepMixin", () => {
+    it("should merge simple properties", () => {
       const target = { a: 1, b: 2 };
       const source = { b: 3, c: 4 };
       const result = deepMixin(target, source);
@@ -33,25 +33,25 @@ describe('utils', () => {
       expect(result).toBe(target); // Should modify original object
     });
 
-    it('should merge nested objects', () => {
+    it("should merge nested objects", () => {
       const target = {
-        user: { name: 'John', age: 30 },
-        settings: { theme: 'dark' },
+        user: { name: "John", age: 30 },
+        settings: { theme: "dark" },
       };
       const source: DeepPartial<typeof target> = {
         user: { age: 31 },
-        settings: { language: 'en' } as any,
+        settings: { language: "en" } as any,
       };
 
       deepMixin(target, source);
 
       expect(target).toEqual({
-        user: { name: 'John', age: 31 },
-        settings: { theme: 'dark', language: 'en' },
+        user: { name: "John", age: 31 },
+        settings: { theme: "dark", language: "en" },
       });
     });
 
-    it('should create nested objects when target property is null', () => {
+    it("should create nested objects when target property is null", () => {
       const target: any = { config: null };
       const source = { config: { enabled: true } };
 
@@ -62,8 +62,8 @@ describe('utils', () => {
       });
     });
 
-    it('should create nested objects when target property is primitive', () => {
-      const target: any = { config: 'string' };
+    it("should create nested objects when target property is primitive", () => {
+      const target: any = { config: "string" };
       const source = { config: { enabled: true } };
 
       deepMixin(target, source);
@@ -73,7 +73,7 @@ describe('utils', () => {
       });
     });
 
-    it('should handle arrays by replacing them', () => {
+    it("should handle arrays by replacing them", () => {
       const target = { items: [1, 2, 3] };
       const source = { items: [4, 5] };
 
@@ -82,7 +82,7 @@ describe('utils', () => {
       expect(target).toEqual({ items: [4, 5] });
     });
 
-    it('should ignore undefined values', () => {
+    it("should ignore undefined values", () => {
       const target = { a: 1, b: 2 };
       const source = { a: undefined, c: 3 };
 
@@ -91,7 +91,7 @@ describe('utils', () => {
       expect(target).toEqual({ a: 1, b: 2, c: 3 });
     });
 
-    it('should handle null values', () => {
+    it("should handle null values", () => {
       const target = { a: 1, b: 2 };
       const source = { a: null, c: 3 };
 
@@ -100,18 +100,18 @@ describe('utils', () => {
       expect(target).toEqual({ a: null, b: 2, c: 3 });
     });
 
-    it('should handle deeply nested structures', () => {
+    it("should handle deeply nested structures", () => {
       const target = {
         level1: {
           level2: {
-            level3: { value: 'old' },
+            level3: { value: "old" },
           },
         },
       };
       const source = {
         level1: {
           level2: {
-            level3: { value: 'new', extra: 'added' },
+            level3: { value: "new", extra: "added" },
           },
         },
       };
@@ -121,13 +121,13 @@ describe('utils', () => {
       expect(target).toEqual({
         level1: {
           level2: {
-            level3: { value: 'new', extra: 'added' },
+            level3: { value: "new", extra: "added" },
           },
         },
       });
     });
 
-    it('should handle empty objects', () => {
+    it("should handle empty objects", () => {
       const target = {};
       const source = {};
 
@@ -137,32 +137,32 @@ describe('utils', () => {
       expect(result).toBe(target);
     });
 
-    it('should handle complex mixed types', () => {
+    it("should handle complex mixed types", () => {
       const target: any = {
-        string: 'value',
+        string: "value",
         number: 42,
         boolean: true,
-        object: { nested: 'value' },
+        object: { nested: "value" },
         array: [1, 2, 3],
       };
       const source: any = {
-        string: 'new value',
+        string: "new value",
         number: 100,
         boolean: false,
-        object: { nested: 'new value', added: 'property' },
+        object: { nested: "new value", added: "property" },
         array: [4, 5],
-        newProp: 'added',
+        newProp: "added",
       };
 
       deepMixin(target, source);
 
       expect(target).toEqual({
-        string: 'new value',
+        string: "new value",
         number: 100,
         boolean: false,
-        object: { nested: 'new value', added: 'property' },
+        object: { nested: "new value", added: "property" },
         array: [4, 5],
-        newProp: 'added',
+        newProp: "added",
       });
     });
   });

package/ts/utils.ts

@@ -1,14 +1,10 @@
 export function sleepms(ms: number) {
   return new Promise((resolve) => setTimeout(resolve, ms));
 }
-export function deepMixin<T>(target: T, source: DeepPartial<T>): T {
+export function deepMixin<T>(target: T, source: DeepPartial<T>, ...more: DeepPartial<T>[]): T {
   for (const key in source) {
-    if (
-      source[key] &&
-      typeof source[key] === 'object' &&
-      !Array.isArray(source[key])
-    ) {
-      if (!target[key] || typeof target[key] !== 'object') {
+    if (source[key] && typeof source[key] === "object" && !Array.isArray(source[key])) {
+      if (!target[key] || typeof target[key] !== "object") {
         (target as any)[key] = {};
       }
       deepMixin(target[key], source[key] as any);
@@ -16,6 +12,10 @@ export function deepMixin<T>(target: T, source: DeepPartial<T>): T {
       (target as any)[key] = source[key];
     }
   }
+
+  for (const moreSource of more) {
+    deepMixin(target, moreSource);
+  }
   return target;
 }
 export type DeepPartial<T> = {