lostvibe 0.0.0-stage → 0.8.0

package/src/hooks.mjs

@@ -0,0 +1,338 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { execFileSync } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { stateDir, saveJson } from './connections.mjs';
+
+const quote = (s) => `'${s.replace(/'/g, "'\\''")}'`;
+// Any hook that runs `lostvibe.mjs hook` is ours, whichever version or folder installed it.
+export const OUR_HOOK = /lostvibe\.mjs'?\s+hook\b/;
+const isOurs = (h) => typeof h?.command === 'string' && OUR_HOOK.test(h.command);
+const EVENTS = ['Stop', 'SessionEnd'];
+const TEMP = /(^|['"\s])\/(private\/)?tmp\//;
+const snake = (e) => e.replace(/([a-z0-9])([A-Z])/g, '$1_$2').toLowerCase();
+
+function load(file, fallback = {}) {
+  if (!fs.existsSync(file)) return fallback;
+  const data = JSON.parse(fs.readFileSync(file, 'utf8'));
+  if (!data || typeof data !== 'object' || Array.isArray(data))
+    throw new Error(`설정 형식을 읽지 못했어요: ${path.basename(file)}`);
+  return data;
+}
+function readSafe(file) {
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+function clients(o = {}) {
+  const claude = process.env.CLAUDE_CONFIG_DIR || path.join(os.homedir(), '.claude');
+  const codex = process.env.CODEX_HOME || path.join(os.homedir(), '.codex');
+  const want = o.client?.toLowerCase();
+  return [
+    { client: 'Claude Code', from: 'claude', dir: claude, file: path.join(claude, 'settings.json') },
+    { client: 'Codex', from: 'codex', dir: codex, file: path.join(codex, 'hooks.json') },
+  ].filter((c) => !want || c.from === want || c.client.toLowerCase().startsWith(want));
+}
+
+// Removes our hooks from the given events (or every event) and leaves all other hooks as they are.
+function stripOurs(config, events) {
+  if (!config.hooks || typeof config.hooks !== 'object' || Array.isArray(config.hooks)) {
+    if (events && config.hooks !== undefined) throw new Error('기존 훅 형식을 읽지 못했어요. 변경하지 않았어요.');
+    return false;
+  }
+  let changed = false;
+  for (const event of events || Object.keys(config.hooks)) {
+    const groups = config.hooks[event];
+    if (groups === undefined) continue;
+    if (!Array.isArray(groups)) {
+      if (events) throw new Error('기존 훅 형식을 읽지 못했어요. 변경하지 않았어요.');
+      continue;
+    }
+    const next = [];
+    for (const g of groups) {
+      if (!Array.isArray(g?.hooks) || !g.hooks.some(isOurs)) {
+        next.push(g);
+        continue;
+      }
+      changed = true;
+      const rest = g.hooks.filter((h) => !isOurs(h));
+      if (rest.length) next.push({ ...g, hooks: rest });
+    }
+    if (next.length) config.hooks[event] = next;
+    else if (groups.length) delete config.hooks[event];
+  }
+  if (changed && !Object.keys(config.hooks).length) delete config.hooks;
+  return changed;
+}
+function findOurs(config, event) {
+  const groups = config.hooks?.[event];
+  if (!Array.isArray(groups)) return null;
+  for (let gi = 0; gi < groups.length; gi++) {
+    const hooks = groups[gi]?.hooks;
+    if (!Array.isArray(hooks)) continue;
+    for (let hi = 0; hi < hooks.length; hi++) if (isOurs(hooks[hi])) return { gi, hi, command: hooks[hi].command };
+  }
+  return null;
+}
+function ourCommands(config) {
+  const out = [];
+  for (const groups of Object.values(config.hooks || {}))
+    if (Array.isArray(groups))
+      for (const g of groups) for (const h of Array.isArray(g?.hooks) ? g.hooks : []) if (isOurs(h)) out.push(h.command);
+  return out;
+}
+
+// A node path that survives node upgrades (e.g. /opt/homebrew/bin/node instead of the Cellar path).
+function stableNode() {
+  let real;
+  try {
+    real = fs.realpathSync(process.execPath);
+  } catch {
+    return process.execPath;
+  }
+  for (const d of (process.env.PATH || '').split(path.delimiter)) {
+    if (!d || !path.isAbsolute(d) || TEMP.test(d) || d.includes('/var/folders/') || d.includes('node_modules')) continue;
+    const c = path.join(d, process.platform === 'win32' ? 'node.exe' : 'node');
+    try {
+      if (fs.realpathSync(c) === real) return c;
+    } catch {
+      /* not here */
+    }
+  }
+  return process.execPath;
+}
+// The hook always runs runtime/current, so its command (and Codex's trust hash) stays the same across versions.
+function installRuntime(dir) {
+  const packageRoot = path.dirname(path.dirname(fileURLToPath(import.meta.url)));
+  const base = path.join(dir, 'runtime');
+  const current = path.join(base, 'current');
+  if (path.resolve(packageRoot) === path.resolve(current)) return current;
+  const next = path.join(base, `.next-${process.pid}`);
+  fs.rmSync(next, { recursive: true, force: true });
+  fs.mkdirSync(next, { recursive: true });
+  for (const part of ['src', 'bin']) fs.cpSync(path.join(packageRoot, part), path.join(next, part), { recursive: true });
+  fs.copyFileSync(path.join(packageRoot, 'package.json'), path.join(next, 'package.json'));
+  fs.rmSync(current, { recursive: true, force: true });
+  fs.renameSync(next, current);
+  return current;
+}
+export function hookCommand(o, from) {
+  const dir = stateDir(o);
+  return `${quote(stableNode())} ${quote(path.join(dir, 'runtime', 'current', 'bin', 'lostvibe.mjs'))} hook --from ${from} --out ${quote(dir)}`;
+}
+
+// Codex keeps approvals in config.toml as [hooks.state."<hooks.json>:<event>:<group>:<hook>"] trusted_hash = "...".
+// Read only: approval is the user's step inside Codex.
+export function codexTrust(codexDir) {
+  let text;
+  try {
+    text = fs.readFileSync(path.join(codexDir, 'config.toml'), 'utf8');
+  } catch {
+    return new Map();
+  }
+  const unq = (s) => s.replace(/\\(.)/g, '$1');
+  const map = new Map();
+  let key = null;
+  let section = null;
+  for (const line of text.split(/\r?\n/)) {
+    const h = line.match(/^\s*\[\s*hooks\s*\.\s*state\s*\.\s*(?:"((?:[^"\\]|\\.)*)"|'([^']*)')\s*\]/);
+    if (h) {
+      key = h[1] !== undefined ? unq(h[1]) : h[2];
+      section = null;
+      continue;
+    }
+    const s = line.match(/^\s*\[\s*([^\]]+?)\s*\]/);
+    if (s) {
+      key = null;
+      section = s[1].replace(/\s/g, '');
+      continue;
+    }
+    if (key) {
+      const t = line.match(/^\s*trusted_hash\s*=\s*["']([^"']*)["']/);
+      if (t) map.set(key, t[1]);
+    } else if (section === 'hooks.state') {
+      const t = line.match(/^\s*"((?:[^"\\]|\\.)*)"\s*=\s*\{[^}]*trusted_hash\s*=\s*"([^"]*)"/);
+      if (t) map.set(unq(t[1]), t[2]);
+    }
+  }
+  return map;
+}
+const trustKey = (file, event, pos) => `${file}:${snake(event)}:${pos.gi}:${pos.hi}`;
+
+export function codexCli() {
+  try {
+    const found = execFileSync('/bin/sh', ['-c', 'command -v codex'], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+      timeout: 5000,
+    }).trim();
+    if (found) return found;
+  } catch {
+    /* not on PATH */
+  }
+  for (const p of [
+    '/Applications/ChatGPT.app/Contents/Resources/codex-cli/bin/codex',
+    '/Applications/Codex.app/Contents/Resources/codex',
+  ])
+    if (fs.existsSync(p)) return p;
+  return null;
+}
+export function codexHint(cli = codexCli()) {
+  return cli
+    ? `Codex 승인: 터미널에서 '${cli}' 실행 → /hooks → Lost Vibe 항목 2개만 Trust`
+    : 'Codex 승인: Codex CLI를 찾지 못했어요. Codex를 열고 /hooks → Lost Vibe 항목 2개만 Trust';
+}
+
+export function installHooks(o = {}) {
+  const dir = stateDir(o);
+  const chosen = clients(o).filter((c) => fs.existsSync(c.dir));
+  if (!chosen.length) throw new Error('연결할 Claude Code 또는 Codex 설정 폴더를 찾지 못했어요.');
+  // Validate all files before changing any.
+  const plans = chosen.map((c) => {
+    const config = load(c.file);
+    return { ...c, before: structuredClone(config), config, command: hookCommand(o, c.from) };
+  });
+  for (const p of plans) {
+    stripOurs(p.config, EVENTS);
+    p.config.hooks ||= {};
+    for (const event of EVENTS)
+      p.config.hooks[event] = [...(p.config.hooks[event] || []), { hooks: [{ type: 'command', command: p.command, timeout: 10 }] }];
+  }
+  installRuntime(dir);
+  const entries = [];
+  for (const p of plans) {
+    fs.mkdirSync(path.dirname(p.file), { recursive: true });
+    if (fs.existsSync(p.file) && !fs.existsSync(p.file + '.lostvibe-backup'))
+      fs.copyFileSync(p.file, p.file + '.lostvibe-backup');
+    saveJson(p.file, p.config);
+    const trust = p.from === 'codex' ? codexTrust(p.dir) : null;
+    for (const event of EVENTS) {
+      const entry = { client: p.client, from: p.from, file: p.file, event, command: p.command };
+      if (trust) {
+        // Remembers the approval that existed at this position so a stale one is not read as approval later.
+        const pos = findOurs(p.config, event);
+        entry.trustKey = trustKey(p.file, event, pos);
+        entry.preHash = trust.get(entry.trustKey) || null;
+        entry.sameCommand = p.before.hooks?.[event]?.[pos.gi]?.hooks?.[pos.hi]?.command === p.command;
+      }
+      entries.push(entry);
+    }
+  }
+  const registryFile = path.join(dir, 'hooks.json');
+  let registry;
+  try {
+    registry = load(registryFile, { entries: [] });
+  } catch {
+    registry = { entries: [] };
+  }
+  registry.entries = [
+    ...(registry.entries || []).filter((e) => !plans.some((p) => p.file === e.file)),
+    ...entries,
+  ];
+  saveJson(registryFile, registry);
+  return [...new Set(chosen.map((c) => c.client))];
+}
+
+export function removeHooks(o = {}) {
+  const file = path.join(stateDir(o), 'hooks.json');
+  let registry;
+  try {
+    registry = load(file, { entries: [] });
+  } catch {
+    registry = { entries: [] };
+  }
+  const chosen = clients(o);
+  const files = new Set(chosen.map((c) => c.file));
+  const matches = (e) => !o.client || chosen.some((c) => c.client === e.client);
+  for (const e of registry.entries || []) if (matches(e)) files.add(e.file);
+  for (const f of files) {
+    if (!fs.existsSync(f)) continue;
+    const config = load(f);
+    if (stripOurs(config)) saveJson(f, config);
+  }
+  registry.entries = (registry.entries || []).filter((e) => !matches(e));
+  saveJson(file, registry);
+}
+
+const when = (iso) => {
+  const d = new Date(iso);
+  if (Number.isNaN(d.getTime())) return '-';
+  const z = (n) => String(n).padStart(2, '0');
+  return `${d.getFullYear()}-${z(d.getMonth() + 1)}-${z(d.getDate())} ${z(d.getHours())}:${z(d.getMinutes())}`;
+};
+
+// Per client: 미설치 / 설치됨·승인 전 / 승인됨·실행 기록 없음 / 실행됨.
+export function hookStatus(o = {}) {
+  const dir = stateDir(o);
+  const registry = readSafe(path.join(dir, 'hooks.json')) || { entries: [] };
+  const last = readSafe(path.join(dir, 'hook-last.json')) || {};
+  const sync = readSafe(path.join(dir, 'last-sync.json'));
+  const lastSync = sync ? (sync.ok ? sync.at : sync.lastOkAt) || null : null;
+  const out = [];
+  for (const c of clients(o)) {
+    if (!fs.existsSync(c.dir)) continue;
+    let config = {};
+    try {
+      config = load(c.file);
+    } catch {
+      /* unreadable config reads as not installed */
+    }
+    const positions = EVENTS.map((event) => ({ event, pos: findOurs(config, event) }));
+    const installed = positions.every((p) => p.pos);
+    let approved = installed;
+    if (installed && c.from === 'codex') {
+      const trust = codexTrust(c.dir);
+      approved = positions.every(({ event, pos }) => {
+        const key = trustKey(c.file, event, pos);
+        const hash = trust.get(key);
+        if (!hash) return false;
+        const snap = (registry.entries || []).find((e) => e.trustKey === key && e.command === pos.command);
+        return !(snap && snap.preHash && snap.preHash === hash && !snap.sameCommand);
+      });
+    }
+    const lastRun = last.clients?.[c.from]?.at || (last.from === c.from ? last.at : null) || null;
+    const state = !installed
+      ? '미설치'
+      : !approved
+        ? '설치됨·승인 전'
+        : !lastRun
+          ? '승인됨·실행 기록 없음'
+          : '실행됨';
+    out.push({
+      client: c.client,
+      from: c.from,
+      state,
+      installed,
+      approved,
+      lastRun,
+      lastSync,
+      temp: ourCommands(config).some((cmd) => TEMP.test(cmd)),
+    });
+  }
+  return out;
+}
+export function statusLines(entries, cli) {
+  if (!entries.length) return ['Claude Code와 Codex 설정 폴더를 찾지 못했어요.'];
+  const lines = entries.map((e) =>
+    e.state === '실행됨'
+      ? `${e.client}: 실행됨 (마지막 실행 ${when(e.lastRun)}, 마지막 사이트 반영 ${e.lastSync ? when(e.lastSync) : '없음'})`
+      : `${e.client}: ${e.state}`,
+  );
+  if (entries.some((e) => e.from === 'codex' && e.installed && !e.approved)) lines.push(codexHint(cli));
+  if (entries.some((e) => e.temp))
+    lines.push('주의: 임시 폴더(/tmp)를 가리키는 Lost Vibe 훅이 있어요. hooks install을 다시 실행하면 정리돼요.');
+  return lines;
+}
+// What install did and what is left for the user.
+export function installLines(o, installed, cli) {
+  const lines = [`자동 갱신 훅을 설치했어요: ${installed.join(', ')} (Stop, SessionEnd).`];
+  const entries = hookStatus(o).filter((e) => installed.includes(e.client));
+  const pending = entries.some((e) => e.from === 'codex' && !e.approved);
+  if (installed.includes('Claude Code')) lines.push('Claude Code는 승인이 필요 없어요. 다음 세션부터 자동으로 갱신돼요.');
+  if (pending) lines.push(`남은 일: ${codexHint(cli)}`);
+  else if (installed.includes('Codex')) lines.push('Codex는 이미 승인돼 있어요.');
+  return lines;
+}