@haposoft/cafekit 0.14.1 → 0.15.0

package/src/codex/hooks/lib/privacy-state.cjs

@@ -0,0 +1,199 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+
+const TTL_MS = 5 * 60 * 1000;
+const APPROVAL_PREFIX = 'APPROVE CAFEKIT PRIVACY ';
+function stateDir(projectRoot) {
+  return path.join(projectRoot, '.codex', 'hooks', '.privacy');
+}
+function hash(value) {
+  return crypto.createHash('sha256').update(String(value)).digest('hex');
+}
+function pathKey(filePath, sessionCwd) {
+  const requested = path.isAbsolute(filePath)
+    ? filePath
+    : path.resolve(sessionCwd, filePath);
+  let target = requested;
+  try {
+    target = fs.realpathSync(requested);
+  } catch {
+    // Missing or virtual paths are still bound to their normalized request path.
+  }
+  return hash(path.normalize(target));
+}
+function requestPaths(filePaths, filePath) {
+  const values = Array.isArray(filePaths) ? filePaths : [filePath];
+  return [...new Set(values.filter((value) => typeof value === 'string' && value.trim()))];
+}
+function requestPathKeys(filePaths, sessionCwd) {
+  return [...new Set(filePaths.map((filePath) => pathKey(filePath, sessionCwd)))].sort();
+}
+function samePathKeys(left, right) {
+  return Array.isArray(left)
+    && left.length === right.length
+    && left.every((value, index) => value === right[index]);
+}
+
+function displayNames(filePaths) {
+  const names = [...new Set(filePaths.map((filePath) => path.basename(filePath)))].sort();
+  return names.length <= 3
+    ? names.join(', ')
+    : `${names.slice(0, 3).join(', ')} (+${names.length - 3} more)`;
+}
+
+function atomicWrite(file, payload) {
+  const dir = path.dirname(file);
+  fs.mkdirSync(dir, { recursive: true, mode: 0o700 });
+  const temp = `${file}.${process.pid}.${crypto.randomBytes(6).toString('hex')}.tmp`;
+  fs.writeFileSync(temp, `${JSON.stringify(payload)}\n`, { encoding: 'utf8', mode: 0o600 });
+  fs.renameSync(temp, file);
+}
+
+function readJson(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function cleanup(projectRoot, now = Date.now()) {
+  const dir = stateDir(projectRoot);
+  if (!fs.existsSync(dir)) return;
+  for (const name of fs.readdirSync(dir)) {
+    if (!/^(pending|token)-[a-f0-9]+\.json$/.test(name)) continue;
+    const file = path.join(dir, name);
+    const record = readJson(file);
+    if (!record || Number(record.expiresAt) <= now) {
+      try {
+        fs.unlinkSync(file);
+      } catch {
+        // Another hook may have consumed it.
+      }
+    }
+  }
+}
+
+function clearState(projectRoot) {
+  const dir = stateDir(projectRoot);
+  try {
+    if (!fs.existsSync(dir)) return;
+    for (const name of fs.readdirSync(dir)) {
+      if (/^(pending|token)-[a-f0-9]+\.json$/.test(name)) {
+        try { fs.unlinkSync(path.join(dir, name)); } catch { /* concurrently consumed */ }
+      }
+    }
+  } catch {
+    // Session boundaries invalidate best-effort state without blocking startup.
+  }
+}
+
+function createPending({
+  projectRoot,
+  sessionCwd,
+  sessionId,
+  filePaths,
+  filePath,
+  toolName
+}) {
+  cleanup(projectRoot);
+  if (!sessionId) throw new Error('A Codex session ID is required');
+  const paths = requestPaths(filePaths, filePath);
+  if (paths.length === 0) throw new Error('At least one sensitive path is required');
+  const requestId = crypto.randomBytes(12).toString('hex');
+  const record = {
+    version: 2,
+    requestId,
+    sessionId: String(sessionId || ''),
+    pathKeys: requestPathKeys(paths, sessionCwd),
+    displayName: displayNames(paths),
+    toolName: String(toolName || ''),
+    expiresAt: Date.now() + TTL_MS
+  };
+  atomicWrite(path.join(stateDir(projectRoot), `pending-${requestId}.json`), record);
+  return record;
+}
+
+function approvePending({ projectRoot, sessionId, requestId }) {
+  cleanup(projectRoot);
+  if (!sessionId) return { ok: false, reason: 'session' };
+  if (!/^[a-f0-9]{24}$/.test(requestId)) return { ok: false, reason: 'invalid' };
+
+  const pendingFile = path.join(stateDir(projectRoot), `pending-${requestId}.json`);
+  const record = readJson(pendingFile);
+  if (!record) return { ok: false, reason: 'missing' };
+  if (record.sessionId !== String(sessionId || '')) return { ok: false, reason: 'session' };
+  if (Number(record.expiresAt) <= Date.now()) return { ok: false, reason: 'expired' };
+
+  try {
+    fs.unlinkSync(pendingFile);
+  } catch {
+    return { ok: false, reason: 'consumed' };
+  }
+
+  atomicWrite(path.join(stateDir(projectRoot), `token-${requestId}.json`), {
+    version: 2,
+    requestId,
+    sessionId: record.sessionId,
+    pathKeys: record.pathKeys,
+    toolName: record.toolName,
+    expiresAt: Math.min(record.expiresAt, Date.now() + TTL_MS)
+  });
+  return { ok: true, displayName: record.displayName };
+}
+
+function consumeToken({
+  projectRoot,
+  sessionCwd,
+  sessionId,
+  filePaths,
+  filePath,
+  toolName
+}) {
+  cleanup(projectRoot);
+  if (!sessionId) return false;
+  const dir = stateDir(projectRoot);
+  if (!fs.existsSync(dir)) return false;
+  const paths = requestPaths(filePaths, filePath);
+  if (paths.length === 0) return false;
+  const expectedPaths = requestPathKeys(paths, sessionCwd);
+
+  for (const name of fs.readdirSync(dir)) {
+    if (!/^token-[a-f0-9]{24}\.json$/.test(name)) continue;
+    const tokenFile = path.join(dir, name);
+    const token = readJson(tokenFile);
+    if (
+      !token ||
+      token.sessionId !== String(sessionId || '') ||
+      !samePathKeys(token.pathKeys, expectedPaths) ||
+      token.toolName !== String(toolName || '') ||
+      Number(token.expiresAt) <= Date.now()
+    ) {
+      continue;
+    }
+
+    const claimed = `${tokenFile}.claimed-${process.pid}-${crypto.randomBytes(4).toString('hex')}`;
+    try {
+      fs.renameSync(tokenFile, claimed);
+      fs.unlinkSync(claimed);
+      return true;
+    } catch {
+      // Only one concurrent tool invocation can rename and consume this token.
+    }
+  }
+  return false;
+}
+
+module.exports = {
+  APPROVAL_PREFIX,
+  TTL_MS,
+  pathKey,
+  createPending,
+  approvePending,
+  consumeToken,
+  cleanup,
+  clearState
+};

package/src/codex/hooks/lib/spec-receipt.cjs

@@ -0,0 +1,78 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+
+const EVIDENCE_NAMES = [
+  'Evidence',
+  'Task Test Plan & Verification Evidence',
+  'Verification & Evidence'
+];
+const PASS_MARKER = /^\s*Verification:\s*PASS\s*$/m;
+const LEGACY_SUCCESS = /^\s*(?:PASS(?:ED)?|✓)(?:\s*:|$)|exit\s+code\s*[:=]?\s*0\b/im;
+const EXPLICIT_FAILURE = /\bFAIL(?:ED|URE|URES|ING)?\b|tests?\s+failed|exit\s+code\s*[:=]?\s*[1-9]\d*|\b0\s+tests?\b/i;
+
+function evidenceBody(text) {
+  const lines = text.split('\n');
+  let start = -1;
+  let level = 0;
+  for (let index = 0; index < lines.length; index += 1) {
+    const match = lines[index].match(/^(#{2,3})\s+(.+?)\s*$/);
+    if (match && EVIDENCE_NAMES.includes(match[2])) {
+      start = index + 1;
+      level = match[1].length;
+      break;
+    }
+  }
+  if (start < 0) return null;
+  let end = lines.length;
+  for (let index = start; index < lines.length; index += 1) {
+    const heading = lines[index].match(/^(#{1,6})\s+/);
+    if (heading && heading[1].length <= level) {
+      end = index;
+      break;
+    }
+  }
+  return lines.slice(start, end).join('\n');
+}
+
+function safeTaskFile(featureDir, taskPath) {
+  const target = path.resolve(featureDir, taskPath);
+  const relative = path.relative(featureDir, target);
+  return !relative.startsWith('..') && !path.isAbsolute(relative)
+    ? target
+    : null;
+}
+
+function checkReceipt(featureDir, taskPath, task) {
+  const failures = [];
+  const file = safeTaskFile(featureDir, taskPath);
+  if (!file || !fs.existsSync(file)) return ['a'];
+  let text = '';
+  try { text = fs.readFileSync(file, 'utf8'); } catch { return ['a']; }
+
+  const status = text.split('\n')
+    .find((line) => /^\s*(?:\*\*)?Status(?:\*\*)?\s*:/i.test(line));
+  if (!status || !/\bdone\b/i.test(status)) failures.push('a');
+
+  const body = evidenceBody(text);
+  if (body === null) {
+    failures.push('b');
+  } else if (
+    /\{\{[^}]+\}\}/.test(body)
+    || EXPLICIT_FAILURE.test(body)
+    || !(PASS_MARKER.test(body) || LEGACY_SUCCESS.test(body))
+  ) {
+    failures.push('c');
+  }
+
+  const completedAt = task?.completed_at;
+  if (
+    typeof completedAt !== 'string'
+    || !/^\d{4}-\d{2}-\d{2}T/.test(completedAt)
+    || Number.isNaN(Date.parse(completedAt))
+  ) failures.push('d');
+  return failures;
+}
+
+module.exports = { checkReceipt };

package/src/codex/hooks/lib/spec-utils.cjs

@@ -0,0 +1,50 @@
+'use strict';
+
+const fs = require('fs');
+const path = require('path');
+const { resolveProjectPath } = require('./hook-context.cjs');
+
+function specsDirectory(projectRoot, runtime) {
+  return resolveProjectPath(
+    projectRoot,
+    runtime.paths?.specs,
+    'specs'
+  );
+}
+
+function findActiveSpec(projectRoot, runtime) {
+  const specsDir = specsDirectory(projectRoot, runtime);
+  if (!fs.existsSync(specsDir)) return null;
+  const entries = fs.readdirSync(specsDir, { withFileTypes: true })
+    .filter((entry) => entry.isDirectory())
+    .sort((left, right) => left.name.localeCompare(right.name));
+
+  for (const entry of entries) {
+    const file = path.join(specsDir, entry.name, 'spec.json');
+    if (!fs.existsSync(file)) continue;
+    try {
+      const spec = JSON.parse(fs.readFileSync(file, 'utf8'));
+      if (spec.status === 'in_progress' || spec.status === 'in-progress') {
+        return { featureName: entry.name, spec, specsDir };
+      }
+    } catch {
+      // Ignore an unrelated malformed spec and continue discovery.
+    }
+  }
+  return null;
+}
+
+function taskStatusMap(spec) {
+  return Object.fromEntries(
+    Object.entries(spec.task_registry || {}).map(([taskPath, task]) => [
+      taskPath,
+      task?.status || 'pending'
+    ])
+  );
+}
+
+module.exports = {
+  findActiveSpec,
+  specsDirectory,
+  taskStatusMap
+};

package/src/codex/hooks/lib/state-store.cjs

@@ -0,0 +1,166 @@
+'use strict';
+
+const crypto = require('crypto');
+const fs = require('fs');
+const path = require('path');
+const { execFileSync } = require('child_process');
+const { atomicWrite } = require('./hook-context.cjs');
+
+const MAX_ARCHIVES = 5;
+const MAX_AGENTS = 3;
+const MAX_FILES = 5;
+const WAIT_BUFFER = new Int32Array(new SharedArrayBuffer(4));
+
+function sessionKey(sessionId) {
+  if (typeof sessionId !== 'string' || !sessionId.trim()) return null;
+  return crypto.createHash('sha256').update(sessionId).digest('hex');
+}
+
+function stateDir(projectRoot, sessionId) {
+  const key = sessionKey(sessionId);
+  return key
+    ? path.join(projectRoot, '.codex', 'session-state', key)
+    : null;
+}
+
+function acquireLock(dir) {
+  const lock = path.join(dir, '.write-lock');
+  fs.mkdirSync(dir, { recursive: true });
+  const deadline = Date.now() + 3000;
+
+  while (Date.now() < deadline) {
+    try {
+      fs.mkdirSync(lock);
+      return () => {
+        try { fs.rmdirSync(lock); } catch { /* already released */ }
+      };
+    } catch (error) {
+      if (error.code !== 'EEXIST') return null;
+      try {
+        if (Date.now() - fs.statSync(lock).mtimeMs > 15000) {
+          fs.rmSync(lock, { recursive: true, force: true });
+          continue;
+        }
+      } catch {
+        continue;
+      }
+      Atomics.wait(WAIT_BUFFER, 0, 0, 20);
+    }
+  }
+  return null;
+}
+
+function withStateLock(projectRoot, sessionId, callback) {
+  const dir = stateDir(projectRoot, sessionId);
+  if (!dir) return false;
+  const release = acquireLock(dir);
+  if (!release) return false;
+  try {
+    callback(dir);
+    return true;
+  } finally {
+    release();
+  }
+}
+
+function readData(dir) {
+  try {
+    return JSON.parse(fs.readFileSync(path.join(dir, 'data.json'), 'utf8'));
+  } catch {
+    return { todos: [], agentResults: [] };
+  }
+}
+
+function runGit(projectRoot, args) {
+  try {
+    return execFileSync('git', args, {
+      cwd: projectRoot,
+      encoding: 'utf8',
+      timeout: 3000,
+      stdio: ['ignore', 'pipe', 'ignore']
+    }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function refreshGit(data, projectRoot) {
+  data.branch = runGit(projectRoot, ['branch', '--show-current'])
+    || runGit(projectRoot, ['rev-parse', '--short', 'HEAD']);
+  const changed = runGit(projectRoot, ['diff', '--name-only', 'HEAD'])
+    || runGit(projectRoot, ['diff', '--name-only']);
+  const untracked = runGit(projectRoot, ['ls-files', '--others', '--exclude-standard']);
+  data.modifiedFiles = [...new Set(
+    `${changed}\n${untracked}`.split('\n').map((item) => item.trim()).filter(Boolean)
+  )].slice(0, MAX_FILES);
+  data.timestamp = new Date().toISOString();
+  return data;
+}
+
+function markdown(data) {
+  const todos = Array.isArray(data.todos) ? data.todos : [];
+  const done = todos.filter((todo) => ['completed', 'done'].includes(todo.status));
+  const pending = todos.filter((todo) => !['completed', 'done'].includes(todo.status));
+  const agents = (data.agentResults || []).slice(-MAX_AGENTS);
+  const files = data.modifiedFiles || [];
+  const lines = [
+    '# Session State',
+    `<!-- Generated: ${data.timestamp || new Date().toISOString()} -->`,
+    `<!-- Branch: ${data.branch || 'unknown'} -->`,
+    '',
+    '## What Worked (Verified)',
+    ...(done.length ? done.map((todo) => `- ${todo.content}`) : ['- (No completed tasks recorded)']),
+    '',
+    "## What's Left",
+    ...(pending.length ? pending.map((todo) => `- [ ] ${todo.content}`) : ['- (No pending tasks recorded)']),
+    ''
+  ];
+
+  if (data.lastToolEvent) {
+    lines.push('## Latest Tracked Tool', `- ${data.lastToolEvent}`, '');
+  }
+  if (data.lastAssistant) {
+    lines.push('## Latest Assistant Message', data.lastAssistant, '');
+  }
+  for (const agent of agents) {
+    lines.push(
+      `## Agent Result: ${agent.type || 'unknown'} (${agent.id || 'unknown'})`,
+      agent.message || '- Completed without a result message.',
+      ''
+    );
+  }
+  lines.push(
+    '## Key Files Modified',
+    ...(files.length ? files.map((file) => `- ${file}`) : ['- (No file changes detected)']),
+    ''
+  );
+  return lines.join('\n');
+}
+
+function writeData(dir, data) {
+  data.agentResults = (data.agentResults || []).slice(-MAX_AGENTS);
+  atomicWrite(path.join(dir, 'data.json'), `${JSON.stringify(data, null, 2)}\n`);
+  atomicWrite(path.join(dir, 'latest.md'), markdown(data));
+}
+
+function archive(dir) {
+  const latest = path.join(dir, 'latest.md');
+  if (!fs.existsSync(latest)) return;
+  const archiveDir = path.join(dir, 'archive');
+  fs.mkdirSync(archiveDir, { recursive: true });
+  const stamp = new Date().toISOString().replace(/\D/g, '').slice(0, 14);
+  fs.copyFileSync(latest, path.join(archiveDir, `${stamp}-${process.pid}.md`));
+  const files = fs.readdirSync(archiveDir).filter((name) => name.endsWith('.md')).sort();
+  while (files.length > MAX_ARCHIVES) {
+    fs.unlinkSync(path.join(archiveDir, files.shift()));
+  }
+}
+
+module.exports = {
+  archive,
+  readData,
+  refreshGit,
+  stateDir,
+  withStateLock,
+  writeData
+};

package/src/codex/hooks/privacy-approval.cjs

@@ -0,0 +1,59 @@
+#!/usr/bin/env node
+'use strict';
+
+const {
+  APPROVAL_PREFIX,
+  approvePending,
+  cleanup
+} = require('./lib/privacy-state.cjs');
+const {
+  getHookContext,
+  readPayload
+} = require('./lib/hook-context.cjs');
+
+function context(message) {
+  process.stdout.write(`${JSON.stringify({
+    hookSpecificOutput: {
+      hookEventName: 'UserPromptSubmit',
+      additionalContext: message
+    }
+  })}\n`);
+}
+
+try {
+  const data = readPayload();
+  if (!data) process.exit(0);
+  const { projectRoot } = getHookContext(data);
+  const prompt = String(data.prompt || '').trim();
+  cleanup(projectRoot);
+
+  if (!prompt.startsWith(APPROVAL_PREFIX)) process.exit(0);
+  if (!data.session_id) {
+    context('CafeKit privacy approval rejected: this hook invocation had no Codex session ID.');
+    process.exit(0);
+  }
+  const requestId = prompt.slice(APPROVAL_PREFIX.length);
+  if (`${APPROVAL_PREFIX}${requestId}` !== prompt || !/^[a-f0-9]{24}$/.test(requestId)) {
+    context('CafeKit privacy approval rejected: the prompt did not exactly match a pending request.');
+    process.exit(0);
+  }
+
+  const result = approvePending({
+    projectRoot,
+    sessionId: data.session_id,
+    requestId
+  });
+  if (!result.ok) {
+    context('CafeKit privacy approval rejected: request missing, expired, consumed, or from another session.');
+    process.exit(0);
+  }
+
+  context(
+    `User approved one retry for the pending sensitive access (${result.displayName}). ` +
+    `The token is session-bound, path-bound, tool-bound, time-limited, and consumed atomically.`
+  );
+  process.exit(0);
+} catch {
+  context('CafeKit privacy approval failed safely; no token was issued.');
+  process.exit(0);
+}