create-walle 0.9.13 → 0.9.14

package/template/claude-task-manager/git-utils.js

@@ -457,6 +457,106 @@ async function _gitSafe(cwd, args, timeoutMs = 5000) {
   });
 }
 
+function _parseGitHubRemoteUrl(remoteUrl) {
+  const raw = String(remoteUrl || '').trim();
+  if (!raw) return null;
+
+  let host = 'github.com';
+  let owner = '';
+  let repo = '';
+  let match = raw.match(/^git@([^:]+):([^/]+)\/(.+)$/);
+  if (match) {
+    host = match[1];
+    owner = match[2];
+    repo = match[3];
+  } else {
+    match = raw.match(/^ssh:\/\/(?:[^@/]+@)?([^/]+)\/([^/]+)\/(.+)$/);
+    if (match) {
+      host = match[1];
+      owner = match[2];
+      repo = match[3];
+    } else {
+      match = raw.match(/^https?:\/\/([^/]+)\/([^/]+)\/(.+)$/);
+      if (!match) return null;
+      host = match[1];
+      owner = match[2];
+      repo = match[3];
+    }
+  }
+
+  repo = repo.replace(/(?:\.git)?\/?$/, '');
+  if (!host || !owner || !repo || repo.includes('/')) return null;
+  const nameWithOwner = `${owner}/${repo}`;
+  return {
+    host,
+    owner,
+    repo,
+    nameWithOwner,
+    ghRepo: host === 'github.com' ? nameWithOwner : `${host}/${nameWithOwner}`,
+  };
+}
+
+async function _githubRemoteSpec(cwd, remoteName) {
+  if (!remoteName) return null;
+  const urls = [
+    await _gitSafe(cwd, ['remote', 'get-url', remoteName]),
+    await _gitSafe(cwd, ['remote', 'get-url', '--push', remoteName]),
+  ].filter(Boolean);
+  for (const url of urls) {
+    const spec = _parseGitHubRemoteUrl(url);
+    if (spec) return { ...spec, remote: remoteName, url };
+  }
+  return null;
+}
+
+async function _selectPrBaseRemote(cwd, base, remoteNames) {
+  const remotes = Array.isArray(remoteNames) ? remoteNames : [];
+  if (remotes.includes('upstream') && await _githubRemoteSpec(cwd, 'upstream')) {
+    return 'upstream';
+  }
+
+  const configured = await _gitSafe(cwd, ['config', '--get', `branch.${base}.remote`]);
+  if (configured && configured !== '.' && remotes.includes(configured)
+      && await _githubRemoteSpec(cwd, configured)) {
+    return configured;
+  }
+
+  if (remotes.includes('origin') && await _githubRemoteSpec(cwd, 'origin')) {
+    return 'origin';
+  }
+
+  for (const remote of remotes) {
+    if (await _githubRemoteSpec(cwd, remote)) return remote;
+  }
+  return null;
+}
+
+async function _buildGhPrCreateArgs(cwd, branchName, opts) {
+  opts = opts || {};
+  const base = opts.base || 'main';
+  const title = opts.title || branchName;
+  const body = opts.body || `Branch \`${branchName}\` opened.`;
+  const remoteOut = await _gitSafe(cwd, ['remote']);
+  const remoteNames = remoteOut ? remoteOut.split('\n').map(s => s.trim()).filter(Boolean) : [];
+  const pushRemote = remoteNames.includes('origin') ? 'origin' : remoteNames[0];
+  const baseRemote = await _selectPrBaseRemote(cwd, base, remoteNames);
+  const baseSpec = await _githubRemoteSpec(cwd, baseRemote);
+  const pushSpec = await _githubRemoteSpec(cwd, pushRemote);
+
+  let head = branchName;
+  if (baseSpec && pushSpec
+      && (baseSpec.host !== pushSpec.host
+        || baseSpec.owner !== pushSpec.owner
+        || baseSpec.repo !== pushSpec.repo)) {
+    head = `${pushSpec.owner}:${branchName}`;
+  }
+
+  const args = ['pr', 'create'];
+  if (baseSpec) args.push('--repo', baseSpec.ghRepo);
+  args.push('--base', base, '--head', head, '--title', title, '--body', body);
+  return { args, baseRemote, pushRemote, baseSpec, pushSpec, head };
+}
+
 function _isGhostPath(p) {
   if (!p) return true;
   if (p.includes('/~/')) return true;          // literal-tilde corruption
@@ -949,11 +1049,18 @@ async function pushAndCreatePR(cwd, branchName, opts) {
     body = log ? `## Summary\n\n${log}\n` : `Branch \`${branchName}\` opened.`;
   }
 
-  // gh pr create — use --json to get the URL back, fall back to scraping stdout.
+  // gh pr create. Do not let gh infer the repository from `origin`: in forked
+  // or stale-remote checkouts that can point it at an inaccessible repo.
+  const prCommand = await _buildGhPrCreateArgs(wt.path, branchName, { base, title, body });
   const ghOut = await new Promise((resolve, reject) => {
-    execFile('gh', ['pr', 'create', '--base', base, '--head', branchName, '--title', title, '--body', body],
+    execFile('gh', prCommand.args,
       { cwd: wt.path, timeout: 60000 }, (err, stdout, stderr) => {
-        if (err) return reject(new Error(`gh pr create failed: ${stderr || err.message}`));
+        if (err) {
+          const target = prCommand.baseSpec
+            ? `${prCommand.baseSpec.ghRepo} from ${prCommand.head}`
+            : `the repository inferred by gh from ${wt.path}`;
+          return reject(new Error(`gh pr create failed for ${target}: ${stderr || err.message}`));
+        }
         resolve((stdout || '').trim());
       });
   });
@@ -971,4 +1078,5 @@ module.exports = {
   // Internal helpers exposed for tests
   _classifyState, _buildSummary, _isGhostPath, _isCanonicalPath, STATE_SORT_RANK,
   _classifyMainRemote, _recommendedAction, _syncAllEligibility, _sameWorktreePath,
+  _parseGitHubRemoteUrl, _githubRemoteSpec, _buildGhPrCreateArgs,
 };

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);
@@ -502,7 +598,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 +631,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 +675,7 @@ module.exports = {
   getCodexThreadResumeCwd,
   getCodexThreadById,
   getResumeSpec,
+  listCodexSessionsFromRollouts,
   parseSessionStartMs,
   parseCodexJsonlIntoMessages,
   parseCodexJsonlFileIntoMessages,