claude-yes 1.30.0 → 1.31.1

package/dist/qwen-yes.js

@@ -14017,12 +14017,12 @@ function catcher(catchFn, fn) {
 }
 
 // ts/codexSessionManager.ts
-import { mkdir, readFile, writeFile } from "fs/promises";
+import { mkdir, readdir, readFile, writeFile } from "fs/promises";
 import { homedir } from "os";
 import path7 from "path";
 async function loadSessionMap() {
   try {
-    const content = await readFile(SESSIONS_FILE, "utf-8");
+    const content = await readFile(getSessionsFile(), "utf-8");
     return JSON.parse(content);
   } catch (error) {
     return {};
@@ -14030,8 +14030,9 @@ async function loadSessionMap() {
 }
 async function saveSessionMap(sessionMap) {
   try {
-    await mkdir(path7.dirname(SESSIONS_FILE), { recursive: true });
-    await writeFile(SESSIONS_FILE, JSON.stringify(sessionMap, null, 2));
+    const sessionsFile = getSessionsFile();
+    await mkdir(path7.dirname(sessionsFile), { recursive: true });
+    await writeFile(sessionsFile, JSON.stringify(sessionMap, null, 2));
   } catch (error) {
     console.warn("Failed to save codex session map:", error);
   }
@@ -14044,7 +14045,78 @@ async function storeSessionForCwd(cwd, sessionId) {
   };
   await saveSessionMap(sessionMap);
 }
+async function parseCodexSessionFile(filePath) {
+  try {
+    const content = await readFile(filePath, "utf-8");
+    const lines2 = content.trim().split(`
+`);
+    for (const line of lines2) {
+      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) {
+    return null;
+  }
+}
+async function getAllCodexSessions() {
+  const sessions = [];
+  const codexSessionsDir = getCodexSessionsDir();
+  try {
+    const years = await readdir(codexSessionsDir);
+    for (const year of years) {
+      const yearPath = path7.join(codexSessionsDir, year);
+      try {
+        const months = await readdir(yearPath);
+        for (const month of months) {
+          const monthPath = path7.join(yearPath, month);
+          try {
+            const days = await readdir(monthPath);
+            for (const day of days) {
+              const dayPath = path7.join(monthPath, day);
+              try {
+                const files = await readdir(dayPath);
+                for (const file of files) {
+                  if (file.endsWith(".jsonl")) {
+                    const sessionPath = path7.join(dayPath, file);
+                    const session = await parseCodexSessionFile(sessionPath);
+                    if (session) {
+                      sessions.push(session);
+                    }
+                  }
+                }
+              } catch (error) {}
+            }
+          } catch (error) {}
+        }
+      } catch (error) {}
+    }
+  } catch (error) {
+    return [];
+  }
+  return sessions.sort((a2, b) => new Date(b.timestamp).getTime() - new Date(a2.timestamp).getTime());
+}
+async function getMostRecentCodexSessionForCwd(targetCwd) {
+  const allSessions = await getAllCodexSessions();
+  const sessionsForCwd = allSessions.filter((session) => session.cwd === targetCwd);
+  return sessionsForCwd[0] || null;
+}
 async function getSessionForCwd(cwd) {
+  const recentSession = await getMostRecentCodexSessionForCwd(cwd);
+  if (recentSession) {
+    return recentSession.id;
+  }
   const sessionMap = await loadSessionMap();
   return sessionMap[cwd]?.sessionId || null;
 }
@@ -14053,10 +14125,8 @@ function extractSessionId(output) {
   const match = output.match(sessionIdRegex);
   return match ? match[0] : null;
 }
-var SESSIONS_FILE;
-var init_codexSessionManager = __esm(() => {
-  SESSIONS_FILE = path7.join(homedir(), ".config", "cli-yes", "codex-sessions.json");
-});
+var getSessionsFile = () => process.env.CLI_YES_TEST_HOME ? path7.join(process.env.CLI_YES_TEST_HOME, ".config", "cli-yes", "codex-sessions.json") : path7.join(homedir(), ".config", "cli-yes", "codex-sessions.json"), getCodexSessionsDir = () => process.env.CLI_YES_TEST_HOME ? path7.join(process.env.CLI_YES_TEST_HOME, ".codex", "sessions") : path7.join(homedir(), ".codex", "sessions");
+var init_codexSessionManager = () => {};
 
 // ts/idleWaiter.ts
 class IdleWaiter {
@@ -20339,8 +20409,9 @@ var init_ts = __esm(async () => {
 // ts/cli.ts
 init_dist();
 init_cli_yes_config();
-if (!globalThis.Bun) {
-  console.log("Re-running with Bun...", process.argv);
+var hasNodePty = !!await import("node-pty").catch(() => null);
+if (!globalThis.Bun && !hasNodePty) {
+  console.log("No node-pty installed. Re-running with Bun...", process.argv);
   (await import("child_process")).spawnSync("node_modules/.bin/bun", [process.argv[1], "--", ...process.argv.slice(2)], { stdio: "inherit" });
   process.exit(0);
 }
@@ -20357,5 +20428,5 @@ if (config2.verbose) {
 var { exitCode } = await cliYes2(config2);
 process.exit(exitCode ?? 1);
 
-//# debugId=A6B971C2331DA0F864756E2164756E21
+//# debugId=229819D0379CAA1264756E2164756E21
 //# sourceMappingURL=cli.js.map

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "claude-yes",
-  "version": "1.30.0",
+  "version": "1.31.1",
   "description": "A wrapper tool that automates interactions with various AI CLI tools by automatically handling common prompts and responses.",
   "keywords": [
     "claude",
@@ -91,11 +91,9 @@
     ]
   },
   "dependencies": {
-    "@types/ms": "^2.1.0",
     "bun": "^1.3.1",
     "bun-pty": "^0.3.2",
-    "from-node-stream": "^0.0.11",
-    "ms": "^2.1.3"
+    "from-node-stream": "^0.1.0"
   },
   "devDependencies": {
     "@biomejs/biome": "^2.2.5",
@@ -105,12 +103,14 @@
     "@semantic-release/release-notes-generator": "^14.1.0",
     "@types/bun": "^1.2.18",
     "@types/jest": "^30.0.0",
+    "@types/ms": "^2.1.0",
     "@types/node": "^24.0.10",
     "@types/yargs": "^17.0.33",
     "cpu-wait": "^0.0.10",
     "execa": "^9.6.0",
     "husky": "^9.1.7",
     "lint-staged": "^16.1.4",
+    "ms": "^2.1.3",
     "p-map": "^7.0.3",
     "phpdie": "^1.7.0",
     "rambda": "^10.3.2",
@@ -125,5 +125,10 @@
   "peerDependencies": {
     "node-pty": "^1.1.0-beta38",
     "typescript": "^5.8.3"
+  },
+  "peerDependenciesMeta": {
+    "node-pty": {
+      "optional": true
+    }
   }
 }

package/ts/cli.ts

@@ -3,10 +3,10 @@ import DIE from 'phpdie';
 import cliYesConfig from '../cli-yes.config';
 
 // if node-pty is not installed, re-run with bun
-// const hasNodePty = !!await import('node-pty').catch(() => null);
-if (!globalThis.Bun) {
+const hasNodePty = !!(await import('node-pty').catch(() => null));
+if (!globalThis.Bun && !hasNodePty) {
   // run with same arguments in Bun if not already
-  console.log('Re-running with Bun...', process.argv);
+  console.log('No node-pty installed. Re-running with Bun...', process.argv);
   (await import('child_process')).spawnSync(
     'node_modules/.bin/bun',
     [process.argv[1]!, '--', ...process.argv.slice(2)],

package/ts/codex-resume.spec.ts

@@ -68,10 +68,6 @@ describe('Codex Session Restoration', () => {
     // Create test directories
     await mkdir(cwd1, { recursive: true });
     await mkdir(cwd2, { recursive: true });
-
-    // Build the project first
-    const buildResult = await runCodexYes(['--help'], process.cwd(), 10000);
-    console.log('Build check:', buildResult.exitCode === 0 ? 'OK' : 'FAILED');
   });
 
   afterAll(async () => {

package/ts/codexSessionManager.test.ts

@@ -0,0 +1,259 @@
+import { afterEach, beforeEach, describe, expect, it } from 'bun:test';
+import { mkdir, rm, writeFile } from 'fs/promises';
+import { tmpdir } from 'os';
+import { join } from 'path';
+import {
+  type CodexSession,
+  extractSessionId,
+  extractSessionIdFromSessionMeta,
+  getAllWorkingDirectories,
+  getRecentSessionsForCwd,
+  getSessionForCwd,
+  storeSessionForCwd,
+} from './codexSessionManager';
+
+// Create a temporary test directory
+const testDir = join(tmpdir(), 'claude-yes-test-' + Date.now());
+const testCodexDir = join(testDir, '.codex', 'sessions');
+const testConfigDir = join(testDir, '.config', 'cli-yes');
+
+// Store original environment
+const originalTestHome = process.env.CLI_YES_TEST_HOME;
+
+beforeEach(async () => {
+  // Set up test directories
+  await mkdir(testCodexDir, { recursive: true });
+  await mkdir(testConfigDir, { recursive: true });
+
+  // Set test home directory
+  process.env.CLI_YES_TEST_HOME = testDir;
+});
+
+afterEach(async () => {
+  // Clean up
+  process.env.CLI_YES_TEST_HOME = originalTestHome;
+  await rm(testDir, { recursive: true, force: true });
+});
+
+// Helper function to create a mock codex session file
+async function createMockSessionFile(sessionData: {
+  id: string;
+  timestamp: string;
+  cwd: string;
+  git?: any;
+}) {
+  const year = new Date(sessionData.timestamp).getFullYear();
+  const month = String(new Date(sessionData.timestamp).getMonth() + 1).padStart(
+    2,
+    '0',
+  );
+  const day = String(new Date(sessionData.timestamp).getDate()).padStart(
+    2,
+    '0',
+  );
+
+  const sessionDir = join(testCodexDir, String(year), month, day);
+  await mkdir(sessionDir, { recursive: true });
+
+  const filename = `test-session-${sessionData.id}.jsonl`;
+  const filePath = join(sessionDir, filename);
+
+  const sessionMeta = {
+    timestamp: sessionData.timestamp,
+    type: 'session_meta',
+    payload: {
+      id: sessionData.id,
+      timestamp: sessionData.timestamp,
+      cwd: sessionData.cwd,
+      originator: 'codex_cli_rs',
+      cli_version: '0.42.0',
+      instructions: null,
+      git: sessionData.git,
+    },
+  };
+
+  const content = JSON.stringify(sessionMeta) + '\n';
+  await writeFile(filePath, content);
+
+  return filePath;
+}
+
+describe('codexSessionManager', () => {
+  describe('extractSessionId', () => {
+    it('should extract valid session IDs from output', () => {
+      const output1 = 'Session ID: 019a4877-5f3c-7763-b573-513cc2d5d291';
+      const output2 =
+        'Starting session 019a4877-5f3c-7763-b573-513cc2d5d291 for user';
+      const output3 = 'No session ID here';
+
+      expect(extractSessionId(output1)).toBe(
+        '019a4877-5f3c-7763-b573-513cc2d5d291',
+      );
+      expect(extractSessionId(output2)).toBe(
+        '019a4877-5f3c-7763-b573-513cc2d5d291',
+      );
+      expect(extractSessionId(output3)).toBeNull();
+    });
+  });
+
+  describe('extractSessionIdFromSessionMeta', () => {
+    it('should extract session ID from valid session metadata', () => {
+      const sessionContent = JSON.stringify({
+        timestamp: '2025-11-03T06:46:14.123Z',
+        type: 'session_meta',
+        payload: {
+          id: '019a4877-5f3c-7763-b573-513cc2d5d291',
+          cwd: '/test/path',
+        },
+      });
+
+      expect(extractSessionIdFromSessionMeta(sessionContent)).toBe(
+        '019a4877-5f3c-7763-b573-513cc2d5d291',
+      );
+    });
+
+    it('should fall back to regex extraction for invalid JSON', () => {
+      const invalidContent =
+        'Invalid JSON but contains 019a4877-5f3c-7763-b573-513cc2d5d291';
+
+      expect(extractSessionIdFromSessionMeta(invalidContent)).toBe(
+        '019a4877-5f3c-7763-b573-513cc2d5d291',
+      );
+    });
+  });
+
+  describe('session storage and retrieval', () => {
+    it('should store and retrieve session IDs for directories', async () => {
+      const cwd = '/test/project';
+      const sessionId = '019a4877-5f3c-7763-b573-513cc2d5d291';
+
+      await storeSessionForCwd(cwd, sessionId);
+      const retrieved = await getSessionForCwd(cwd);
+
+      expect(retrieved).toBe(sessionId);
+    });
+
+    it('should return null for non-existent directories', async () => {
+      const result = await getSessionForCwd('/non/existent');
+      expect(result).toBeNull();
+    });
+  });
+
+  describe('codex session file parsing', () => {
+    it('should read sessions from actual codex files', async () => {
+      const sessionData = {
+        id: '019a4877-5f3c-7763-b573-513cc2d5d291',
+        timestamp: '2025-11-03T06:46:14.123Z',
+        cwd: '/v1/code/snomiao/claude-yes/tree/main',
+        git: {
+          commit_hash: 'abc123',
+          branch: 'main',
+          repository_url: 'git@github.com:snomiao/claude-yes.git',
+        },
+      };
+
+      await createMockSessionFile(sessionData);
+
+      const retrieved = await getSessionForCwd(sessionData.cwd);
+      expect(retrieved).toBe(sessionData.id);
+    });
+
+    it('should get recent sessions for a directory', async () => {
+      const cwd = '/test/project';
+      const sessions = [
+        {
+          id: 'session-1',
+          timestamp: '2025-11-03T10:00:00.000Z',
+          cwd,
+        },
+        {
+          id: 'session-2',
+          timestamp: '2025-11-03T09:00:00.000Z',
+          cwd,
+        },
+        {
+          id: 'session-3',
+          timestamp: '2025-11-03T08:00:00.000Z',
+          cwd,
+        },
+      ];
+
+      for (const session of sessions) {
+        await createMockSessionFile(session);
+      }
+
+      const recent = await getRecentSessionsForCwd(cwd, 2);
+      expect(recent).toHaveLength(2);
+      expect(recent[0].id).toBe('session-1'); // Most recent first
+      expect(recent[1].id).toBe('session-2');
+    });
+
+    it('should get all working directories with counts', async () => {
+      const sessions = [
+        {
+          id: 'session-1',
+          timestamp: '2025-11-03T10:00:00.000Z',
+          cwd: '/project-a',
+        },
+        {
+          id: 'session-2',
+          timestamp: '2025-11-03T09:00:00.000Z',
+          cwd: '/project-a',
+        },
+        {
+          id: 'session-3',
+          timestamp: '2025-11-03T08:00:00.000Z',
+          cwd: '/project-b',
+        },
+      ];
+
+      for (const session of sessions) {
+        await createMockSessionFile(session);
+      }
+
+      const directories = await getAllWorkingDirectories();
+      expect(directories).toHaveLength(2);
+
+      const projectA = directories.find((d) => d.cwd === '/project-a');
+      const projectB = directories.find((d) => d.cwd === '/project-b');
+
+      expect(projectA?.count).toBe(2);
+      expect(projectB?.count).toBe(1);
+
+      // Should be sorted by last session time (most recent first)
+      expect(directories[0].cwd).toBe('/project-a');
+    });
+  });
+
+  describe('fallback behavior', () => {
+    it('should fall back to stored mapping when no codex files exist', async () => {
+      const cwd = '/fallback/test';
+      const sessionId = 'fallback-session-id';
+
+      // Store in mapping but don't create codex file
+      await storeSessionForCwd(cwd, sessionId);
+
+      const retrieved = await getSessionForCwd(cwd);
+      expect(retrieved).toBe(sessionId);
+    });
+
+    it('should prefer codex files over stored mapping', async () => {
+      const cwd = '/preference/test';
+      const storedSessionId = 'stored-session';
+      const codexSessionId = 'codex-session';
+
+      // Store in mapping first
+      await storeSessionForCwd(cwd, storedSessionId);
+
+      // Create codex file with different session ID
+      await createMockSessionFile({
+        id: codexSessionId,
+        timestamp: '2025-11-03T10:00:00.000Z',
+        cwd,
+      });
+
+      const retrieved = await getSessionForCwd(cwd);
+      expect(retrieved).toBe(codexSessionId); // Should prefer codex file
+    });
+  });
+});