create-walle 0.9.13 → 0.9.15

package/template/claude-task-manager/lib/session-history.js

@@ -7,6 +7,8 @@ const { getResumeSpec: getAgentResumeSpec, normalizeAgentType } = require('./age
 
 const DEFAULT_CODEX_LOOKBACK_SEC = 10;
 const DEFAULT_CODEX_MAX_DELAY_SEC = 180;
+const UUID_RE = /^[0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12}$/i;
+const CODEX_ROLLOUT_BASENAME_RE = /^rollout-(\d{4}-\d{2}-\d{2}T\d{2}-\d{2}-\d{2})-([0-9a-f]{8}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{4}-[0-9a-f]{12})\.jsonl(?:\.bak)?$/i;
 
 function getResumeSpec(agentType, resumeId) {
   return getAgentResumeSpec(agentType || 'claude', resumeId);
@@ -27,12 +29,63 @@ function extractResumeTarget(agentType, args) {
   return idx >= 0 && list[idx + 1] ? { index: idx, valueIndex: idx + 1, sessionId: list[idx + 1] } : null;
 }
 
-function findCodexSessionFiles(threadId, sessionsRoot) {
-  if (!threadId) return [];
-  const root = sessionsRoot || path.join(process.env.HOME, '.codex', 'sessions');
-  if (!fs.existsSync(root)) return [];
+function codexRolloutFileInfo(filePath) {
+  if (!filePath) return null;
+  const match = path.basename(filePath).match(CODEX_ROLLOUT_BASENAME_RE);
+  if (!match) return null;
+  return {
+    rolloutPrefix: match[1],
+    threadId: match[2].toLowerCase(),
+  };
+}
+
+function codexRolloutIdFromPath(filePath) {
+  return codexRolloutFileInfo(filePath)?.threadId || '';
+}
+
+function codexSessionSearchRoots(sessionsRoot, homeDir = process.env.HOME) {
+  if (sessionsRoot) return fs.existsSync(sessionsRoot) ? [sessionsRoot] : [];
+  return [
+    path.join(homeDir, '.codex', 'sessions'),
+    path.join(homeDir, '.codex', 'archived_sessions'),
+  ].filter((root) => fs.existsSync(root));
+}
+
+function sortCodexRolloutFiles(files) {
+  return [...new Set(files)]
+    .map((filePath) => ({ filePath, info: codexRolloutFileInfo(filePath) }))
+    .filter((entry) => entry.info)
+    .sort((a, b) => {
+      const byPrefix = b.info.rolloutPrefix.localeCompare(a.info.rolloutPrefix);
+      return byPrefix || b.filePath.localeCompare(a.filePath);
+    })
+    .map((entry) => entry.filePath);
+}
+
+function findCodexStateRolloutPath(threadId, homeDir = process.env.HOME) {
+  if (!UUID_RE.test(String(threadId || ''))) return '';
+  let db = null;
+  try {
+    db = openCodexStateDb(homeDir);
+    if (!db) return '';
+    const row = db.prepare('SELECT rollout_path FROM threads WHERE id = ?').get(threadId);
+    const rolloutPath = row?.rollout_path || '';
+    if (!rolloutPath || !fs.existsSync(rolloutPath)) return '';
+    return codexRolloutIdFromPath(rolloutPath) === threadId.toLowerCase() ? rolloutPath : '';
+  } catch {
+    return '';
+  } finally {
+    try { if (db) db.close(); } catch {}
+  }
+}
+
+function findCodexSessionFiles(threadId, sessionsRoot, homeDir = process.env.HOME) {
+  const wanted = String(threadId || '').trim().toLowerCase();
+  if (!UUID_RE.test(wanted)) return [];
   const matches = [];
-  const stack = [root];
+  const indexedPath = sessionsRoot ? '' : findCodexStateRolloutPath(wanted, homeDir);
+  if (indexedPath) matches.push(indexedPath);
+  const stack = codexSessionSearchRoots(sessionsRoot, homeDir);
   while (stack.length > 0) {
     const dir = stack.pop();
     let entries = [];
@@ -43,12 +96,12 @@ function findCodexSessionFiles(threadId, sessionsRoot) {
         stack.push(fullPath);
         continue;
       }
-      if (entry.isFile() && entry.name.endsWith('.jsonl') && entry.name.includes(threadId)) {
+      if (entry.isFile() && codexRolloutIdFromPath(fullPath) === wanted) {
         matches.push(fullPath);
       }
     }
   }
-  return matches.sort();
+  return sortCodexRolloutFiles(matches);
 }
 
 function parseSessionStartMs(value) {
@@ -66,6 +119,46 @@ function parseSessionStartMs(value) {
   return Number.isFinite(ms) ? ms : null;
 }
 
+function cleanCodexCwdPath(value) {
+  const raw = String(value || '').trim();
+  if (!raw) return '';
+  const normalized = path.normalize(path.isAbsolute(raw) ? raw : path.resolve(raw));
+  return normalized.replace(/\/+$/, '') || path.parse(normalized).root;
+}
+
+function realpathCodexCwdPath(value) {
+  const cleaned = cleanCodexCwdPath(value);
+  if (!cleaned) return '';
+  try {
+    const realpath = fs.realpathSync.native ? fs.realpathSync.native(cleaned) : fs.realpathSync(cleaned);
+    return cleanCodexCwdPath(realpath);
+  } catch {
+    // The cwd may point at an already-removed worktree; fall back to lexical aliases.
+    return cleaned;
+  }
+}
+
+function codexCwdVariants(value) {
+  const variants = new Set();
+  const add = (candidate) => {
+    const cleaned = cleanCodexCwdPath(candidate);
+    if (!cleaned) return;
+    variants.add(cleaned);
+    if (cleaned === '/tmp') variants.add('/private/tmp');
+    else if (cleaned.startsWith('/tmp/')) variants.add(`/private${cleaned}`);
+    else if (cleaned === '/private/tmp') variants.add('/tmp');
+    else if (cleaned.startsWith('/private/tmp/')) variants.add(`/tmp/${cleaned.slice('/private/tmp/'.length)}`);
+  };
+  add(value);
+  add(realpathCodexCwdPath(value));
+  return [...variants];
+}
+
+function codexCwdMatches(a, b) {
+  const bVariants = new Set(codexCwdVariants(b));
+  return codexCwdVariants(a).some((variant) => bVariants.has(variant));
+}
+
 function openCodexStateDb(homeDir = process.env.HOME) {
   const Database = require('better-sqlite3');
   const dbPath = path.join(homeDir, '.codex', 'state_5.sqlite');
@@ -80,7 +173,7 @@ function getCodexThreadById(threadId, homeDir = process.env.HOME) {
     db = openCodexStateDb(homeDir);
     if (!db) return null;
     return db.prepare(
-      'SELECT id, title, first_user_message, model, cwd, git_branch, created_at, updated_at FROM threads WHERE id = ?'
+      'SELECT * FROM threads WHERE id = ?'
     ).get(threadId) || null;
   } catch {
     return null;
@@ -98,7 +191,7 @@ function getCodexThreadResumeCwd(threadId, {
   const thread = getCodexThreadById(threadId, homeDir);
   if (thread?.cwd) return thread.cwd;
 
-  const files = findCodexSessionFiles(threadId, path.join(homeDir, '.codex', 'sessions'));
+  const files = findCodexSessionFiles(threadId, null, homeDir);
   for (const filePath of files) {
     const row = _readCodexRolloutMetadata(filePath);
     if (row?.cwd) return row.cwd;
@@ -124,8 +217,7 @@ function readFilePrefix(filePath, maxBytes = 64 * 1024) {
 function codexThreadPreciseCreatedMs(row, homeDir = process.env.HOME) {
   const fallback = Number.isFinite(row?.created_at) ? row.created_at * 1000 : null;
   if (!row?.id) return fallback;
-  const sessionsRoot = path.join(homeDir, '.codex', 'sessions');
-  const files = findCodexSessionFiles(row.id, sessionsRoot);
+  const files = findCodexSessionFiles(row.id, null, homeDir);
   for (const filePath of files) {
     const prefix = readFilePrefix(filePath);
     if (!prefix) continue;
@@ -142,7 +234,8 @@ function codexThreadPreciseCreatedMs(row, homeDir = process.env.HOME) {
 }
 
 function _readCodexRolloutMetadata(filePath) {
-  const prefix = readFilePrefix(filePath, 256 * 1024);
+  // 512KB covers the large turn_context blob that Codex injects before the user_message event
+  const prefix = readFilePrefix(filePath, 512 * 1024);
   if (!prefix) return null;
   let meta = null;
   let firstUser = '';
@@ -228,7 +321,7 @@ function findCodexThreadFromRolloutsForSession({
       }
       if (!entry.isFile() || !entry.name.endsWith('.jsonl')) continue;
       const row = _readCodexRolloutMetadata(fullPath);
-      if (!row || row.cwd !== cwd) continue;
+      if (!row || !codexCwdMatches(row.cwd, cwd)) continue;
       const ms = row._preciseCreatedMs;
       if (ms < minMs || ms > maxMs) continue;
       matches.push({ row, distance: Math.abs(ms - startMs) });
@@ -257,6 +350,7 @@ function findCodexThreadForSession({
   const startMs = parseSessionStartMs(createdAtMs);
   if (!Number.isFinite(startMs)) return null;
   const startSec = Math.floor(startMs / 1000);
+  const cwdVariants = codexCwdVariants(cwd);
   const fallbackFromRollouts = () => findCodexThreadFromRolloutsForSession({
     cwd,
     createdAtMs,
@@ -265,16 +359,18 @@ function findCodexThreadForSession({
     maxDelaySec,
     allowAmbiguous,
   });
+  if (cwdVariants.length === 0) return null;
   let db = null;
   try {
     db = openCodexStateDb(homeDir);
     if (!db) return fallbackFromRollouts();
+    const cwdPlaceholders = cwdVariants.map(() => '?').join(', ');
     const rows = db.prepare(
       `SELECT rowid, id, title, first_user_message, model, cwd, git_branch, created_at, updated_at
          FROM threads
-        WHERE cwd = ? AND created_at >= ? AND created_at <= ?
+        WHERE cwd IN (${cwdPlaceholders}) AND created_at >= ? AND created_at <= ?
         ORDER BY ABS(created_at - ?) ASC, created_at ASC`
-    ).all(cwd, startSec - lookbackSec, startSec + maxDelaySec, startSec);
+    ).all(...cwdVariants, startSec - lookbackSec, startSec + maxDelaySec, startSec);
     if (rows.length === 0) return fallbackFromRollouts();
     const best = rows[0];
     const bestDistance = Math.abs((best.created_at || 0) - startSec);
@@ -482,6 +578,170 @@ function parseCodexJsonlFileIntoMessages(filePath, messages, options = {}) {
   };
 }
 
+function normalizeCodexSearchValue(value) {
+  return String(value || '')
+    .trim()
+    .toLowerCase()
+    .replace(/(^|[\s([{])[$/]+(?=[a-z0-9_-])/g, '$1')
+    .replace(/\s+/g, ' ');
+}
+
+function codexSearchSnippet(text, terms) {
+  const raw = String(text || '').replace(/\s+/g, ' ').trim();
+  const normalized = normalizeCodexSearchValue(raw);
+  let idx = -1;
+  for (const term of terms || []) {
+    idx = normalized.indexOf(term);
+    if (idx >= 0) break;
+  }
+  if (idx < 0) return raw.slice(0, 180);
+  const start = Math.max(0, idx - 60);
+  const end = Math.min(raw.length, idx + 140);
+  return (start > 0 ? '...' : '') + raw.slice(start, end).trim() + (end < raw.length ? '...' : '');
+}
+
+function codexSearchMatchForMessage(msg, terms, order) {
+  const text = msg?.text || '';
+  const normalized = normalizeCodexSearchValue(text);
+  if (!terms.every(term => normalized.includes(term))) return null;
+
+  const rawLower = String(text).toLowerCase();
+  let score = msg.role === 'user' ? 20 : 0;
+  for (const term of terms) {
+    if (rawLower.includes(`$${term}`) || rawLower.includes(`/${term}`)) score += 50;
+    const wordRe = new RegExp(`(^|[^a-z0-9_-])${term.replace(/[.*+?^${}()|[\]\\]/g, '\\$&')}([^a-z0-9_-]|$)`, 'i');
+    if (wordRe.test(text)) score += 10;
+  }
+
+  return {
+    role: msg.role,
+    timestamp: msg.timestamp || '',
+    snippet: codexSearchSnippet(text, terms),
+    _rankScore: score,
+    _order: order,
+  };
+}
+
+function searchCodexRolloutFileMessages(filePath, terms, row) {
+  const state = { seenUsers: new Set(), sessionMeta: null };
+  const matches = [];
+  const chunkSize = 1024 * 1024;
+  const buf = Buffer.alloc(chunkSize);
+  const decoder = new StringDecoder('utf8');
+  let partial = '';
+  let fd = null;
+  let order = 0;
+
+  try {
+    fd = fs.openSync(filePath, 'r');
+    while (true) {
+      const bytesRead = fs.readSync(fd, buf, 0, buf.length, null);
+      if (bytesRead <= 0) break;
+      const text = partial + decoder.write(buf.subarray(0, bytesRead));
+      let start = 0;
+      while (true) {
+        const end = text.indexOf('\n', start);
+        if (end === -1) break;
+        const line = text.slice(start, end);
+        if (line) {
+          let entry;
+          try { entry = JSON.parse(line); } catch { entry = null; }
+          if (entry) {
+            if (!state.sessionMeta) {
+              const meta = codexSessionMetaFromEntry(entry);
+              if (meta?.id) state.sessionMeta = meta;
+            }
+            const msg = codexMessageFromEntry(entry);
+            if (msg) {
+              if (msg.role === 'user') {
+                const key = codexUserKey(msg.text);
+                if (!key || state.seenUsers.has(key)) {
+                  start = end + 1;
+                  continue;
+                }
+                state.seenUsers.add(key);
+              }
+              const match = codexSearchMatchForMessage(msg, terms, order++);
+              if (match) matches.push(match);
+            }
+          }
+        }
+        start = end + 1;
+      }
+      partial = text.slice(start);
+    }
+    const tail = decoder.end();
+    if (tail) partial += tail;
+    if (partial && partial.trim()) {
+      let entry;
+      try { entry = JSON.parse(partial); } catch { entry = null; }
+      if (entry) {
+        if (!state.sessionMeta) {
+          const meta = codexSessionMetaFromEntry(entry);
+          if (meta?.id) state.sessionMeta = meta;
+        }
+        const msg = codexMessageFromEntry(entry);
+        if (msg) {
+          let shouldConsider = true;
+          if (msg.role === 'user') {
+            const key = codexUserKey(msg.text);
+            if (!key || state.seenUsers.has(key)) {
+              shouldConsider = false;
+            } else {
+              state.seenUsers.add(key);
+            }
+          }
+          const match = shouldConsider ? codexSearchMatchForMessage(msg, terms, order++) : null;
+          if (match) matches.push(match);
+        }
+      }
+    }
+  } finally {
+    try { if (fd != null) fs.closeSync(fd); } catch {}
+  }
+
+  if (matches.length === 0) return null;
+  const meta = state.sessionMeta || {};
+  const id = row?.id || meta.id || codexRolloutIdFromPath(filePath);
+  if (!id) return null;
+  let stat = null;
+  try { stat = fs.statSync(filePath); } catch {}
+  const updatedAt = stat ? Math.floor(stat.mtimeMs / 1000) : (row?.updated_at || 0);
+  return {
+    id,
+    title: row?.title || row?.first_user_message || '',
+    first_user_message: row?.first_user_message || '',
+    model: row?.model || meta.model || '',
+    cwd: row?.cwd || meta.cwd || '',
+    git_branch: row?.git_branch || meta.git_branch || '',
+    created_at: row?.created_at || Math.floor(parseSessionStartMs(meta.timestamp) / 1000) || 0,
+    updated_at: updatedAt,
+    _jsonlPath: filePath,
+    _fileSize: stat?.size || 0,
+    _match: matches.sort((a, b) => (b._rankScore || 0) - (a._rankScore || 0) || (b._order || 0) - (a._order || 0))[0],
+    _matchCount: matches.length,
+  };
+}
+
+function searchCodexRolloutMessages(query, {
+  homeDir = process.env.HOME,
+  maxFiles = 100,
+  limit = 50,
+} = {}) {
+  const terms = normalizeCodexSearchValue(query).split(/\s+/).filter(t => t.length >= 2);
+  if (terms.length === 0) return [];
+  const rows = listCodexSessionsFromRollouts(homeDir, maxFiles);
+  const hits = [];
+  for (const row of rows) {
+    if (hits.length >= limit) break;
+    const filePath = row._jsonlPath;
+    if (!filePath) continue;
+    const hit = searchCodexRolloutFileMessages(filePath, terms, row);
+    if (hit) hits.push(hit);
+  }
+  return hits.sort((a, b) => (b.updated_at || 0) - (a.updated_at || 0)).slice(0, limit);
+}
+
 function commandLooksLikeCodex(value) {
   return /(^|\/)codex(\s|$)/i.test(String(value || ''));
 }
@@ -502,7 +762,7 @@ function findCodexThreadForCtmSession({
   if (explicitId) {
     const direct = getCodexThreadById(explicitId, homeDir);
     if (direct) return direct;
-    const files = findCodexSessionFiles(explicitId, path.join(homeDir, '.codex', 'sessions'));
+    const files = findCodexSessionFiles(explicitId, null, homeDir);
     if (files.length > 0) {
       return {
         id: explicitId,
@@ -535,10 +795,41 @@ function findCodexThreadForCtmSession({
   });
 }
 
+// Scan ~/.codex/sessions/**/*.jsonl and return session metadata rows sorted by mtime DESC.
+// Used as a fallback when state_5.sqlite is unavailable or corrupt.
+function listCodexSessionsFromRollouts(homeDir = process.env.HOME, limit = 50) {
+  const root = path.join(homeDir, '.codex', 'sessions');
+  if (!fs.existsSync(root)) return [];
+  const results = [];
+  const stack = [root];
+  while (stack.length > 0) {
+    const dir = stack.pop();
+    let entries = [];
+    try { entries = fs.readdirSync(dir, { withFileTypes: true }); } catch { continue; }
+    for (const entry of entries) {
+      const fullPath = path.join(dir, entry.name);
+      if (entry.isDirectory()) { stack.push(fullPath); continue; }
+      if (!entry.isFile() || !entry.name.endsWith('.jsonl')) continue;
+      const row = _readCodexRolloutMetadata(fullPath);
+      if (!row) continue;
+      try {
+        const st = fs.statSync(fullPath);
+        row.updated_at = Math.max(row.updated_at || 0, Math.floor(st.mtimeMs / 1000));
+        row._jsonlPath = fullPath;
+      } catch {}
+      results.push(row);
+    }
+  }
+  results.sort((a, b) => (b.updated_at || 0) - (a.updated_at || 0));
+  return results.slice(0, limit);
+}
+
 module.exports = {
   cleanCodexUserText,
   codexInputText,
   codexMessageFromEntry,
+  codexRolloutFileInfo,
+  codexRolloutIdFromPath,
   codexUserKey,
   extractResumeTarget,
   findCodexSessionFiles,
@@ -548,6 +839,8 @@ module.exports = {
   getCodexThreadResumeCwd,
   getCodexThreadById,
   getResumeSpec,
+  listCodexSessionsFromRollouts,
+  searchCodexRolloutMessages,
   parseSessionStartMs,
   parseCodexJsonlIntoMessages,
   parseCodexJsonlFileIntoMessages,