sessionpipe-conformance 0.1.0 → 0.2.0

package/dist/index.js

@@ -1,10 +1,19 @@
-// sessionpipe-conformance 0.1.0 · Apache-2.0 · https://sessionpipe.org
+// sessionpipe-conformance 0.2.0 · Apache-2.0 · https://sessionpipe.org
 
 // src/index.ts
 import { readFileSync as readFileSync6 } from "node:fs";
 
 // ../core/src/adapters/antigravity.ts
-import { existsSync as existsSync2, mkdirSync as mkdirSync2, readdirSync as readdirSync2, readFileSync as readFileSync2, realpathSync, statSync as statSync2, writeFileSync as writeFileSync2 } from "node:fs";
+import {
+  existsSync as existsSync2,
+  mkdirSync as mkdirSync2,
+  readdirSync as readdirSync2,
+  readFileSync as readFileSync2,
+  realpathSync,
+  statSync as statSync2,
+  unlinkSync as unlinkSync2,
+  writeFileSync as writeFileSync2
+} from "node:fs";
 import path3 from "node:path";
 
 // ../core/src/paths.ts
@@ -212,28 +221,67 @@ function readAntigravity(lines, from) {
 }
 
 // ../core/src/adapters/claude-shaped.ts
-import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { existsSync, mkdirSync, readFileSync, unlinkSync, writeFileSync } from "node:fs";
 import path2 from "node:path";
 var OURS = /sessionpipe[^"\n]*[\\/]hook\.js"?\s+[a-z][a-z-]*\s+[A-Za-z]+\s*$/;
 var isOurs = (h) => Array.isArray(h?.hooks) && h.hooks.some((x) => typeof x.command === "string" && OURS.test(x.command));
-function readJson(file) {
+function readJsonFile(file) {
+  let raw;
   try {
-    return JSON.parse(readFileSync(file, "utf8"));
+    raw = readFileSync(file, "utf8");
   } catch {
-    return {};
+    return { ok: true, existed: false, value: {}, raw: "", indent: "  ", eol: "\n", finalNewline: true };
   }
+  let value;
+  try {
+    value = JSON.parse(raw);
+  } catch {
+    const hint = /^\s*\/\/|\/\*/m.test(raw) ? "not plain JSON (it has comments)" : "not plain JSON";
+    return { ok: false, existed: true, reason: hint };
+  }
+  if (!value || typeof value !== "object" || Array.isArray(value))
+    return { ok: false, existed: true, reason: "not a JSON object" };
+  const eol = raw.includes("\r\n") ? "\r\n" : "\n";
+  const m = /^( +|\t+)\S/m.exec(raw);
+  const indent = m?.[1] ?? "  ";
+  return {
+    ok: true,
+    existed: true,
+    value,
+    raw,
+    indent,
+    eol,
+    finalNewline: /\r?\n$/.test(raw)
+  };
+}
+function formatJson(value, f) {
+  const text = JSON.stringify(value, null, f.indent).replace(/\n/g, f.eol);
+  return f.finalNewline ? text + f.eol : text;
 }
 function entryFor(event, harness, cmd, o) {
   const matcher = o.matcherFor(event);
   return {
     ...matcher !== void 0 ? { matcher } : {},
-    hooks: [{ type: "command", command: cmd([harness, event]).command, timeout: o.timeout }]
+    hooks: [{ type: "command", command: cmd([harness, event]).command, timeout: o.timeoutFor?.(event) ?? o.timeout }]
   };
 }
 function installClaudeShaped(file, harness, events, cmd, o) {
-  const settings2 = readJson(file);
+  const f = readJsonFile(file);
+  if (!f.ok) return { file, changed: false, skipped: true, note: `${f.reason}; not touched` };
+  const settings2 = f.value;
   const hooks = settings2.hooks && typeof settings2.hooks === "object" ? settings2.hooks : {};
   let changed = false;
+  const want = new Set(events);
+  for (const ev of Object.keys(hooks)) {
+    if (want.has(ev)) continue;
+    const list = Array.isArray(hooks[ev]) ? hooks[ev] : [];
+    const kept = list.filter((h) => !isOurs(h));
+    if (kept.length !== list.length) {
+      changed = true;
+      if (kept.length) hooks[ev] = kept;
+      else delete hooks[ev];
+    }
+  }
   for (const ev of events) {
     const list = Array.isArray(hooks[ev]) ? hooks[ev] : [];
     const entry2 = entryFor(ev, harness, cmd, o);
@@ -252,19 +300,19 @@ function installClaudeShaped(file, harness, events, cmd, o) {
   if (changed) {
     settings2.hooks = hooks;
     mkdirSync(path2.dirname(file), { recursive: true });
-    writeFileSync(file, `${JSON.stringify(settings2, null, 2)}
-`);
+    writeFileSync(file, formatJson(settings2, f));
   }
-  return { file, changed };
+  return { file, changed, created: !f.existed && changed };
 }
-function uninstallClaudeShaped(file, events) {
+function uninstallClaudeShaped(file, events, opts = {}) {
   if (!existsSync(file)) return { file, changed: false };
-  const raw = readFileSync(file, "utf8");
-  const settings2 = readJson(file);
+  const f = readJsonFile(file);
+  if (!f.ok) return { file, changed: false, skipped: true, note: `${f.reason}; not touched` };
+  const settings2 = f.value;
   const hooks = settings2.hooks;
   if (!hooks || typeof hooks !== "object") return { file, changed: false };
   let changed = false;
-  for (const ev of events) {
+  for (const ev of [...events, ...Object.keys(hooks)]) {
     const list = Array.isArray(hooks[ev]) ? hooks[ev] : [];
     const kept = list.filter((h) => !isOurs(h));
     if (kept.length !== list.length) {
@@ -275,13 +323,17 @@ function uninstallClaudeShaped(file, events) {
   }
   if (!changed) return { file, changed: false };
   if (!Object.keys(hooks).length) delete settings2.hooks;
-  const next = `${JSON.stringify(settings2, null, 2)}
-`;
-  if (next !== raw) writeFileSync(file, next);
+  if (opts.created && !Object.keys(settings2).length) {
+    unlinkSync(file);
+    return { file, changed: true, note: "removed (sessionpipe created it)" };
+  }
+  const next = formatJson(settings2, f);
+  if (next !== f.raw) writeFileSync(file, next);
   return { file, changed: true };
 }
 function installedClaudeShaped(file, harness, events, cmd, o) {
-  const hooks = readJson(file).hooks ?? {};
+  const f = readJsonFile(file);
+  const hooks = f.ok ? f.value.hooks ?? {} : {};
   let present = 0;
   let current = 0;
   for (const ev of events) {
@@ -290,6 +342,9 @@ function installedClaudeShaped(file, harness, events, cmd, o) {
     if (mine.length) present++;
     if (mine.length === 1 && JSON.stringify(mine[0]) === JSON.stringify(entryFor(ev, harness, cmd, o))) current++;
   }
+  for (const ev of Object.keys(hooks))
+    if (!events.includes(ev) && (Array.isArray(hooks[ev]) ? hooks[ev] : []).some((h) => isOurs(h)))
+      return "stale";
   if (!present) return "missing";
   return current === events.length ? "current" : "stale";
 }
@@ -304,10 +359,13 @@ var projectsDir = (env) => path3.join(gemini(env), "config", "projects");
 var dataDirs = (env) => ["antigravity", "antigravity-cli", "antigravity-ide"].map((d) => path3.join(gemini(env), d));
 var ID_RE = /^[A-Za-z0-9_-]{1,128}$/;
 var validTool = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
-function entry(cmd) {
+function entry(cmd, lean) {
   const handler = (e) => ({ type: "command", command: cmd([NAME, e]).command, timeout: 5 });
   const out = { enabled: true };
-  for (const e of AG_EVENTS) out[e] = /Tool/.test(e) ? [{ matcher: "*", hooks: [handler(e)] }] : [handler(e)];
+  for (const e of AG_EVENTS) {
+    if (lean && e === "PreToolUse") continue;
+    out[e] = /Tool/.test(e) ? [{ matcher: "*", hooks: [handler(e)] }] : [handler(e)];
+  }
   return out;
 }
 var antigravity = {
@@ -315,34 +373,49 @@ var antigravity = {
   events: AG_EVENTS,
   detect: (env = process.env) => existsSync2(path3.join(gemini(env), "config")) || dataDirs(env).some((d) => existsSync2(d)),
   configFiles: (env = process.env) => [hooksFile(env)],
-  install(cmd, env = process.env) {
+  install(cmd, env = process.env, opts = {}) {
     const file = hooksFile(env);
-    const hooks = readJson(file);
-    const e = entry(cmd);
+    const f = readJsonFile(file);
+    if (!f.ok) return [{ file, changed: false, skipped: true, note: `${f.reason}; not touched` }];
+    const hooks = f.value;
+    const e = entry(cmd, opts.lean);
     if (JSON.stringify(hooks[HOOK_NAME]) === JSON.stringify(e)) return [{ file, changed: false }];
     hooks[HOOK_NAME] = e;
     mkdirSync2(path3.dirname(file), { recursive: true });
-    writeFileSync2(file, `${JSON.stringify(hooks, null, 2)}
-`);
+    writeFileSync2(file, formatJson(hooks, f));
     return [
-      { file, changed: true, note: "hooks.json is read when a conversation starts; open ones report after a restart" }
+      {
+        file,
+        changed: true,
+        created: !f.existed,
+        note: "hooks.json is read when a conversation starts; open ones report after a restart"
+      }
     ];
   },
-  uninstall(env = process.env) {
+  uninstall(env = process.env, opts = {}) {
     const file = hooksFile(env);
     if (!existsSync2(file)) return [{ file, changed: false }];
-    const hooks = readJson(file);
+    const f = readJsonFile(file);
+    if (!f.ok) return [{ file, changed: false, skipped: true, note: `${f.reason}; not touched` }];
+    const hooks = f.value;
     if (!(HOOK_NAME in hooks)) return [{ file, changed: false }];
     delete hooks[HOOK_NAME];
-    writeFileSync2(file, `${JSON.stringify(hooks, null, 2)}
-`);
+    if (opts.created?.includes(file) && !Object.keys(hooks).length) {
+      unlinkSync2(file);
+      return [{ file, changed: true, note: "removed (sessionpipe created it)" }];
+    }
+    writeFileSync2(file, formatJson(hooks, f));
     return [{ file, changed: true }];
   },
-  installed(cmd, env = process.env) {
+  installed(cmd, env = process.env, opts = {}) {
     const file = hooksFile(env);
-    const have = readJson(file)[HOOK_NAME];
+    const f = readJsonFile(file);
+    const have = f.ok ? f.value[HOOK_NAME] : void 0;
     return [
-      { file, state: !have ? "missing" : JSON.stringify(have) === JSON.stringify(entry(cmd)) ? "current" : "stale" }
+      {
+        file,
+        state: !have ? "missing" : JSON.stringify(have) === JSON.stringify(entry(cmd, opts.lean)) ? "current" : "stale"
+      }
     ];
   },
   fromHook(input) {
@@ -608,9 +681,18 @@ var CLAUDE_EVENTS = [
   "SubagentStop",
   "PreCompact",
   "PostCompact",
-  "SessionEnd"
+  "SessionEnd",
+  "StopFailure"
 ];
-var OPTS = { matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0, timeout: 5 };
+var LEAN_SKIP = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUseFailure"]);
+var eventsFor = (lean) => lean ? CLAUDE_EVENTS.filter((e) => !LEAN_SKIP.has(e)) : [...CLAUDE_EVENTS];
+var OPTS = {
+  matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0,
+  timeout: 5,
+  // The hook waits up to 125 s for a verified control answer, and only when control
+  // is paired on this machine; everywhere else it exits in milliseconds as before.
+  timeoutFor: (e) => e === "PermissionRequest" ? 130 : void 0
+};
 var DESKTOP_ID = /^local_[A-Za-z0-9-]{1,64}$/;
 function claudeDirs(env = process.env, home = HOME) {
   const out = [];
@@ -641,11 +723,13 @@ var claudeCode = {
   events: CLAUDE_EVENTS,
   detect: (env = process.env) => claudeDirs(env).some((d) => existsSync3(d)),
   configFiles: (env = process.env) => claudeDirs(env).map(settingsIn),
-  install: (cmd, env = process.env) => claudeDirs(env).map((d) => installClaudeShaped(settingsIn(d), NAME2, CLAUDE_EVENTS, cmd, OPTS)),
-  uninstall: (env = process.env) => claudeDirs(env).map((d) => uninstallClaudeShaped(settingsIn(d), CLAUDE_EVENTS)),
-  installed: (cmd, env = process.env) => claudeDirs(env).map((d) => ({
+  install: (cmd, env = process.env, opts = {}) => claudeDirs(env).map((d) => installClaudeShaped(settingsIn(d), NAME2, eventsFor(opts.lean), cmd, OPTS)),
+  uninstall: (env = process.env, opts = {}) => claudeDirs(env).map(
+    (d) => uninstallClaudeShaped(settingsIn(d), CLAUDE_EVENTS, { created: opts.created?.includes(settingsIn(d)) })
+  ),
+  installed: (cmd, env = process.env, opts = {}) => claudeDirs(env).map((d) => ({
     file: settingsIn(d),
-    state: installedClaudeShaped(settingsIn(d), NAME2, CLAUDE_EVENTS, cmd, OPTS)
+    state: installedClaudeShaped(settingsIn(d), NAME2, eventsFor(opts.lean), cmd, OPTS)
   })),
   fromHook(input) {
     const event = input.argv[1] ?? "";
@@ -736,6 +820,15 @@ var claudeCode = {
       case "Stop":
         events.push(ev("turn.ended", { turn_id, reason: "stop" }));
         break;
+      case "StopFailure":
+        events.push(
+          ev("turn.ended", {
+            turn_id,
+            reason: "error",
+            error: typeof s.error === "string" ? s.error.slice(0, 200) : void 0
+          })
+        );
+        break;
       case "SubagentStart":
         events.push(
           ev("subagent.started", {
@@ -1247,6 +1340,7 @@ var CODEX_EVENTS = [
   "SessionEnd"
 ];
 var OPTS2 = { matcherFor: (e) => /Tool|Permission/.test(e) ? "" : void 0, timeout: 5 };
+var eventsFor2 = (lean) => lean ? CODEX_EVENTS.filter((e) => e !== "PreToolUse") : [...CODEX_EVENTS];
 var codexHome = (env) => env.CODEX_HOME || path5.join(HOME, ".codex");
 var hooksFile2 = (env) => path5.join(codexHome(env), "hooks.json");
 var configFile = (env) => path5.join(codexHome(env), "config.toml");
@@ -1295,7 +1389,8 @@ function installNotify(cmd, env) {
     return {
       file,
       changed: false,
-      note: `left alone: notify runs ${n.raw.slice(0, 80)} (hooks.json carries the events; the notify fallback is off)`
+      skipped: true,
+      note: `notify belongs to ${(n.argv?.[0] ?? n.raw).replace(/^.*\//, "").slice(0, 40)}; left alone. Codex will report nothing until you approve the hooks: start \`codex\` and accept the hook review`
     };
   }
   write(withNotify(text, line));
@@ -1352,14 +1447,21 @@ var codex = {
   events: CODEX_EVENTS,
   detect: (env = process.env) => existsSync4(codexHome(env)),
   configFiles: (env = process.env) => [hooksFile2(env), configFile(env)],
-  install: (cmd, env = process.env) => [
-    installClaudeShaped(hooksFile2(env), NAME3, CODEX_EVENTS, cmd, OPTS2),
+  install: (cmd, env = process.env, opts = {}) => [
+    installClaudeShaped(hooksFile2(env), NAME3, eventsFor2(opts.lean), cmd, OPTS2),
     installNotify(cmd, env)
   ],
-  uninstall: (env = process.env) => [uninstallClaudeShaped(hooksFile2(env), CODEX_EVENTS), uninstallNotify(env)],
-  installed: (cmd, env = process.env) => {
+  uninstall: (env = process.env, opts = {}) => [
+    uninstallClaudeShaped(hooksFile2(env), CODEX_EVENTS, { created: opts.created?.includes(hooksFile2(env)) }),
+    uninstallNotify(env)
+  ],
+  installed: (cmd, env = process.env, opts = {}) => {
     const out = [
-      { file: hooksFile2(env), state: installedClaudeShaped(hooksFile2(env), NAME3, CODEX_EVENTS, cmd, OPTS2) }
+      {
+        file: hooksFile2(env),
+        state: installedClaudeShaped(hooksFile2(env), NAME3, eventsFor2(opts.lean), cmd, OPTS2),
+        note: "Codex runs non-managed hooks only after the review in `codex` (/hooks); until then nothing is reported unless the notify fallback is ours"
+      }
     ];
     let text = "";
     try {
@@ -1547,6 +1649,7 @@ function codexFacts(file) {
 }
 
 // ../core/src/adapters/gemini-cli.ts
+import { execFileSync as execFileSync3 } from "node:child_process";
 import { existsSync as existsSync5, readFileSync as readFileSync5 } from "node:fs";
 import path6 from "node:path";
 var NAME4 = "gemini-cli";
@@ -1564,17 +1667,61 @@ var OPTS3 = { matcherFor: (e) => /Tool/.test(e) ? ".*" : void 0, timeout: 5e3 };
 var geminiDir = (env) => env.GEMINI_CLI_HOME || path6.join(HOME, ".gemini");
 var settings = (env) => path6.join(geminiDir(env), "settings.json");
 var validTool4 = (n) => typeof n === "string" && /^[A-Za-z0-9_.:-]{1,120}$/.test(n);
+var eventsFor3 = (lean) => lean ? GEMINI_EVENTS.filter((e) => e !== "BeforeTool") : [...GEMINI_EVENTS];
+function geminiHooksActive(settingsFile) {
+  let tools;
+  try {
+    tools = JSON.parse(readFileSync5(settingsFile, "utf8")).tools;
+  } catch {
+  }
+  if (tools?.enableHooks === true) return { active: true };
+  if (tools?.enableHooks === false)
+    return { active: false, note: "inactive: tools.enableHooks is false in settings.json" };
+  let version = "";
+  try {
+    version = execFileSync3("gemini", ["--version"], {
+      encoding: "utf8",
+      timeout: 4e3,
+      stdio: ["ignore", "pipe", "ignore"]
+    }).trim();
+  } catch {
+    return {
+      active: true,
+      note: "could not run `gemini --version`; hooks need tools.enableHooks on versions before 0.46"
+    };
+  }
+  const m = /(\d+)\.(\d+)/.exec(version);
+  if (m && (Number(m[1]) > 0 || Number(m[2]) >= 46)) return { active: true };
+  return {
+    active: false,
+    note: `inactive: Gemini CLI ${version || "?"} runs hooks only with "tools": {"enableHooks": true} in settings.json`
+  };
+}
 var geminiCli = {
   name: NAME4,
   events: GEMINI_EVENTS,
   // ~/.gemini also belongs to Antigravity; Gemini CLI is here when its settings or its chat logs exist.
   detect: (env = process.env) => existsSync5(settings(env)) || existsSync5(path6.join(geminiDir(env), "tmp")),
   configFiles: (env = process.env) => [settings(env)],
-  install: (cmd, env = process.env) => [installClaudeShaped(settings(env), NAME4, GEMINI_EVENTS, cmd, OPTS3)],
-  uninstall: (env = process.env) => [uninstallClaudeShaped(settings(env), GEMINI_EVENTS)],
-  installed: (cmd, env = process.env) => [
-    { file: settings(env), state: installedClaudeShaped(settings(env), NAME4, GEMINI_EVENTS, cmd, OPTS3) }
+  install: (cmd, env = process.env, opts = {}) => {
+    const r = installClaudeShaped(settings(env), NAME4, eventsFor3(opts.lean), cmd, OPTS3);
+    const a = geminiHooksActive(settings(env));
+    return [a.note && !r.skipped ? { ...r, note: [r.note, a.note].filter(Boolean).join("; ") } : r];
+  },
+  uninstall: (env = process.env, opts = {}) => [
+    uninstallClaudeShaped(settings(env), GEMINI_EVENTS, { created: opts.created?.includes(settings(env)) })
   ],
+  installed: (cmd, env = process.env, opts = {}) => {
+    const state = installedClaudeShaped(settings(env), NAME4, eventsFor3(opts.lean), cmd, OPTS3);
+    const a = geminiHooksActive(settings(env));
+    return [
+      {
+        file: settings(env),
+        state: state === "current" && !a.active ? "inactive" : state,
+        ...a.note ? { note: a.note } : {}
+      }
+    ];
+  },
   fromHook(input) {
     const event = input.argv[1] ?? "";
     let s = {};