attestari 0.0.0-stage → 2.9.1

package/dist/hook.js

@@ -0,0 +1,2416 @@
+#!/usr/bin/env node
+"use strict";
+
+// src/main.ts
+var import_node_fs11 = require("node:fs");
+
+// src/adapters/claude-code.ts
+var import_node_path6 = require("node:path");
+
+// src/call.ts
+var import_node_crypto2 = require("node:crypto");
+
+// src/cache.ts
+var import_node_crypto = require("node:crypto");
+var import_node_fs = require("node:fs");
+var import_node_path2 = require("node:path");
+
+// src/paths.ts
+var import_node_os = require("node:os");
+var import_node_path = require("node:path");
+function home() {
+  return process.env.HOME || process.env.USERPROFILE || (0, import_node_os.homedir)();
+}
+function attestariDir() {
+  return (0, import_node_path.join)(home(), ".attestari");
+}
+function agentDir(agent) {
+  return (0, import_node_path.join)(attestariDir(), agent);
+}
+
+// src/validate.ts
+function isObject(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isString(value) {
+  return typeof value === "string";
+}
+function isEntry(value) {
+  return isObject(value) && isString(value.key) && isString(value.source) && isString(value.name) && (value.version === null || isString(value.version)) && (value.decision === "allow" || value.decision === "block" || value.decision === "warn") && isString(value.rule) && (value.grade === null || isString(value.grade));
+}
+function isCompiled(value) {
+  if (!isObject(value) || value.format !== 1) return false;
+  const policy = value.policy;
+  if (!isObject(policy) || typeof policy.version !== "number" || !isString(policy.minimum_grade) || typeof policy.block_not_examined !== "boolean" || typeof policy.block_not_gradeable !== "boolean") {
+    return false;
+  }
+  const unlisted = value.unlisted;
+  if (!isObject(unlisted) || unlisted.decision !== "block" || unlisted.rule !== "not_checked") return false;
+  return isString(value.etag) && value.etag !== "" && isString(value.compiled_at) && Array.isArray(value.not_enforced) && value.not_enforced.every(isString) && Array.isArray(value.servers) && value.servers.every(isEntry);
+}
+
+// src/cache.ts
+var MAX_EVENTS = 1e3;
+function cacheDir(agent) {
+  return agentDir(agent);
+}
+function ensureDir(agent) {
+  const dir = cacheDir(agent);
+  (0, import_node_fs.mkdirSync)(dir, { recursive: true, mode: 448 });
+  return dir;
+}
+function writeAtomic(file, data, mode) {
+  const temporary = `${file}.${process.pid}.tmp`;
+  try {
+    (0, import_node_fs.writeFileSync)(temporary, data, { mode });
+    try {
+      (0, import_node_fs.chmodSync)(temporary, mode);
+    } catch {
+    }
+    (0, import_node_fs.renameSync)(temporary, file);
+  } catch (error) {
+    try {
+      (0, import_node_fs.unlinkSync)(temporary);
+    } catch {
+    }
+    throw error;
+  }
+}
+function readText(file) {
+  try {
+    return (0, import_node_fs.readFileSync)(file, "utf8");
+  } catch {
+    return null;
+  }
+}
+function readPolicy(agent) {
+  const file = (0, import_node_path2.join)(cacheDir(agent), "policy.json");
+  const text = readText(file);
+  if (text === null) return null;
+  let document;
+  try {
+    document = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (!isCompiled(document)) return null;
+  let modified;
+  try {
+    modified = (0, import_node_fs.statSync)(file).mtimeMs;
+  } catch {
+    return null;
+  }
+  return { policy: document, ageMs: Math.max(0, Date.now() - modified) };
+}
+function isResolved(value) {
+  if (typeof value !== "object" || value === null || Array.isArray(value)) return false;
+  const r = value;
+  return typeof r.key === "string" && typeof r.source === "string" && typeof r.name === "string" && (r.version === null || typeof r.version === "string") && typeof r.local === "string";
+}
+function writePolicy(agent, policy, etag) {
+  const dir = ensureDir(agent);
+  writeAtomic((0, import_node_path2.join)(dir, "policy.json"), `${JSON.stringify(policy, null, 2)}
+`, 384);
+  writeAtomic((0, import_node_path2.join)(dir, "policy.etag"), etag, 384);
+}
+function readEtag(agent) {
+  const etag = readText((0, import_node_path2.join)(cacheDir(agent), "policy.etag"))?.trim();
+  return etag ? etag : null;
+}
+function readToken(agent) {
+  const text = readText((0, import_node_path2.join)(cacheDir(agent), "token"));
+  const token = text?.trim();
+  return token ? token : null;
+}
+function writeToken(agent, token) {
+  writeAtomic((0, import_node_path2.join)(ensureDir(agent), "token"), token, 384);
+}
+function appendEvent(agent, event) {
+  const file = (0, import_node_path2.join)(ensureDir(agent), "events.jsonl");
+  (0, import_node_fs.appendFileSync)(file, `${JSON.stringify(event)}
+`, { mode: 384 });
+  const lines = (readText(file) ?? "").split("\n").filter((line) => line !== "");
+  if (lines.length > MAX_EVENTS) {
+    writeAtomic(file, `${lines.slice(-MAX_EVENTS).join("\n")}
+`, 384);
+  }
+}
+function readEvents(agent) {
+  const events = [];
+  for (const line of (readText((0, import_node_path2.join)(cacheDir(agent), "events.jsonl")) ?? "").split("\n")) {
+    if (line === "") continue;
+    try {
+      events.push(JSON.parse(line));
+    } catch {
+    }
+  }
+  return events;
+}
+function removeEvents(agent, ids) {
+  const file = (0, import_node_path2.join)(cacheDir(agent), "events.jsonl");
+  const text = readText(file);
+  if (text === null) return;
+  const sent2 = new Set(ids);
+  const keep = readEvents(agent).filter((event) => !sent2.has(event.id));
+  if (keep.length === 0) {
+    try {
+      (0, import_node_fs.unlinkSync)(file);
+    } catch {
+    }
+    return;
+  }
+  writeAtomic(file, `${keep.map((event) => JSON.stringify(event)).join("\n")}
+`, 384);
+}
+function folderId(cwd) {
+  return (0, import_node_crypto.createHash)("sha256").update(cwd, "utf8").digest("hex").slice(0, 16);
+}
+var FOLDER_FILE = /^([0-9a-f]{16})\.json$/;
+function parseResolution(id, text, modifiedMs) {
+  if (text === null) return null;
+  let document;
+  try {
+    document = JSON.parse(text);
+  } catch {
+    return null;
+  }
+  if (typeof document !== "object" || document === null || Array.isArray(document)) return null;
+  const { complete, servers, cwd } = document;
+  if (typeof complete !== "boolean" || !Array.isArray(servers) || !servers.every(isResolved)) return null;
+  const path = typeof cwd === "string" && cwd !== "" && folderId(cwd) === id ? { cwd } : {};
+  const when = modifiedMs === void 0 ? {} : { modifiedMs };
+  return { id, complete, servers: servers.map((r) => ({ ...r, folder: id.slice(0, 8) })), ...path, ...when };
+}
+function readResolution(agent, cwd) {
+  return readResolutionOf(agent, folderId(cwd));
+}
+function readResolutionOf(agent, id) {
+  if (!/^[0-9a-f]{16}$/.test(id)) return null;
+  return parseResolution(id, readText((0, import_node_path2.join)(cacheDir(agent), "resolved", `${id}.json`)));
+}
+function sessionFile(agent, sessionId) {
+  const name = /^[A-Za-z0-9_-]{1,128}$/.test(sessionId) ? sessionId : (0, import_node_crypto.createHash)("sha256").update(sessionId, "utf8").digest("hex");
+  return (0, import_node_path2.join)(cacheDir(agent), "sessions", name);
+}
+function writeSession(agent, sessionId, cwd) {
+  (0, import_node_fs.mkdirSync)((0, import_node_path2.join)(ensureDir(agent), "sessions"), { recursive: true, mode: 448 });
+  writeAtomic(sessionFile(agent, sessionId), `${JSON.stringify({ folder: folderId(cwd), cwd })}
+`, 384);
+}
+function readSession(agent, sessionId) {
+  const text = readText(sessionFile(agent, sessionId));
+  if (text === null) return null;
+  try {
+    const value = JSON.parse(text);
+    if (typeof value !== "object" || value === null) return null;
+    const { folder, cwd } = value;
+    return typeof folder === "string" && typeof cwd === "string" && cwd !== "" && folderId(cwd) === folder ? { folder, cwd } : null;
+  } catch {
+    return null;
+  }
+}
+function pruneSessions(agent, maxAgeMs, now = Date.now()) {
+  const dir = (0, import_node_path2.join)(cacheDir(agent), "sessions");
+  let names;
+  try {
+    names = (0, import_node_fs.readdirSync)(dir);
+  } catch {
+    return 0;
+  }
+  let removed = 0;
+  for (const name of names) {
+    try {
+      const file = (0, import_node_path2.join)(dir, name);
+      if (now - (0, import_node_fs.statSync)(file).mtimeMs > maxAgeMs) {
+        (0, import_node_fs.unlinkSync)(file);
+        removed += 1;
+      }
+    } catch {
+    }
+  }
+  return removed;
+}
+function readResolutions(agent) {
+  let names;
+  try {
+    names = (0, import_node_fs.readdirSync)((0, import_node_path2.join)(cacheDir(agent), "resolved")).sort();
+  } catch {
+    return [];
+  }
+  const out = [];
+  for (const name of names) {
+    const id = FOLDER_FILE.exec(name)?.[1];
+    if (id === void 0) continue;
+    const file = (0, import_node_path2.join)(cacheDir(agent), "resolved", name);
+    let modifiedMs;
+    try {
+      modifiedMs = (0, import_node_fs.statSync)(file).mtimeMs;
+    } catch {
+      modifiedMs = void 0;
+    }
+    const resolution = parseResolution(id, readText(file), modifiedMs);
+    if (resolution !== null) out.push(resolution);
+  }
+  return out;
+}
+function writeResolution(agent, cwd, servers, complete) {
+  const dir = (0, import_node_path2.join)(ensureDir(agent), "resolved");
+  const file = (0, import_node_path2.join)(dir, `${folderId(cwd)}.json`);
+  try {
+    (0, import_node_fs.mkdirSync)(dir, { recursive: true, mode: 448 });
+    const kept = servers.map(({ folder: _folder, ...r }) => r);
+    writeAtomic(file, `${JSON.stringify({ complete, cwd, servers: kept }, null, 2)}
+`, 384);
+  } catch (error) {
+    try {
+      (0, import_node_fs.rmSync)(file, { force: true });
+    } catch {
+    }
+    throw error;
+  }
+}
+function readWritten(agent, id) {
+  const text = readText((0, import_node_path2.join)(cacheDir(agent), "written", `${id}.json`));
+  if (text === null) return [];
+  try {
+    const value = JSON.parse(text);
+    return Array.isArray(value) && value.every((v) => typeof v === "string") ? value : [];
+  } catch {
+    return [];
+  }
+}
+function dropResolution(agent, id) {
+  if (!/^[0-9a-f]{16}$/.test(id)) return;
+  (0, import_node_fs.rmSync)((0, import_node_path2.join)(cacheDir(agent), "resolved", `${id}.json`), { force: true });
+  (0, import_node_fs.rmSync)((0, import_node_path2.join)(cacheDir(agent), "written", `${id}.json`), { force: true });
+}
+function writeWritten(agent, id, written) {
+  const dir = (0, import_node_path2.join)(ensureDir(agent), "written");
+  (0, import_node_fs.mkdirSync)(dir, { recursive: true, mode: 448 });
+  writeAtomic((0, import_node_path2.join)(dir, `${id}.json`), `${JSON.stringify(written, null, 2)}
+`, 384);
+}
+function deleteToken(agent) {
+  try {
+    (0, import_node_fs.unlinkSync)((0, import_node_path2.join)(cacheDir(agent), "token"));
+  } catch {
+  }
+}
+function deletePolicy(agent) {
+  for (const name of ["policy.json", "policy.etag"]) {
+    try {
+      (0, import_node_fs.unlinkSync)((0, import_node_path2.join)(cacheDir(agent), name));
+    } catch {
+    }
+  }
+}
+function deleteStamp(agent, name) {
+  try {
+    (0, import_node_fs.unlinkSync)((0, import_node_path2.join)(cacheDir(agent), name));
+  } catch {
+  }
+}
+function writeStamp(agent, name, at = /* @__PURE__ */ new Date(), word) {
+  writeAtomic((0, import_node_path2.join)(ensureDir(agent), name), `${at.toISOString()}${word === void 0 ? "" : ` ${word}`}
+`, 384);
+}
+function readStamp(agent, name) {
+  const parts = (readText((0, import_node_path2.join)(cacheDir(agent), name)) ?? "").trim().split(/\s+/);
+  const at = Date.parse(parts[0]);
+  if (parts[0] === "" || Number.isNaN(at)) return null;
+  return { at, word: parts[1] ?? null };
+}
+function stampAge(agent, name, now = Date.now()) {
+  const stamp = readStamp(agent, name);
+  if (stamp === null || stamp.at > now) return null;
+  return now - stamp.at;
+}
+var SECRET_BYTES = 32;
+function readSecret(agent) {
+  const file = (0, import_node_path2.join)(ensureDir(agent), "secret");
+  const held = () => {
+    try {
+      const bytes = (0, import_node_fs.readFileSync)(file);
+      return bytes.length === SECRET_BYTES ? bytes : null;
+    } catch {
+      return null;
+    }
+  };
+  const existing = held();
+  if (existing !== null) return existing;
+  const fresh = (0, import_node_crypto.randomBytes)(SECRET_BYTES);
+  const temporary = `${file}.${process.pid}.tmp`;
+  (0, import_node_fs.writeFileSync)(temporary, fresh, { mode: 384 });
+  try {
+    try {
+      (0, import_node_fs.chmodSync)(temporary, 384);
+    } catch {
+    }
+    try {
+      (0, import_node_fs.linkSync)(temporary, file);
+      return fresh;
+    } catch {
+      const other = held();
+      if (other !== null) return other;
+      (0, import_node_fs.renameSync)(temporary, file);
+      return fresh;
+    }
+  } finally {
+    try {
+      (0, import_node_fs.unlinkSync)(temporary);
+    } catch {
+    }
+  }
+}
+
+// src/decide.ts
+var STALE_MS = 7 * 24 * 60 * 60 * 1e3;
+var NOT_CHECKED = "not_checked";
+var PACKAGES = /* @__PURE__ */ new Set(["npm", "pypi", "remote"]);
+var BY_KEY = /* @__PURE__ */ new Set(["local", "skill"]);
+var REPORTS = /* @__PURE__ */ new Set(["npm", "pypi"]);
+var STRICTEST = { block: 0, warn: 1, allow: 2 };
+function reducedKey(key) {
+  return Array.from(key, (c) => /^[A-Za-z0-9@/._-]$/.test(c) ? c : "_").join("").slice(0, 214);
+}
+function suffixedKey(reduced, folder) {
+  return `${reduced.slice(0, 214 - folder.length - 1)}/${folder}`;
+}
+function oneLine(text) {
+  return text.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g, " ");
+}
+function named(name, version) {
+  return version === null ? name : `${name} ${version}`;
+}
+function report(source, name, version) {
+  if (!REPORTS.has(source)) return "app.attestari.ai/tools";
+  const path = name.split("/").map(encodeURIComponent).join("/");
+  return `app.attestari.ai/tools/${source}/${path}${version === null ? "" : `/${encodeURIComponent(version)}`}`;
+}
+var BLOCKED = "Blocked by your organization's policy:";
+var REASONS = /* @__PURE__ */ new Map([
+  ["below_minimum_grade", (e, p) => `${BLOCKED} ${named(e.name, e.version)} is graded ${e.grade === null ? "" : `${e.grade}, `}below the minimum ${p.policy.minimum_grade}.`],
+  ["not_examined", (e) => `${BLOCKED} ${named(e.name, e.version)} has not been examined by Attestari yet.`],
+  ["under_re_examination", (e) => `${BLOCKED} ${named(e.name, e.version)} is being re-examined by Attestari.`],
+  ["not_gradeable", (e) => `${BLOCKED} ${named(e.name, e.version)} was examined and could not be graded.`]
+]);
+function blocked(entry, policy) {
+  const words = REASONS.get(entry.rule);
+  const said = words ? words(entry, policy) : `${BLOCKED} ${named(entry.name, entry.version)} (${entry.rule}).`;
+  return `${said} ${report(entry.source, entry.name, entry.version)}`;
+}
+function matches(entry, resolved) {
+  if (entry.source !== resolved.source) return false;
+  if (BY_KEY.has(resolved.source)) {
+    const reduced = reducedKey(resolved.key);
+    return entry.key === reduced || resolved.folder !== void 0 && entry.key === suffixedKey(reduced, resolved.folder);
+  }
+  if (PACKAGES.has(resolved.source)) return entry.name === resolved.name && (resolved.version === null || entry.version === resolved.version);
+  return false;
+}
+function entryFor(policy, resolved) {
+  return policy.servers.filter((e) => matches(e, resolved)).sort((a, b) => STRICTEST[a.decision] - STRICTEST[b.decision])[0];
+}
+function deny(rule, reason) {
+  return { allow: false, reason: oneLine(reason), rule };
+}
+function decide(policy, ageMs, resolved, key = resolved?.key) {
+  const tool = resolved !== null ? named(resolved.name, resolved.version) : key !== void 0 ? `the server "${reducedKey(key)}"` : "this server";
+  if (policy === null) {
+    return deny(NOT_CHECKED, `Not checked by Attestari: this agent holds no Attestari policy, so ${tool} is blocked. Pair it at app.attestari.ai/agents`);
+  }
+  if (ageMs > STALE_MS) {
+    return deny(NOT_CHECKED, `Attestari blocked ${tool}: not checked in for 7 days: open app.attestari.ai`);
+  }
+  const entry = resolved === null ? void 0 : entryFor(policy, resolved);
+  if (entry === void 0) {
+    return deny(policy.unlisted.rule, `Not yet checked by Attestari: ${tool} is not in your organization's policy yet. app.attestari.ai/agents`);
+  }
+  if (entry.decision === "allow") return { allow: true };
+  if (entry.decision === "warn") return { allow: true, warn: { rule: entry.rule } };
+  return deny(entry.rule, blocked(entry, policy));
+}
+
+// src/refresh.ts
+var import_node_child_process = require("node:child_process");
+var import_node_fs2 = require("node:fs");
+var HOUR_MS = 60 * 60 * 1e3;
+var DAY_MS = 24 * HOUR_MS;
+var CHECKED_IN = "checked_in";
+var LOOKUP_UNAVAILABLE = "lookup_unavailable";
+var REFUSED = "refused";
+function say(line) {
+  process.stderr.write(`attestari-hook: ${line.replace(/\s+/g, " ").trim()}
+`);
+}
+function message(error) {
+  return error instanceof Error ? error.message : String(error);
+}
+function attempt(what, fn) {
+  try {
+    fn();
+  } catch (error) {
+    say(`${what}: ${message(error)}`);
+  }
+}
+function usableFolder(folder) {
+  try {
+    return typeof folder === "string" && folder !== "" && (0, import_node_fs2.statSync)(folder).isDirectory() ? folder : void 0;
+  } catch {
+    return void 0;
+  }
+}
+function spawnRefresh(agent, cwd) {
+  const at = /* @__PURE__ */ new Date();
+  attempt("refresh_started_at was not written", () => writeStamp(agent, "refresh_started_at", at));
+  const folder = usableFolder(cwd);
+  let pid;
+  try {
+    const child = (0, import_node_child_process.spawn)(process.execPath, [__filename, agent, "refresh", ...cwd !== void 0 && cwd !== "" ? ["--cwd", cwd] : []], {
+      cwd: folder,
+      detached: true,
+      stdio: "ignore",
+      windowsHide: true
+    });
+    child.on("error", () => {
+    });
+    child.unref();
+    pid = child.pid;
+  } catch (error) {
+    say(`the refresh could not be started: ${message(error)}`);
+  }
+  if (pid === void 0) {
+    attempt("refresh_started_at was not removed", () => deleteStamp(agent, "refresh_started_at"));
+    return;
+  }
+  const started = pid;
+  attempt("refresh_started_at was not written", () => writeStamp(agent, "refresh_started_at", at, started));
+}
+function heldBack(agent, now, onlyAfterRefusal) {
+  const next = readStamp(agent, "next_refresh_at");
+  if (next === null || next.at <= now) return false;
+  return !onlyAfterRefusal || next.word !== CHECKED_IN;
+}
+function refreshDue(agent, now = Date.now()) {
+  if (readToken(agent) === null) return false;
+  const checked = stampAge(agent, "checked_in_at", now);
+  if (checked !== null && checked < HOUR_MS) return false;
+  const started = stampAge(agent, "refresh_started_at", now);
+  if (started !== null && started < HOUR_MS) return false;
+  return !heldBack(agent, now, false);
+}
+
+// src/call.ts
+var UNREADABLE = "Attestari could not read the tool call";
+var UNREADABLE_VERDICT = { allow: false, reason: UNREADABLE, rule: "unreadable" };
+function record(adapter, decision, rule, tool) {
+  try {
+    appendEvent(adapter.name, { id: (0, import_node_crypto2.randomUUID)(), at: (/* @__PURE__ */ new Date()).toISOString(), decision, rule, tool, agent_client: adapter.client });
+  } catch {
+  }
+}
+function refreshWhenDue(agent, cwd) {
+  try {
+    if (refreshDue(agent)) spawnRefresh(agent, cwd);
+  } catch {
+  }
+}
+function decideCall(adapter, event, stdinText) {
+  const parsed = adapter.parse(event, stdinText);
+  if (parsed.kind === "unreadable") return adapter.deny(event, UNREADABLE_VERDICT);
+  if (parsed.kind === "other") return adapter.allow(event);
+  const agent = adapter.name;
+  const session = parsed.sessionId !== void 0 && parsed.sessionId !== "" ? readSession(agent, parsed.sessionId) : null;
+  const cwd = session?.cwd ?? (parsed.cwd !== void 0 && parsed.cwd !== "" ? parsed.cwd : void 0);
+  refreshWhenDue(agent, cwd);
+  const resolution = session !== null ? readResolutionOf(agent, session.folder) : cwd !== void 0 ? readResolution(agent, cwd) : null;
+  const same2 = adapter.matches ?? ((a, b) => a === b);
+  const held = parsed.plugin ? [] : (resolution?.servers ?? []).filter((r) => same2(parsed.key, r.key));
+  const resolved = held.length === 1 ? held[0] : null;
+  const cached = readPolicy(agent);
+  const verdict = decide(cached?.policy ?? null, cached?.ageMs ?? 0, resolved, parsed.shown ?? parsed.key);
+  const tool = resolved && { source: resolved.source, name: resolved.name, version: resolved.version };
+  if (!verdict.allow) {
+    if (tool) record(adapter, "blocked", verdict.rule, tool);
+    return adapter.deny(event, verdict);
+  }
+  if (verdict.warn && tool) record(adapter, "warned", verdict.warn.rule, tool);
+  return adapter.allow(event);
+}
+
+// src/denies.ts
+var import_node_fs3 = require("node:fs");
+var import_node_path3 = require("node:path");
+function isObject2(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function denyOf(r) {
+  const launch = r.launch;
+  if (!isObject2(launch)) return null;
+  const command = launch.command;
+  if (Array.isArray(command) && command.length > 0 && command.every((c) => typeof c === "string")) return { serverCommand: command };
+  if (typeof launch.url === "string" && launch.url !== "") return { serverUrl: launch.url };
+  return null;
+}
+function blockedForms(resolved, policy) {
+  const forms = resolved.filter((r) => entryFor(policy, r)?.decision === "block").map(denyOf).filter((e) => e !== null);
+  return [...new Set(forms.map((e) => JSON.stringify(e)))];
+}
+function indentOf(text) {
+  const first = /\n([ \t]+)\S/.exec(text);
+  if (first === null) return 2;
+  return first[1].startsWith("	") ? "	" : Math.min(first[1].length, 8);
+}
+function bytesOf(file) {
+  try {
+    return (0, import_node_fs3.readFileSync)(file);
+  } catch (error) {
+    if (error.code === "ENOENT") return null;
+    throw error;
+  }
+}
+function same(a, b) {
+  return a === null || b === null ? a === b : a.equals(b);
+}
+var beforeRename = null;
+function writeBeside(file, data, mode, read) {
+  const temporary = `${file}.${process.pid}.attestari.tmp`;
+  try {
+    (0, import_node_fs3.writeFileSync)(temporary, data, mode === void 0 ? {} : { mode });
+    if (mode !== void 0) {
+      try {
+        (0, import_node_fs3.chmodSync)(temporary, mode);
+      } catch {
+      }
+    }
+    beforeRename?.();
+    if (!same(bytesOf(file), read)) {
+      (0, import_node_fs3.unlinkSync)(temporary);
+      return false;
+    }
+    (0, import_node_fs3.renameSync)(temporary, file);
+    return true;
+  } catch (error) {
+    try {
+      (0, import_node_fs3.unlinkSync)(temporary);
+    } catch {
+    }
+    throw error;
+  }
+}
+function formatLike(text, value) {
+  const bom = text !== null && text.startsWith("\uFEFF");
+  const crlf = text !== null && text.includes("\r\n");
+  const newline = text === null || /\n$/.test(text);
+  let out = JSON.stringify(value, null, text === null ? 2 : indentOf(text)) + (newline ? "\n" : "");
+  if (crlf) out = out.replace(/\n/g, "\r\n");
+  if (bom) out = `\uFEFF${out}`;
+  return out;
+}
+function modeOf(file, text) {
+  try {
+    return text === null ? void 0 : (0, import_node_fs3.statSync)(file).mode & 511;
+  } catch {
+    return void 0;
+  }
+}
+function say2(line) {
+  process.stderr.write(`attestari-hook: ${line}
+`);
+}
+function writeDenies(agent, settingsPath, resolved, policy, written, takeBack = true, elsewhere = /* @__PURE__ */ new Set()) {
+  void agent;
+  const wanted = blockedForms(resolved, policy);
+  let read;
+  try {
+    read = bytesOf(settingsPath);
+  } catch {
+    say2(`${settingsPath} could not be read; its deny entries are left as they were`);
+    return written;
+  }
+  const text = read === null ? null : read.toString("utf8");
+  if (text === null) {
+    if (wanted.length === 0) return [];
+    if (!(0, import_node_fs3.existsSync)((0, import_node_path3.dirname)(settingsPath))) {
+      say2(`${(0, import_node_path3.dirname)(settingsPath)} does not exist; no deny entry is written`);
+      return written;
+    }
+  }
+  const bom = text !== null && text.startsWith("\uFEFF");
+  let settings;
+  try {
+    settings = text === null ? {} : JSON.parse(bom ? text.slice(1) : text);
+  } catch {
+    settings = void 0;
+  }
+  if (!isObject2(settings) || settings.deniedMcpServers !== void 0 && !Array.isArray(settings.deniedMcpServers)) {
+    say2(`${settingsPath} is not a settings file the hook can read; its deny entries are left as they were`);
+    return written;
+  }
+  const existing = settings.deniedMcpServers ?? [];
+  const mine = new Set(written);
+  const want = new Set(wanted);
+  const applies = (form) => want.has(form) || elsewhere.has(form);
+  const kept = existing.filter((e) => {
+    const form = JSON.stringify(e);
+    return !(takeBack && mine.has(form) && !applies(form));
+  });
+  const present = new Set(kept.map((e) => JSON.stringify(e)));
+  const added = wanted.filter((form) => !present.has(form));
+  const now = takeBack ? [...wanted.filter((form) => mine.has(form) || added.includes(form)), ...written.filter((form) => !want.has(form) && elsewhere.has(form))] : [...written, ...added.filter((form) => !mine.has(form))];
+  if (added.length === 0 && kept.length === existing.length) return now;
+  const next = { ...settings, deniedMcpServers: [...kept, ...added.map((form) => JSON.parse(form))] };
+  const crlf = text !== null && text.includes("\r\n");
+  const newline = text === null || /\n$/.test(text);
+  let out = JSON.stringify(next, null, text === null ? 2 : indentOf(text)) + (newline ? "\n" : "");
+  if (crlf) out = out.replace(/\n/g, "\r\n");
+  if (bom) out = `\uFEFF${out}`;
+  let mode;
+  try {
+    mode = text === null ? void 0 : (0, import_node_fs3.statSync)(settingsPath).mode & 511;
+  } catch {
+    mode = void 0;
+  }
+  if (!writeBeside(settingsPath, out, mode, read)) {
+    say2(`${settingsPath} changed while the hook wrote its deny entries; they are left as they were until the next check-in`);
+    return written;
+  }
+  return now;
+}
+function writeDenyList(file, get, put, wanted, written, takeBack = true, elsewhere = /* @__PURE__ */ new Set()) {
+  let read;
+  try {
+    read = bytesOf(file);
+  } catch {
+    say2(`${file} could not be read; its deny entries are left as they were`);
+    return written;
+  }
+  const text = read === null ? null : read.toString("utf8");
+  if (text === null) {
+    if (wanted.length === 0) return [];
+    if (!(0, import_node_fs3.existsSync)((0, import_node_path3.dirname)(file))) {
+      say2(`${(0, import_node_path3.dirname)(file)} does not exist; no deny entry is written`);
+      return written;
+    }
+  }
+  const bom = text !== null && text.startsWith("\uFEFF");
+  let settings;
+  try {
+    settings = text === null ? {} : JSON.parse(bom ? text.slice(1) : text);
+  } catch {
+    settings = void 0;
+  }
+  const existing = isObject2(settings) ? get(settings) : null;
+  if (!isObject2(settings) || existing === null) {
+    say2(`${file} is not a settings file the hook can read; its deny entries are left as they were`);
+    return written;
+  }
+  const current = existing ?? [];
+  const mine = new Set(written);
+  const want = new Set(wanted);
+  const applies = (form) => want.has(form) || elsewhere.has(form);
+  const kept = current.filter((e) => {
+    const form = JSON.stringify(e);
+    return !(takeBack && mine.has(form) && !applies(form));
+  });
+  const present = new Set(kept.map((e) => JSON.stringify(e)));
+  const added = wanted.filter((form) => !present.has(form));
+  const now = takeBack ? [...wanted.filter((form) => mine.has(form) || added.includes(form)), ...written.filter((form) => !want.has(form) && elsewhere.has(form))] : [...written, ...added.filter((form) => !mine.has(form))];
+  if (added.length === 0 && kept.length === current.length) return now;
+  const next = put(settings, [...kept, ...added.map((form) => JSON.parse(form))]);
+  const out = formatLike(text, next);
+  if (!writeBeside(file, bom ? `\uFEFF${out}` : out, modeOf(file, text), read)) {
+    say2(`${file} changed while the hook wrote its deny entries; they are left as they were until the next check-in`);
+    return written;
+  }
+  return now;
+}
+
+// src/plugin.ts
+var import_node_child_process2 = require("node:child_process");
+var import_node_fs4 = require("node:fs");
+var import_node_path4 = require("node:path");
+var DEFAULT_MARKETPLACE = "https://attestari.ai/plugins/marketplace.json";
+var PLUGIN = "attestari@attestari";
+var TIMEOUT_MS = 6e4;
+var WINDOWS_EXTENSIONS = [".com", ".exe", ".bat", ".cmd"];
+var CMD_UNSAFE = /["%^&|<>!\r\n]/;
+function marketplace() {
+  return process.env.ATTESTARI_MARKETPLACE || DEFAULT_MARKETPLACE;
+}
+function steps(market) {
+  return [
+    ["plugin", "marketplace", "add", market],
+    ["plugin", "install", PLUGIN, "--scope", "user"]
+  ];
+}
+function runnable(file, windows) {
+  try {
+    if (!(0, import_node_fs4.statSync)(file).isFile()) return false;
+    if (!windows) (0, import_node_fs4.accessSync)(file, import_node_fs4.constants.X_OK);
+    return true;
+  } catch {
+    return false;
+  }
+}
+function findOnPath(name, path = process.env.PATH ?? "", windows = process.platform === "win32") {
+  const named2 = (process.env.PATHEXT ?? "").split(";").map((e) => e.trim().toLowerCase()).filter((e) => WINDOWS_EXTENSIONS.includes(e));
+  const extensions = named2.length > 0 ? named2 : WINDOWS_EXTENSIONS;
+  for (const folder of path.split(import_node_path4.delimiter)) {
+    if (folder.trim() === "") continue;
+    const candidates = windows ? extensions.map((e) => (0, import_node_path4.join)(folder, `${name}${e}`)) : [(0, import_node_path4.join)(folder, name)];
+    for (const candidate of candidates) if (runnable(candidate, windows)) return candidate;
+  }
+  return null;
+}
+function run(file, args) {
+  const options = { timeout: TIMEOUT_MS, stdio: "pipe", windowsHide: true };
+  let result;
+  if (process.platform === "win32" && /\.(cmd|bat)$/i.test(file)) {
+    const all = [file, ...args];
+    if (all.some((a) => CMD_UNSAFE.test(a))) return "a character cmd.exe would read";
+    const line = all.map((a) => `"${a}"`).join(" ");
+    result = (0, import_node_child_process2.spawnSync)(process.env.ComSpec || "cmd.exe", ["/d", "/s", "/c", `"${line}"`], { ...options, windowsVerbatimArguments: true });
+  } else {
+    result = (0, import_node_child_process2.spawnSync)(file, args, options);
+  }
+  const code = result.error?.code;
+  if (code === "ETIMEDOUT") return "timed out";
+  if (result.error) return code ?? "did not run";
+  if (result.status === 0) return null;
+  return result.status !== null ? `exit ${result.status}` : result.signal ?? "did not run";
+}
+function installPlugin() {
+  const claude = findOnPath("claude");
+  if (claude === null) return { installed: false, why: "Claude Code (claude) is not on the PATH" };
+  for (const args of steps(marketplace())) {
+    const failed2 = run(claude, args);
+    if (failed2 !== null) return { installed: false, why: `\`claude ${args.slice(0, args[1] === "marketplace" ? 3 : 2).join(" ")}\` failed (${failed2})` };
+  }
+  return { installed: true };
+}
+function installCommands() {
+  const market = marketplace().replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g, " ");
+  const shown = /\s/.test(market) ? `"${market}"` : market;
+  return steps(shown).map((args) => `  claude ${args.join(" ")}
+`).join("");
+}
+
+// src/resolve.ts
+var import_node_crypto3 = require("node:crypto");
+var import_node_fs5 = require("node:fs");
+var import_node_path5 = require("node:path");
+var SERVERS_AT_MOST = 200;
+var NPM_NAME = /^(?:@[A-Za-z0-9~-][A-Za-z0-9._~-]*\/)?[A-Za-z0-9~-][A-Za-z0-9._~-]*$/;
+var PYPI_NAME = /^(?:[A-Za-z0-9]|[A-Za-z0-9][A-Za-z0-9._-]*[A-Za-z0-9])$/;
+var CONTROL = /[\u0000-\u001f\u007f-\u009f]/;
+var SOURCES = /* @__PURE__ */ new Set(["npm", "pypi", "local", "remote"]);
+var NPM_EXACT = /^v?(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?)$/;
+var PYPI_EXACT = /^[0-9][0-9A-Za-z.+!-]*$/;
+function isStrings(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+function runner(command) {
+  const file = command.split(/[\\/]/).pop() ?? command;
+  return file.toLowerCase().replace(/\.(cmd|exe|bat|ps1)$/, "");
+}
+var NPM_WANTED = /^[0-9A-Za-z.^~<>=|*+ -]*$/;
+function npmSpec(spec) {
+  const at = spec.indexOf("@", spec.startsWith("@") ? 1 : 0);
+  const name = at > 0 ? spec.slice(0, at) : spec;
+  const wanted = at > 0 ? spec.slice(at + 1) : "";
+  if (!NPM_NAME.test(name) || name.length > 214 || !NPM_WANTED.test(wanted)) return null;
+  const exact = NPM_EXACT.exec(wanted);
+  return { source: "npm", name, version: exact ? exact[1] : null };
+}
+var RUNNER_NO_VALUE = /* @__PURE__ */ new Set(["-y", "--yes", "-q", "--quiet"]);
+function npmRunner(args) {
+  const packages = [];
+  let i = 0;
+  for (; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--") {
+      i++;
+      break;
+    }
+    if (a === "-p" || a === "--package") {
+      if (i + 1 >= args.length) return null;
+      packages.push(args[++i]);
+      continue;
+    }
+    if (a.startsWith("--package=")) {
+      packages.push(a.slice("--package=".length));
+      continue;
+    }
+    if (RUNNER_NO_VALUE.has(a)) continue;
+    if (a.startsWith("-")) return null;
+    break;
+  }
+  if (packages.length > 1) return null;
+  const spec = packages[0] ?? args[i];
+  return spec === void 0 ? null : npmSpec(spec);
+}
+function pypiSpec(spec) {
+  const match = /^([A-Za-z0-9][A-Za-z0-9._-]*)(?:\[[^\]]*\])?(.*)$/.exec(spec.trim());
+  if (match === null || !PYPI_NAME.test(match[1]) || match[1].length > 214) return null;
+  const rest = match[2].trim();
+  if (/[:/]/.test(rest)) return null;
+  const exact = /^(?:==|@)\s*([^\s,;<>=!~*@]+)$/.exec(rest);
+  if (rest !== "" && exact === null && !/^[<>=!~]/.test(rest)) return null;
+  return { source: "pypi", name: match[1], version: exact && PYPI_EXACT.test(exact[1]) ? exact[1] : null };
+}
+function pypiRunner(args, from) {
+  let chosen = null;
+  let i = 0;
+  for (; i < args.length; i++) {
+    const a = args[i];
+    if (a === from || a.startsWith(`${from}=`)) {
+      const value = a === from ? args[++i] : a.slice(from.length + 1);
+      if (value === void 0 || chosen !== null) return null;
+      chosen = value;
+      continue;
+    }
+    if (RUNNER_NO_VALUE.has(a)) continue;
+    if (from === "--from" && (a === "--python" || a === "-p")) {
+      if (i + 1 >= args.length) return null;
+      i++;
+      continue;
+    }
+    if (from === "--from" && a.startsWith("--python=")) continue;
+    if (a.startsWith("-")) return null;
+    break;
+  }
+  const spec = chosen ?? args[i];
+  return spec === void 0 ? null : pypiSpec(spec);
+}
+function unwrapped(command, args) {
+  if (runner(command) === "cmd" && args.length >= 2 && /^\/[ck]$/i.test(args[0])) return unwrapped(args[1], args.slice(2));
+  return [command, args];
+}
+function registryRunner(configuredCommand, configuredArgs) {
+  const [command, args] = unwrapped(configuredCommand, configuredArgs);
+  const run3 = runner(command);
+  if (run3 === "npx" || run3 === "bunx" || run3 === "pnpx" || run3 === "uvx") return true;
+  if ((run3 === "pnpm" || run3 === "yarn") && args[0] === "dlx") return true;
+  return run3 === "pipx" && args[0] === "run";
+}
+function packageOf(configuredCommand, configuredArgs) {
+  const [command, args] = unwrapped(configuredCommand, configuredArgs);
+  const run3 = runner(command);
+  if (run3 === "npx" || run3 === "bunx" || run3 === "pnpx") return npmRunner(args);
+  if ((run3 === "pnpm" || run3 === "yarn") && args[0] === "dlx") return npmRunner(args.slice(1));
+  if (run3 === "uvx") return pypiRunner(args, "--from");
+  if (run3 === "pipx" && args[0] === "run") return pypiRunner(args.slice(1), "--spec");
+  return null;
+}
+function secretLike(segment) {
+  return /[%@=+]/.test(segment) || segment.length >= 16 && /[0-9]/.test(segment) && /[A-Za-z]/.test(segment);
+}
+function remoteName(address) {
+  let url2;
+  try {
+    url2 = new URL(address.trim());
+  } catch {
+    return null;
+  }
+  if (!["http:", "https:", "ws:", "wss:"].includes(url2.protocol) || url2.hostname === "") return null;
+  const port = url2.port === "" ? "" : `:${url2.port}`;
+  const path = url2.pathname.replace(/\/+$/, "").split("/").map((segment) => secretLike(segment) ? "*" : segment).join("/");
+  return `${url2.hostname.toLowerCase()}${port}${path}`;
+}
+function pathLike(arg) {
+  if (arg.startsWith("-") || /^\/[A-Za-z?]$/.test(arg)) return false;
+  if (/[=?#@]/.test(arg) || arg.replace(/^[A-Za-z]:(?=[\\/])/, "").includes(":")) return false;
+  return /[\\/]/.test(arg) || arg.startsWith("~") || /\.(?:[cm]?[jt]s|py)$/i.test(arg);
+}
+var FILE_NAME = /^[A-Za-z0-9._-]{1,200}$/;
+function fileName(file) {
+  if (!FILE_NAME.test(file) || secretLike(file)) return false;
+  return !(file.length >= 16 && !file.includes(".") && /[a-z]/.test(file) && /[A-Z]/.test(file));
+}
+function fileAndFolder(path, home2) {
+  const expanded = path === "~" || path.startsWith("~/") || path.startsWith("~\\") ? `${home2}${path.slice(1)}` : path;
+  const parts = expanded.split(/[\\/]/);
+  const file = parts.pop() ?? "";
+  return { file, folder: parts.join("/") };
+}
+function labelOf(folder, home2) {
+  const slashed = folder.replace(/\\/g, "/");
+  const root = home2.replace(/\\/g, "/").replace(/\/+$/, "");
+  const fold = (s) => process.platform === "win32" ? s.toLowerCase() : s;
+  if (root !== "" && (fold(slashed) === fold(root) || fold(slashed).startsWith(`${fold(root)}/`))) return `~${slashed.slice(root.length)}`;
+  return slashed;
+}
+function localName(configuredCommand, configuredArgs, home2, secret) {
+  const [command, args] = unwrapped(configuredCommand, configuredArgs);
+  const path = args.find(pathLike);
+  const fromArg = path === void 0 ? null : fileAndFolder(path, home2);
+  const chosen = fromArg !== null && fileName(fromArg.file) ? fromArg : fileAndFolder(command, home2);
+  const file = fileName(chosen.file) ? chosen.file : "local";
+  const hash = (0, import_node_crypto3.createHmac)("sha256", secret).update(labelOf(chosen.folder, home2), "utf8").digest("hex").slice(0, 12);
+  return `${file}#${hash}`;
+}
+function resolve(key, entry, home2, secret) {
+  const type = entry.type;
+  const command = entry.command;
+  const remote = type === "http" || type === "sse" || type === "ws" || type === void 0 && typeof command !== "string";
+  if (remote) {
+    const url2 = entry.url;
+    if (typeof url2 !== "string") return null;
+    const name = remoteName(url2);
+    if (name === null) return null;
+    const launch2 = { url: url2 };
+    return { key, source: "remote", name, version: null, local: url2, launch: launch2 };
+  }
+  if (type !== void 0 && type !== "stdio") return null;
+  const args = entry.args === void 0 ? [] : entry.args;
+  if (typeof command !== "string" || command === "" || !isStrings(args)) return null;
+  const launch = { command: [command, ...args] };
+  const local = [command, ...args].join(" ");
+  const found = packageOf(command, args);
+  if (found !== null) return { key, ...found, local, launch };
+  if (registryRunner(command, args)) return null;
+  return { key, source: "local", name: localName(command, args, home2, secret), version: null, local, launch };
+}
+function oneLineName(value) {
+  return value.length >= 1 && value.length <= 214 && !/\s/.test(value) && !CONTROL.test(value);
+}
+function reportable(r) {
+  if (!SOURCES.has(r.source) || !oneLineName(r.name)) return false;
+  if (r.version !== null && (r.version.length < 1 || r.version.length > 64 || /\s/.test(r.version) || CONTROL.test(r.version))) return false;
+  if (r.source === "remote" && (/[?#@]/.test(r.name) || r.name.includes("://"))) return false;
+  if (r.source === "npm" && !NPM_NAME.test(r.name)) return false;
+  if (r.source === "pypi" && !PYPI_NAME.test(r.name)) return false;
+  if (r.source === "local" && !LOCAL_NAME.test(r.name)) return false;
+  return reducedKey(r.key) !== "";
+}
+var LOCAL_NAME = /^[A-Za-z0-9._-]{1,200}#[0-9a-f]{12}$/;
+function byKey(a, b) {
+  return a < b ? -1 : a > b ? 1 : 0;
+}
+function finished(servers) {
+  const counts = /* @__PURE__ */ new Map();
+  for (const s of servers) counts.set(s.key, (counts.get(s.key) ?? 0) + 1);
+  return servers.filter((s) => counts.get(s.key) === 1).sort((a, b) => byKey(a.key, b.key)).slice(0, SERVERS_AT_MOST);
+}
+var sent = (r, key) => ({ key, source: r.source, name: r.name, version: r.version });
+function reportedAll(folders) {
+  const byReduced = /* @__PURE__ */ new Map();
+  for (const { folder, servers } of folders) {
+    for (const r of servers.filter(reportable)) {
+      const key = reducedKey(r.key);
+      byReduced.set(key, [...byReduced.get(key) ?? [], { folder, r }]);
+    }
+  }
+  const out = [];
+  for (const [key, held] of byReduced) {
+    const [first] = held;
+    const same2 = held.every(({ r }) => r.source === first.r.source && r.name === first.r.name && r.version === first.r.version);
+    if (same2) out.push(sent(first.r, key));
+    else for (const { folder, r } of held) out.push(sent(r, suffixedKey(key, folder)));
+  }
+  return finished(out);
+}
+function isObject3(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function readJson(file) {
+  let text;
+  try {
+    text = (0, import_node_fs5.readFileSync)(file, "utf8");
+  } catch (error) {
+    return error.code === "ENOENT" ? void 0 : null;
+  }
+  try {
+    const value = JSON.parse(text.replace(/^\ufeff/, ""));
+    return isObject3(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function serversOf(holder) {
+  if (holder === null) return null;
+  if (holder === void 0 || holder.mcpServers === void 0) return void 0;
+  return isObject3(holder.mcpServers) ? holder.mcpServers : null;
+}
+function claudeCodeScopes(home2, cwd) {
+  const claude = readJson((0, import_node_path5.join)(home2, ".claude.json"));
+  let project;
+  if (claude === null) project = null;
+  else if (claude !== void 0 && claude.projects !== void 0) {
+    const projects = claude.projects;
+    if (!isObject3(projects)) project = null;
+    else {
+      const trimmed = cwd.replace(/[\\/]+$/, "");
+      const forms = [cwd, cwd.replace(/\\/g, "/"), ...trimmed === "" ? [] : [trimmed, trimmed.replace(/\\/g, "/")]];
+      const held = forms.map((form) => projects[form]).find((value) => value !== void 0);
+      project = held === void 0 ? void 0 : isObject3(held) ? held : null;
+    }
+  }
+  return [
+    { label: "~/.claude.json (this project)", servers: serversOf(project) },
+    { label: ".mcp.json", servers: serversOf(readJson((0, import_node_path5.join)(cwd, ".mcp.json"))) },
+    { label: "~/.claude.json", servers: serversOf(claude) }
+  ];
+}
+function unnameable(entry) {
+  if (!isObject3(entry) || entry.type !== void 0 && entry.type !== "stdio") return false;
+  const args = entry.args === void 0 ? [] : entry.args;
+  return typeof entry.command === "string" && entry.command !== "" && isStrings(args) && registryRunner(entry.command, args);
+}
+function resolveConfiguration(home2, cwd, secret, scopes4 = claudeCodeScopes(home2, cwd)) {
+  const notes = [];
+  const entries = /* @__PURE__ */ new Map();
+  let complete = true;
+  for (const scope of scopes4) {
+    if (scope.servers === null) {
+      notes.push(`${scope.label} could not be read: its servers, and those of every scope below it, are not checked`);
+      complete = false;
+      break;
+    }
+    for (const [key, entry] of Object.entries(scope.servers ?? {})) if (!entries.has(key)) entries.set(key, entry);
+  }
+  const resolved = [];
+  for (const [key, entry] of entries) {
+    const shown = reducedKey(key) || "(empty)";
+    if (key.includes("__") || reducedKey(key) === "") {
+      notes.push(`the server "${shown}" is not checked: its key cannot name one server`);
+      continue;
+    }
+    const r = isObject3(entry) ? resolve(key, entry, home2, secret) : null;
+    if (r === null && unnameable(entry)) notes.push(`the server is not checked: its package could not be named: ${shown}`);
+    else if (r === null) notes.push(`the server "${shown}" is not checked: neither a command nor an address`);
+    else if (!reportable(r)) notes.push(`the server "${shown}" is not checked: its name is not one the device API takes`);
+    else resolved.push(r);
+  }
+  const counts = /* @__PURE__ */ new Map();
+  for (const r of resolved) counts.set(reducedKey(r.key), (counts.get(reducedKey(r.key)) ?? 0) + 1);
+  const unique = resolved.filter((r) => {
+    if (counts.get(reducedKey(r.key)) === 1) return true;
+    notes.push(`the server "${reducedKey(r.key)}" is not checked: two keys reduce to the same string`);
+    return false;
+  });
+  unique.sort((a, b) => byKey(reducedKey(a.key), reducedKey(b.key)));
+  if (unique.length > SERVERS_AT_MOST) {
+    notes.push(`${unique.length} servers: the first ${SERVERS_AT_MOST} by key are checked, the rest are not`);
+  }
+  return { resolved: unique.slice(0, SERVERS_AT_MOST), notes, complete };
+}
+
+// src/adapters/claude-code.ts
+var PREFIX = "mcp__";
+function serverKeyOf(toolName) {
+  if (!toolName.startsWith(PREFIX)) return null;
+  const rest = toolName.slice(PREFIX.length);
+  const end = rest.indexOf("__");
+  if (end <= 0 || end + 2 >= rest.length) return null;
+  return rest.slice(0, end);
+}
+function isObject4(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse(_event, stdinText) {
+  let input;
+  try {
+    input = JSON.parse(stdinText);
+  } catch {
+    return { kind: "unreadable" };
+  }
+  if (!isObject4(input) || typeof input.tool_name !== "string") return { kind: "unreadable" };
+  if (typeof input.cursor_version === "string") return { kind: "other" };
+  const server = isObject4(input.mcp_server) ? input.mcp_server : null;
+  const parsed = serverKeyOf(input.tool_name);
+  if (parsed === null) return server === null ? { kind: "other" } : { kind: "unreadable" };
+  const key = typeof server?.name === "string" && server.name !== "" ? server.name : parsed;
+  const plugin = server !== null ? server.source === "plugin" : input.tool_name.startsWith(`${PREFIX}plugin_`);
+  return {
+    kind: "mcp",
+    key,
+    plugin,
+    sessionId: typeof input.session_id === "string" ? input.session_id : void 0,
+    cwd: typeof input.cwd === "string" ? input.cwd : void 0
+  };
+}
+function deny2(_event, verdict) {
+  const output = { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: verdict.reason } };
+  return { stdout: `${JSON.stringify(output)}
+`, exitCode: 0 };
+}
+var allow = () => ({ stdout: "", exitCode: 0 });
+var claudeCode = {
+  name: "claude-code",
+  client: "Claude Code",
+  events: ["PreToolUse", "SessionStart"],
+  parse,
+  deny: deny2,
+  allow,
+  scopes: claudeCodeScopes,
+  // Claude Code's own deny form: deniedMcpServers in ~/.claude/settings.json (denies.ts).
+  writeDenies: (resolved, policy, written, takeBack, elsewhere) => writeDenies("claude-code", (0, import_node_path6.join)(home(), ".claude", "settings.json"), resolved, policy, written, takeBack, elsewhere),
+  // Installed by plugin (D8), not by a file the hook writes.
+  install: () => ({ commands: installCommands().split("\n").map((line) => line.trim()).filter((line) => line !== "") })
+};
+
+// src/adapters/codex.ts
+var import_node_fs6 = require("node:fs");
+var import_node_path7 = require("node:path");
+
+// src/toml.ts
+function isObject5(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+var Fail = class extends Error {
+};
+function unescape(text) {
+  return text.replace(/\\(u[0-9A-Fa-f]{4}|U[0-9A-Fa-f]{8}|.)/g, (_m, e) => {
+    switch (e[0]) {
+      case "n":
+        return "\n";
+      case "t":
+        return "	";
+      case "r":
+        return "\r";
+      case "b":
+        return "\b";
+      case "f":
+        return "\f";
+      case '"':
+        return '"';
+      case "\\":
+        return "\\";
+      case "u":
+      case "U":
+        return String.fromCodePoint(parseInt(e.slice(1), 16));
+      default:
+        throw new Fail("escape");
+    }
+  });
+}
+var Reader = class {
+  constructor(text) {
+    this.text = text;
+  }
+  text;
+  skipSpace(at) {
+    while (at < this.text.length && (this.text[at] === " " || this.text[at] === "	")) at++;
+    return at;
+  }
+  // One key segment: bare, or quoted (basic or literal).
+  key(at) {
+    const t = this.text;
+    if (t[at] === '"') return this.basicString(at);
+    if (t[at] === "'") return this.literalString(at);
+    let end = at;
+    while (end < t.length && /[A-Za-z0-9_-]/.test(t[end])) end++;
+    if (end === at) throw new Fail("key");
+    return [t.slice(at, end), end];
+  }
+  // A dotted key: segments separated by dots, spaces allowed around them.
+  dottedKey(at) {
+    const parts = [];
+    let i = at;
+    for (; ; ) {
+      i = this.skipSpace(i);
+      const [part, end] = this.key(i);
+      parts.push(part);
+      i = this.skipSpace(end);
+      if (this.text[i] !== ".") return [parts, i];
+      i++;
+    }
+  }
+  basicString(at) {
+    const t = this.text;
+    if (t.startsWith('"""', at)) throw new Fail("multi-line");
+    let i = at + 1;
+    while (i < t.length && t[i] !== '"') {
+      if (t[i] === "\n") throw new Fail("newline in string");
+      i += t[i] === "\\" ? 2 : 1;
+    }
+    if (i >= t.length) throw new Fail("unterminated");
+    return [unescape(t.slice(at + 1, i)), i + 1];
+  }
+  literalString(at) {
+    const t = this.text;
+    if (t.startsWith("'''", at)) throw new Fail("multi-line");
+    const end = t.indexOf("'", at + 1);
+    if (end === -1 || t.slice(at + 1, end).includes("\n")) throw new Fail("unterminated");
+    return [t.slice(at + 1, end), end + 1];
+  }
+  value(at) {
+    const t = this.text;
+    const c = t[at];
+    if (c === '"') return this.basicString(at);
+    if (c === "'") return this.literalString(at);
+    if (c === "[") return this.array(at);
+    if (c === "{") return this.inlineTable(at);
+    const word = /^(true|false|[+-]?(?:0|[1-9](?:_?[0-9])*)(?:\.[0-9](?:_?[0-9])*)?(?:[eE][+-]?[0-9]+)?)(?=[\s,\]}#]|$)/.exec(t.slice(at));
+    if (word === null) throw new Fail("value");
+    const w = word[1];
+    const value = w === "true" ? true : w === "false" ? false : Number(w.replace(/_/g, ""));
+    if (typeof value === "number" && !Number.isFinite(value)) throw new Fail("number");
+    return [value, at + w.length];
+  }
+  // Whitespace, newlines and comments inside an array.
+  skipInArray(at) {
+    const t = this.text;
+    for (; ; ) {
+      while (at < t.length && /[ \t\r\n]/.test(t[at])) at++;
+      if (t[at] === "#") {
+        while (at < t.length && t[at] !== "\n") at++;
+      } else return at;
+    }
+  }
+  array(at) {
+    const t = this.text;
+    const out = [];
+    let i = at + 1;
+    for (; ; ) {
+      i = this.skipInArray(i);
+      if (i >= t.length) throw new Fail("unterminated array");
+      if (t[i] === "]") return [out, i + 1];
+      const [value, end] = this.value(i);
+      out.push(value);
+      i = this.skipInArray(end);
+      if (t[i] === ",") i++;
+      else if (t[i] !== "]") throw new Fail("array");
+    }
+  }
+  inlineTable(at) {
+    const t = this.text;
+    const out = {};
+    let i = this.skipSpace(at + 1);
+    if (t[i] === "}") return [out, i + 1];
+    for (; ; ) {
+      const [parts, afterKey] = this.dottedKey(i);
+      if (t[afterKey] !== "=") throw new Fail("inline table");
+      const [value, end] = this.value(this.skipSpace(afterKey + 1));
+      assign(out, parts, value);
+      i = this.skipSpace(end);
+      if (t[i] === ",") i = this.skipSpace(i + 1);
+      else if (t[i] === "}") return [out, i + 1];
+      else throw new Fail("inline table");
+    }
+  }
+};
+function assign(table, parts, value) {
+  let here = table;
+  for (const part of parts.slice(0, -1)) {
+    const next = here[part];
+    if (next === void 0) {
+      const made = {};
+      here[part] = made;
+      here = made;
+    } else if (isObject5(next)) here = next;
+    else throw new Fail("key reused");
+  }
+  const last = parts[parts.length - 1];
+  if (Object.hasOwn(here, last)) throw new Fail("key defined twice");
+  here[last] = value;
+}
+function tableAt(root, parts) {
+  let here = root;
+  for (const part of parts) {
+    const next = here[part];
+    if (next === void 0) {
+      const made = {};
+      here[part] = made;
+      here = made;
+    } else if (isObject5(next)) here = next;
+    else throw new Fail("table reused");
+  }
+  return here;
+}
+function parseToml(input) {
+  const text = input.replace(/^/, "");
+  try {
+    const root = {};
+    let current = root;
+    const reader = new Reader(text);
+    let pos = 0;
+    while (pos < text.length) {
+      let lineEnd = text.indexOf("\n", pos);
+      if (lineEnd === -1) lineEnd = text.length;
+      const line = text.slice(pos, lineEnd).replace(/\r$/, "");
+      const trimmed = line.trim();
+      if (trimmed === "" || trimmed.startsWith("#")) {
+        pos = lineEnd + 1;
+        continue;
+      }
+      if (trimmed.startsWith("[[")) throw new Fail("array table");
+      if (trimmed.startsWith("[")) {
+        const close = trimmed.lastIndexOf("]");
+        const rest = trimmed.slice(close + 1).trim();
+        if (close === -1 || rest !== "" && !rest.startsWith("#")) throw new Fail("table header");
+        const header = trimmed.slice(1, close);
+        const inner = new Reader(header);
+        const [parts2, end2] = inner.dottedKey(0);
+        if (inner.skipSpace(end2) !== header.length) throw new Fail("table header");
+        current = tableAt(root, parts2);
+        pos = lineEnd + 1;
+        continue;
+      }
+      const [parts, afterKey] = reader.dottedKey(pos);
+      if (text[afterKey] !== "=") throw new Fail("assignment");
+      const [value, end] = reader.value(reader.skipSpace(afterKey + 1));
+      let tailEnd = text.indexOf("\n", end);
+      if (tailEnd === -1) tailEnd = text.length;
+      const tail = text.slice(end, tailEnd).replace(/\r$/, "").trim();
+      if (tail !== "" && !tail.startsWith("#")) throw new Fail("trailing");
+      assign(current, parts, value);
+      pos = tailEnd + 1;
+    }
+    return root;
+  } catch (error) {
+    if (error instanceof Fail) return null;
+    throw error;
+  }
+}
+
+// src/adapters/codex.ts
+var PREFIX2 = "mcp__";
+var TIMEOUT_S = 10;
+var COPY = (0, import_node_path7.join)(".attestari", "hook.js");
+var STATUS = "Attestari is checking this MCP call";
+function isObject6(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function sanitized(key) {
+  return key.replace(/[^A-Za-z0-9_]/g, "_");
+}
+function parse2(_event, stdinText) {
+  let input;
+  try {
+    input = JSON.parse(stdinText);
+  } catch {
+    return { kind: "unreadable" };
+  }
+  if (!isObject6(input) || typeof input.tool_name !== "string") return { kind: "unreadable" };
+  const name = input.tool_name;
+  if (!name.startsWith(PREFIX2)) return { kind: "other" };
+  const rest = name.slice(PREFIX2.length);
+  if (rest === "" || !rest.includes("__")) return { kind: "unreadable" };
+  return {
+    kind: "mcp",
+    key: rest,
+    shown: rest.slice(0, rest.indexOf("__")),
+    plugin: false,
+    sessionId: typeof input.session_id === "string" ? input.session_id : void 0,
+    cwd: typeof input.cwd === "string" ? input.cwd : void 0
+  };
+}
+function matches2(parsedKey, configuredKey) {
+  const head = `${sanitized(configuredKey)}__`;
+  return parsedKey.startsWith(head) && parsedKey.length > head.length;
+}
+function deny3(_event, verdict) {
+  const output = { hookSpecificOutput: { hookEventName: "PreToolUse", permissionDecision: "deny", permissionDecisionReason: verdict.reason } };
+  return { stdout: `${JSON.stringify(output)}
+`, exitCode: 0 };
+}
+var allow2 = () => ({ stdout: "", exitCode: 0 });
+function serversOfToml(file) {
+  let text;
+  try {
+    text = (0, import_node_fs6.readFileSync)(file, "utf8");
+  } catch (error) {
+    return error.code === "ENOENT" ? void 0 : null;
+  }
+  const table = parseToml(text);
+  if (table === null) return null;
+  const servers = table.mcp_servers;
+  if (servers === void 0) return void 0;
+  if (!isObject6(servers)) return null;
+  const live = {};
+  for (const [key, entry] of Object.entries(servers)) if (!(isObject6(entry) && entry.enabled === false)) live[key] = entry;
+  return live;
+}
+function scopes(home2, cwd) {
+  return [
+    { label: "~/.codex/managed_config.toml", servers: serversOfToml((0, import_node_path7.join)(home2, ".codex", "managed_config.toml")) },
+    { label: ".codex/config.toml", servers: serversOfToml((0, import_node_path7.join)(cwd, ".codex", "config.toml")) },
+    { label: "~/.codex/config.toml", servers: serversOfToml((0, import_node_path7.join)(home2, ".codex", "config.toml")) }
+  ];
+}
+function quoted(path) {
+  return /[\s"]/.test(path) ? `"${path.replace(/"/g, '\\"')}"` : path;
+}
+function hookCommands(node, hook2) {
+  return {
+    preToolUse: `${quoted(node)} ${quoted(hook2)} codex pre-tool-use`,
+    sessionStart: `${quoted(node)} ${quoted(hook2)} codex session-start`
+  };
+}
+var MINE = /attestari.*\bcodex (pre-tool-use|session-start)\b/;
+function isMine(handler) {
+  return isObject6(handler) && typeof handler.command === "string" && MINE.test(handler.command);
+}
+function withHandler(groups, matcher, handler) {
+  const current = Array.isArray(groups) ? groups : [];
+  const cleaned = current.map((g) => isObject6(g) && Array.isArray(g.hooks) ? { ...g, hooks: g.hooks.filter((h) => !isMine(h)) } : g).filter((g) => !(isObject6(g) && Array.isArray(g.hooks) && g.hooks.length === 0));
+  const at = cleaned.findIndex((g) => isObject6(g) && g.matcher === matcher && Array.isArray(g.hooks));
+  if (at === -1) return [...cleaned, matcher === void 0 ? { hooks: [handler] } : { matcher, hooks: [handler] }];
+  const group = cleaned[at];
+  cleaned[at] = { ...group, hooks: [...group.hooks, handler] };
+  return cleaned;
+}
+function install(home2, hookFile = __filename, node = process.execPath) {
+  const copy = (0, import_node_path7.join)(home2, COPY);
+  (0, import_node_fs6.mkdirSync)((0, import_node_path7.join)(home2, ".attestari"), { recursive: true });
+  (0, import_node_fs6.copyFileSync)(hookFile, copy);
+  const commands = hookCommands(node, copy);
+  const file = (0, import_node_path7.join)(home2, ".codex", "hooks.json");
+  const read = bytesOf(file);
+  const text = read === null ? null : read.toString("utf8");
+  let settings = {};
+  if (text !== null) {
+    try {
+      settings = JSON.parse(text.replace(/^/, ""));
+    } catch {
+      throw new Error(`${file} could not be read as Codex's hooks file; the hook was not installed`);
+    }
+  }
+  if (!isObject6(settings) || settings.hooks !== void 0 && !isObject6(settings.hooks)) {
+    throw new Error(`${file} is not Codex's hooks file; the hook was not installed`);
+  }
+  const hooks = isObject6(settings.hooks) ? settings.hooks : {};
+  const next = {
+    ...settings,
+    hooks: {
+      ...hooks,
+      PreToolUse: withHandler(hooks.PreToolUse, "^mcp__", { type: "command", command: commands.preToolUse, timeout: TIMEOUT_S, statusMessage: STATUS }),
+      SessionStart: withHandler(hooks.SessionStart, void 0, { type: "command", command: commands.sessionStart, timeout: TIMEOUT_S })
+    }
+  };
+  const after = formatLike(text, next);
+  if (text !== after) {
+    (0, import_node_fs6.mkdirSync)((0, import_node_path7.join)(home2, ".codex"), { recursive: true });
+    if (!writeBeside(file, after, modeOf(file, text), read)) throw new Error(`${file} changed while the hook was installed; run the install again`);
+  }
+  return { path: file, before: text, after };
+}
+var codex = {
+  name: "codex",
+  client: "Codex",
+  events: ["PreToolUse", "SessionStart"],
+  parse: parse2,
+  matches: matches2,
+  deny: deny3,
+  allow: allow2,
+  scopes,
+  // Codex's own deny form would be `enabled = false` in the person's server table: not written. The hook decides.
+  install
+};
+
+// src/adapters/cursor.ts
+var import_node_fs7 = require("node:fs");
+var import_node_path8 = require("node:path");
+
+// src/jsonc.ts
+function stripJsonc(text) {
+  let out = "";
+  let i = 0;
+  const n = text.length;
+  while (i < n) {
+    const c = text[i];
+    if (c === '"') {
+      let j = i + 1;
+      while (j < n && text[j] !== '"') j += text[j] === "\\" ? 2 : 1;
+      out += text.slice(i, j + 1);
+      i = j + 1;
+    } else if (c === "/" && text[i + 1] === "/") {
+      while (i < n && text[i] !== "\n") i++;
+    } else if (c === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2);
+      i = end === -1 ? n : end + 2;
+    } else if (c === ",") {
+      let j = i + 1;
+      for (; ; ) {
+        while (j < n && /\s/.test(text[j])) j++;
+        if (text[j] === "/" && text[j + 1] === "/") {
+          while (j < n && text[j] !== "\n") j++;
+        } else if (text[j] === "/" && text[j + 1] === "*") {
+          const end = text.indexOf("*/", j + 2);
+          j = end === -1 ? n : end + 2;
+        } else break;
+      }
+      if (text[j] === "}" || text[j] === "]") i++;
+      else out += text[i++];
+    } else {
+      out += text[i++];
+    }
+  }
+  return out;
+}
+function parseJsonc(text) {
+  return JSON.parse(stripJsonc(text.replace(/^/, "")));
+}
+
+// src/adapters/cursor.ts
+var TIMEOUT_S2 = 10;
+var COPY2 = (0, import_node_path8.join)(".attestari", "hook.js");
+function isObject7(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function isStrings2(value) {
+  return Array.isArray(value) && value.every((v) => typeof v === "string");
+}
+function parse3(_event, stdinText) {
+  let input;
+  try {
+    input = JSON.parse(stdinText);
+  } catch {
+    return { kind: "unreadable" };
+  }
+  if (!isObject7(input)) return { kind: "unreadable" };
+  const key = input.mcp_server_name;
+  if (typeof key !== "string" || key === "") return { kind: "unreadable" };
+  const roots = isStrings2(input.workspace_roots) ? input.workspace_roots : [];
+  return {
+    kind: "mcp",
+    key,
+    plugin: false,
+    sessionId: typeof input.conversation_id === "string" ? input.conversation_id : void 0,
+    cwd: roots.length > 0 && roots[0] !== "" ? roots[0] : void 0
+  };
+}
+function deny4(_event, verdict) {
+  return { stdout: `${JSON.stringify({ permission: "deny", user_message: verdict.reason, agent_message: verdict.reason })}
+`, exitCode: 0 };
+}
+var allow3 = () => ({ stdout: `${JSON.stringify({ permission: "allow" })}
+`, exitCode: 0 });
+function readCursorJson(file) {
+  let text;
+  try {
+    text = (0, import_node_fs7.readFileSync)(file, "utf8");
+  } catch (error) {
+    return error.code === "ENOENT" ? void 0 : null;
+  }
+  try {
+    const value = parseJsonc(text);
+    return isObject7(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function serversOf2(holder) {
+  if (holder === null) return null;
+  if (holder === void 0 || holder.mcpServers === void 0) return void 0;
+  return isObject7(holder.mcpServers) ? holder.mcpServers : null;
+}
+function scopes2(home2, cwd) {
+  return [
+    { label: ".cursor/mcp.json", servers: serversOf2(readCursorJson((0, import_node_path8.join)(cwd, ".cursor", "mcp.json"))) },
+    { label: "~/.cursor/mcp.json", servers: serversOf2(readCursorJson((0, import_node_path8.join)(home2, ".cursor", "mcp.json"))) }
+  ];
+}
+var denyToken = (key) => `Mcp(${key}:*)`;
+function cursorDenyForms(resolved, policy) {
+  const keys = resolved.filter((r) => entryFor(policy, r)?.decision === "block").map((r) => denyToken(r.key));
+  return [...new Set(keys.map((k) => JSON.stringify(k)))];
+}
+function writeDenies2(resolved, policy, written, takeBack, elsewhere) {
+  return writeDenyList(
+    (0, import_node_path8.join)(home(), ".cursor", "cli-config.json"),
+    (settings) => {
+      const permissions = settings.permissions;
+      if (permissions === void 0) return void 0;
+      if (!isObject7(permissions)) return null;
+      if (permissions.deny === void 0) return void 0;
+      return Array.isArray(permissions.deny) ? permissions.deny : null;
+    },
+    (settings, list) => ({ ...settings, permissions: { ...isObject7(settings.permissions) ? settings.permissions : {}, deny: list } }),
+    cursorDenyForms(resolved, policy),
+    written,
+    takeBack,
+    elsewhere
+  );
+}
+function quoted2(path) {
+  return /[\s"]/.test(path) ? `"${path.replace(/"/g, '\\"')}"` : path;
+}
+function hookCommands2(node, hook2) {
+  return {
+    preToolUse: `${quoted2(node)} ${quoted2(hook2)} cursor pre-tool-use`,
+    sessionStart: `${quoted2(node)} ${quoted2(hook2)} cursor session-start`
+  };
+}
+var MINE2 = /attestari.*\bcursor (pre-tool-use|session-start)\b/;
+function withEntry(list, entry) {
+  const current = Array.isArray(list) ? list : [];
+  const others = current.filter((e) => !(isObject7(e) && typeof e.command === "string" && MINE2.test(e.command)));
+  return [...others, entry];
+}
+function install2(home2, hookFile = __filename, node = process.execPath) {
+  const copy = (0, import_node_path8.join)(home2, COPY2);
+  (0, import_node_fs7.mkdirSync)((0, import_node_path8.join)(home2, ".attestari"), { recursive: true });
+  (0, import_node_fs7.copyFileSync)(hookFile, copy);
+  const commands = hookCommands2(node, copy);
+  const file = (0, import_node_path8.join)(home2, ".cursor", "hooks.json");
+  const read = bytesOf(file);
+  const text = read === null ? null : read.toString("utf8");
+  let settings = {};
+  if (text !== null) {
+    try {
+      settings = parseJsonc(text);
+    } catch {
+      throw new Error(`${file} could not be read as Cursor's hooks file; the hook was not installed`);
+    }
+  }
+  if (!isObject7(settings)) throw new Error(`${file} is not Cursor's hooks file; the hook was not installed`);
+  const hooks = isObject7(settings.hooks) ? settings.hooks : {};
+  const next = {
+    ...settings,
+    version: typeof settings.version === "number" ? settings.version : 1,
+    hooks: {
+      ...hooks,
+      beforeMCPExecution: withEntry(hooks.beforeMCPExecution, { command: commands.preToolUse, timeout: TIMEOUT_S2, failClosed: true }),
+      sessionStart: withEntry(hooks.sessionStart, { command: commands.sessionStart, timeout: TIMEOUT_S2 })
+    }
+  };
+  const after = formatLike(text, next);
+  if (text !== after) {
+    (0, import_node_fs7.mkdirSync)((0, import_node_path8.join)(home2, ".cursor"), { recursive: true });
+    if (!writeBeside(file, after, modeOf(file, text), read)) throw new Error(`${file} changed while the hook was installed; run the install again`);
+  }
+  return { path: file, before: text, after };
+}
+var cursor = {
+  name: "cursor",
+  client: "Cursor",
+  events: ["beforeMCPExecution", "sessionStart"],
+  parse: parse3,
+  deny: deny4,
+  allow: allow3,
+  scopes: scopes2,
+  writeDenies: writeDenies2,
+  install: install2
+};
+
+// src/adapters/gemini.ts
+var import_node_fs8 = require("node:fs");
+var import_node_path9 = require("node:path");
+var PREFIX3 = "mcp_";
+var TIMEOUT_MS2 = 1e4;
+var COPY3 = (0, import_node_path9.join)(".attestari", "hook.js");
+var HANDLER = "attestari";
+var SESSION_HANDLER = "attestari-session";
+function isObject8(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function parse4(_event, stdinText) {
+  let input;
+  try {
+    input = JSON.parse(stdinText);
+  } catch {
+    return { kind: "unreadable" };
+  }
+  if (!isObject8(input) || typeof input.tool_name !== "string") return { kind: "unreadable" };
+  const context = isObject8(input.mcp_context) ? input.mcp_context : null;
+  if (context === null) return input.tool_name.startsWith(PREFIX3) ? { kind: "unreadable" } : { kind: "other" };
+  const key = context.server_name;
+  if (typeof key !== "string" || key === "") return { kind: "unreadable" };
+  return {
+    kind: "mcp",
+    key,
+    plugin: false,
+    sessionId: typeof input.session_id === "string" ? input.session_id : void 0,
+    cwd: typeof input.cwd === "string" ? input.cwd : void 0
+  };
+}
+function deny5(_event, verdict) {
+  return { stdout: `${JSON.stringify({ decision: "deny", reason: verdict.reason })}
+`, exitCode: 0 };
+}
+var allow4 = () => ({ stdout: "", exitCode: 0 });
+function geminiEntry(entry) {
+  if (!isObject8(entry)) return entry;
+  const address = typeof entry.httpUrl === "string" ? entry.httpUrl : typeof entry.url === "string" ? entry.url : null;
+  if (address === null) return entry;
+  const { command: _c, args: _a, httpUrl: _h, url: _u, type: _t, ...rest } = entry;
+  return { ...rest, type: "http", url: address };
+}
+function serversOf3(holder) {
+  if (holder === null) return null;
+  if (holder === void 0 || holder.mcpServers === void 0) return void 0;
+  if (!isObject8(holder.mcpServers)) return null;
+  return Object.fromEntries(Object.entries(holder.mcpServers).map(([key, entry]) => [key, geminiEntry(entry)]));
+}
+function systemSettingsPath(platform2 = process.platform, env = process.env) {
+  if (env.GEMINI_CLI_SYSTEM_SETTINGS_PATH) return env.GEMINI_CLI_SYSTEM_SETTINGS_PATH;
+  if (platform2 === "win32") return import_node_path9.win32.join(env.ProgramData ?? "C:\\ProgramData", "gemini-cli", "settings.json");
+  if (platform2 === "darwin") return "/Library/Application Support/GeminiCli/settings.json";
+  return "/etc/gemini-cli/settings.json";
+}
+function scopes3(home2, cwd) {
+  return [
+    { label: "the system settings.json", servers: serversOf3(readJson(systemSettingsPath())) },
+    { label: ".gemini/settings.json", servers: serversOf3(readJson((0, import_node_path9.join)(cwd, ".gemini", "settings.json"))) },
+    { label: "~/.gemini/settings.json", servers: serversOf3(readJson((0, import_node_path9.join)(home2, ".gemini", "settings.json"))) }
+  ];
+}
+function geminiDenyForms(resolved, policy) {
+  const keys = resolved.filter((r) => entryFor(policy, r)?.decision === "block").map((r) => r.key);
+  return [...new Set(keys.map((k) => JSON.stringify(k)))];
+}
+function writeDenies3(resolved, policy, written, takeBack, elsewhere) {
+  return writeDenyList(
+    (0, import_node_path9.join)(home(), ".gemini", "settings.json"),
+    (settings) => {
+      const mcp = settings.mcp;
+      if (mcp === void 0) return void 0;
+      if (!isObject8(mcp)) return null;
+      if (mcp.excluded === void 0) return void 0;
+      return Array.isArray(mcp.excluded) ? mcp.excluded : null;
+    },
+    (settings, list) => ({ ...settings, mcp: { ...isObject8(settings.mcp) ? settings.mcp : {}, excluded: list } }),
+    geminiDenyForms(resolved, policy),
+    written,
+    takeBack,
+    elsewhere
+  );
+}
+function quoted3(path) {
+  return /[\s"]/.test(path) ? `"${path}"` : path;
+}
+var LAUNCHER = (0, import_node_path9.join)(".attestari", "gemini-hook.cmd");
+function geminiShell(platform2 = process.platform, env = process.env) {
+  if (platform2 !== "win32") return "sh";
+  const comSpec = (env.ComSpec ?? "").toLowerCase();
+  if (comSpec.endsWith("powershell.exe") || comSpec.endsWith("pwsh.exe")) return "powershell";
+  return findOnPath("pwsh", env.PATH ?? "", true) !== null ? "powershell" : "cmd";
+}
+function hookCommands3(node, hook2, shell, launcher) {
+  const program = shell === "sh" || launcher === void 0 ? `${quoted3(node)} ${quoted3(hook2)}` : quoted3(launcher);
+  const call = shell === "powershell" && program.startsWith('"') ? `& ${program}` : program;
+  return { preToolUse: `${call} gemini pre-tool-use`, sessionStart: `${call} gemini session-start` };
+}
+function launcherText(node, hook2) {
+  return `@"${node}" "${hook2}" %*\r
+`;
+}
+function isMine2(handler) {
+  return isObject8(handler) && (handler.name === HANDLER || handler.name === SESSION_HANDLER || typeof handler.command === "string" && /attestari.*\bgemini (pre-tool-use|session-start)\b/.test(handler.command));
+}
+function withHandler2(groups, matcher, handler) {
+  const current = Array.isArray(groups) ? groups : [];
+  const cleaned = current.map((g) => isObject8(g) && Array.isArray(g.hooks) ? { ...g, hooks: g.hooks.filter((h) => !isMine2(h)) } : g).filter((g) => !(isObject8(g) && Array.isArray(g.hooks) && g.hooks.length === 0));
+  const at = cleaned.findIndex((g) => isObject8(g) && g.matcher === matcher && Array.isArray(g.hooks));
+  if (at === -1) return [...cleaned, matcher === void 0 ? { hooks: [handler] } : { matcher, hooks: [handler] }];
+  const group = cleaned[at];
+  cleaned[at] = { ...group, hooks: [...group.hooks, handler] };
+  return cleaned;
+}
+function install3(home2, hookFile = __filename, node = process.execPath) {
+  const copy = (0, import_node_path9.join)(home2, COPY3);
+  (0, import_node_fs8.mkdirSync)((0, import_node_path9.join)(home2, ".attestari"), { recursive: true });
+  (0, import_node_fs8.copyFileSync)(hookFile, copy);
+  const shell = geminiShell();
+  let launcher;
+  if (shell !== "sh") {
+    launcher = (0, import_node_path9.join)(home2, LAUNCHER);
+    (0, import_node_fs8.writeFileSync)(launcher, launcherText(node, copy));
+  }
+  const commands = hookCommands3(node, copy, shell, launcher);
+  const file = (0, import_node_path9.join)(home2, ".gemini", "settings.json");
+  const read = bytesOf(file);
+  const text = read === null ? null : read.toString("utf8");
+  let settings = {};
+  if (text !== null) {
+    try {
+      settings = JSON.parse(text.replace(/^\ufeff/, ""));
+    } catch {
+      throw new Error(`${file} could not be read as Gemini CLI's settings file; the hook was not installed`);
+    }
+  }
+  if (!isObject8(settings) || settings.hooks !== void 0 && !isObject8(settings.hooks)) {
+    throw new Error(`${file} is not Gemini CLI's settings file; the hook was not installed`);
+  }
+  const hooks = isObject8(settings.hooks) ? settings.hooks : {};
+  const next = {
+    ...settings,
+    hooks: {
+      ...hooks,
+      BeforeTool: withHandler2(hooks.BeforeTool, "mcp_.*", { name: HANDLER, type: "command", command: commands.preToolUse, timeout: TIMEOUT_MS2, description: "Attestari checks the server before the call" }),
+      SessionStart: withHandler2(hooks.SessionStart, void 0, { name: SESSION_HANDLER, type: "command", command: commands.sessionStart, timeout: TIMEOUT_MS2 })
+    }
+  };
+  const after = formatLike(text, next);
+  if (text !== after) {
+    (0, import_node_fs8.mkdirSync)((0, import_node_path9.join)(home2, ".gemini"), { recursive: true });
+    if (!writeBeside(file, after, modeOf(file, text), read)) throw new Error(`${file} changed while the hook was installed; run the install again`);
+  }
+  return { path: file, before: text, after };
+}
+var gemini = {
+  name: "gemini",
+  client: "Gemini CLI",
+  events: ["BeforeTool", "SessionStart"],
+  parse: parse4,
+  deny: deny5,
+  allow: allow4,
+  scopes: scopes3,
+  writeDenies: writeDenies3,
+  install: install3
+};
+
+// src/adapters/registry.ts
+var ADAPTERS = /* @__PURE__ */ new Map([
+  [claudeCode.name, claudeCode],
+  [cursor.name, cursor],
+  [codex.name, codex],
+  [gemini.name, gemini]
+]);
+function adapterFor(name) {
+  return ADAPTERS.get(name) ?? null;
+}
+
+// src/session.ts
+var import_node_fs9 = require("node:fs");
+var import_node_os2 = require("node:os");
+
+// src/api.ts
+var import_node_http = require("node:http");
+var import_node_https = require("node:https");
+
+// src/version.ts
+var HOOK_VERSION = "2.9.1";
+
+// src/api.ts
+var timeoutMs = 1e4;
+var MAX_BODY_BYTES = 5 * 1024 * 1024;
+var ApiError = class extends Error {
+  status;
+  error;
+  retryAfterSeconds;
+  said;
+  constructor(status2, error, retryAfterSeconds = null, said = null) {
+    super(`${status2} ${error}`);
+    this.name = "ApiError";
+    this.status = status2;
+    this.error = error;
+    this.retryAfterSeconds = retryAfterSeconds;
+    this.said = said;
+  }
+};
+function send(url2, method, headers, body) {
+  return new Promise((resolve2, reject) => {
+    const unreachable = () => new ApiError(0, "unreachable");
+    let target;
+    try {
+      target = new URL(url2);
+    } catch {
+      reject(unreachable());
+      return;
+    }
+    const request = target.protocol === "https:" ? import_node_https.request : target.protocol === "http:" ? import_node_http.request : null;
+    if (request === null) {
+      reject(unreachable());
+      return;
+    }
+    const allHeaders = { Accept: "application/json", "User-Agent": `attestari-hook/${HOOK_VERSION}`, ...headers };
+    if (body !== null) {
+      allHeaders["Content-Type"] = "application/json";
+      allHeaders["Content-Length"] = String(Buffer.byteLength(body));
+    }
+    let settled = false;
+    const settle = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(deadline);
+      fn();
+    };
+    let req;
+    try {
+      req = request(target, { method, headers: allHeaders }, (res) => {
+        const chunks = [];
+        let size = 0;
+        res.on("data", (chunk) => {
+          size += chunk.length;
+          if (size > MAX_BODY_BYTES) {
+            settle(() => reject(new ApiError(res.statusCode ?? 0, "unexpected_response")));
+            req.destroy();
+            return;
+          }
+          chunks.push(chunk);
+        });
+        res.on("end", () => settle(() => resolve2({ status: res.statusCode ?? 0, headers: res.headers, text: Buffer.concat(chunks).toString("utf8") })));
+        res.on("error", () => settle(() => reject(unreachable())));
+      });
+    } catch {
+      reject(unreachable());
+      return;
+    }
+    const deadline = setTimeout(() => {
+      settle(() => reject(unreachable()));
+      req.destroy();
+    }, timeoutMs);
+    req.on("error", () => settle(() => reject(unreachable())));
+    req.end(body ?? void 0);
+  });
+}
+function parseObject(text) {
+  try {
+    const value = JSON.parse(text);
+    return typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function retryAfter(reply) {
+  const raw = reply.headers["retry-after"];
+  const value = Array.isArray(raw) ? raw[0] : raw;
+  if (value === void 0 || !/^\d+$/.test(value.trim())) return null;
+  return Number.parseInt(value.trim(), 10);
+}
+function failure(reply) {
+  const word = parseObject(reply.text)?.error;
+  const said = typeof word === "string" && word !== "" ? word : null;
+  if (reply.status === 401) return new ApiError(401, "invalid_token", null, said);
+  return new ApiError(reply.status, said ?? "unexpected_response", retryAfter(reply), said);
+}
+function ok(reply) {
+  if (reply.status !== 200) throw failure(reply);
+  const body = parseObject(reply.text);
+  if (body === null) throw new ApiError(reply.status, "unexpected_response");
+  return body;
+}
+function url(base, path) {
+  return `${base.replace(/\/+$/, "")}${path}`;
+}
+function bearer(token) {
+  return { Authorization: `Bearer ${token}` };
+}
+async function redeem(base, code, about) {
+  const body = JSON.stringify({ client_id: "attestari-hook", code, ...about });
+  const answer = ok(await send(url(base, "/v1/device/redeem"), "POST", {}, body));
+  const organization = answer.organization;
+  if (typeof answer.access_token !== "string" || answer.access_token === "" || typeof organization !== "object" || organization === null) {
+    throw new ApiError(200, "unexpected_response");
+  }
+  return { token: answer.access_token, organization };
+}
+async function checkin(base, token, body, etag) {
+  const headers = bearer(token);
+  if (etag !== null) headers["If-None-Match"] = etag;
+  const answer = ok(await send(url(base, "/v1/device/checkin"), "POST", headers, JSON.stringify(body)));
+  if (typeof answer.policy_version !== "number" || !(answer.compiled === null || isCompiled(answer.compiled))) {
+    throw new ApiError(200, "unexpected_response");
+  }
+  return { policy_version: answer.policy_version, compiled: answer.compiled };
+}
+
+// src/session.ts
+var EVENTS_AT_MOST = 200;
+var SESSION_MS = 30 * DAY_MS;
+var FOLDER_MS = 30 * DAY_MS;
+var PAIRING_LINE = "Attestari: this agent is not protected. Run `npx -y attestari@2.9 pair --code <code from app.attestari.ai/agents>`";
+var INVALID_CODE = "That code is not valid or has expired. Make a new one at app.attestari.ai/agents.";
+var TOKEN_REFUSED = "Pairing did not complete: Attestari refused the new token. Make a new code at app.attestari.ai/agents.";
+var PAIR_USAGE = "usage: attestari-hook pair --code <code> [--agent claude-code|cursor|codex|gemini]";
+var INSTALL_USAGE = "usage: attestari-hook install --agent claude-code|cursor|codex|gemini";
+var ACCOUNTS = "https://accounts.attestari.ai";
+var LOOPBACK = /* @__PURE__ */ new Set(["127.0.0.1", "[::1]", "localhost"]);
+function accountsBase() {
+  const wanted = process.env.ATTESTARI_ACCOUNTS_URL;
+  if (!wanted) return ACCOUNTS;
+  let host;
+  try {
+    host = new URL(wanted).hostname.toLowerCase();
+  } catch {
+    host = null;
+  }
+  if (host !== null && LOOPBACK.has(host)) return wanted;
+  say("ATTESTARI_ACCOUNTS_URL is ignored: only a loopback address (127.0.0.1, ::1, localhost) may replace accounts.attestari.ai");
+  return ACCOUNTS;
+}
+function isObject9(value) {
+  return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+function resolveAndKeep(adapter, cwd) {
+  const agent = adapter.name;
+  const { resolved, notes, complete } = resolveConfiguration(home(), cwd, readSecret(agent), adapter.scopes(home(), cwd));
+  for (const note of notes) say(note);
+  attempt("the resolution was not written", () => writeResolution(agent, cwd, resolved, complete));
+}
+function sessionStart(stdinText, adapter) {
+  const agent = adapter.name;
+  if (readToken(agent) === null) return { stdout: `${PAIRING_LINE}
+`, exitCode: 0 };
+  let input = null;
+  try {
+    input = JSON.parse(stdinText);
+  } catch {
+  }
+  const cwd = isObject9(input) && typeof input.cwd === "string" && input.cwd !== "" ? input.cwd : process.cwd();
+  attempt("the configuration was not resolved", () => resolveAndKeep(adapter, cwd));
+  if (isObject9(input) && typeof input.session_id === "string" && input.session_id !== "") {
+    const sessionId = input.session_id;
+    attempt("the session was not bound to its folder", () => writeSession(agent, sessionId, cwd));
+  }
+  attempt("the refresh was not started", () => {
+    if (!heldBack(agent, Date.now(), true)) spawnRefresh(agent, cwd);
+  });
+  return { stdout: "", exitCode: 0 };
+}
+function nextAt(agent, ms, word) {
+  attempt("next_refresh_at was not written", () => writeStamp(agent, "next_refresh_at", new Date(Date.now() + ms), word));
+}
+async function refresh(adapter, cwd) {
+  const agent = adapter.name;
+  const token = readToken(agent);
+  if (token === null) return null;
+  if (cwd !== void 0 && cwd !== "" && readResolution(agent, cwd) === null) {
+    try {
+      resolveAndKeep(adapter, cwd);
+    } catch (error) {
+      say(`the configuration was not resolved: ${message(error)}`);
+    }
+  }
+  try {
+    pruneSessions(agent, SESSION_MS);
+  } catch {
+  }
+  const now = Date.now();
+  const all = readResolutions(agent);
+  const stale = all.filter((r) => r.cwd !== void 0 && folderGone(r.cwd) || r.modifiedMs !== void 0 && now - r.modifiedMs > FOLDER_MS);
+  const resolutions = all.filter((r) => !stale.includes(r));
+  const held = readPolicy(agent);
+  const etag = held === null ? null : readEtag(agent);
+  let events = [];
+  try {
+    events = readEvents(agent).slice(0, EVENTS_AT_MOST);
+  } catch {
+  }
+  const servers = reportedAll(resolutions.map((r) => ({ folder: r.id.slice(0, 8), servers: r.servers })));
+  let answer;
+  try {
+    answer = await checkin(
+      accountsBase(),
+      token,
+      { hook_version: HOOK_VERSION, agent_client: adapter.client, policy_version: held?.policy.policy.version ?? 0, servers, events },
+      held !== null && etag === held.policy.etag ? etag : null
+    );
+  } catch (error) {
+    if (!(error instanceof ApiError)) say(`the check-in failed: ${message(error)}`);
+    else if (error.status === 401) {
+      if (error.said === "invalid_token") {
+        deleteToken(agent);
+        deletePolicy(agent);
+      }
+    } else if (error.status === 503) nextAt(agent, Math.min(Math.max((error.retryAfterSeconds ?? 0) * 1e3, HOUR_MS), DAY_MS), LOOKUP_UNAVAILABLE);
+    else if (error.status === 403) nextAt(agent, HOUR_MS, REFUSED);
+    else if (error.status !== 0) say(`the check-in was refused: ${error.status} ${error.error}`);
+    return null;
+  }
+  let policy = held?.policy ?? null;
+  if (answer.compiled !== null) {
+    const document = answer.compiled;
+    policy = document;
+    attempt("policy.json was not written", () => writePolicy(agent, document, document.etag));
+  } else if (held !== null) {
+    const current = held.policy;
+    attempt("policy.json was not confirmed", () => writePolicy(agent, current, current.etag));
+  }
+  try {
+    removeEvents(agent, events.map((e) => e.id));
+  } catch {
+  }
+  attempt("checked_in_at was not written", () => writeStamp(agent, "checked_in_at"));
+  nextAt(agent, HOUR_MS, CHECKED_IN);
+  if (policy !== null && adapter.writeDenies !== void 0) {
+    dropStale(agent, adapter.writeDenies, stale, resolutions, policy);
+    writeAllDenies(agent, adapter.writeDenies, resolutions, policy);
+  }
+  return { servers: servers.length, policy };
+}
+function folderGone(folder) {
+  try {
+    return !(0, import_node_fs9.statSync)(folder).isDirectory();
+  } catch (error) {
+    const code = error.code;
+    return code === "ENOENT" || code === "ENOTDIR";
+  }
+}
+function dropStale(agent, write, stale, live, policy) {
+  const blocked2 = new Map(live.map((r) => [r.id, blockedForms(r.servers, policy)]));
+  const elsewhere = new Set([...blocked2.values()].flat());
+  for (const resolution of stale) {
+    attempt("a folder's resolution was not dropped", () => {
+      if (resolution.complete) {
+        const left = write([], policy, readWritten(agent, resolution.id), true, elsewhere);
+        const heirs = left.map((form) => [form, live.find((r) => blocked2.get(r.id)?.includes(form))]);
+        if (heirs.some(([, heir]) => heir === void 0)) return;
+        for (const [form, heir] of heirs) {
+          if (heir === void 0) continue;
+          const theirs = readWritten(agent, heir.id);
+          if (!theirs.includes(form)) writeWritten(agent, heir.id, [...theirs, form]);
+        }
+      }
+      dropResolution(agent, resolution.id);
+    });
+  }
+}
+function writeAllDenies(agent, write, resolutions, policy) {
+  const blocked2 = new Map(resolutions.map((r) => [r.id, blockedForms(r.servers, policy)]));
+  for (const resolution of resolutions) {
+    const elsewhere = new Set(resolutions.filter((r) => r.id !== resolution.id).flatMap((r) => blocked2.get(r.id) ?? []));
+    attempt("the deny entries were not written", () => {
+      const written = write(resolution.servers, policy, readWritten(agent, resolution.id), resolution.complete, elsewhere);
+      writeWritten(agent, resolution.id, written);
+    });
+  }
+}
+function oneLine2(text) {
+  return text.replace(/[\u0000-\u001f\u007f-\u009f\u2028\u2029]/g, " ");
+}
+async function pair(args) {
+  let code;
+  let agent = "claude-code";
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if ((a === "--code" || a === "--agent") && i + 1 < args.length) {
+      if (a === "--code") code = args[++i];
+      else agent = args[++i];
+    } else if (a.startsWith("--code=")) code = a.slice("--code=".length);
+    else if (a.startsWith("--agent=")) agent = a.slice("--agent=".length);
+    else {
+      process.stderr.write(`${PAIR_USAGE}
+`);
+      return 2;
+    }
+  }
+  if (code === void 0 || code === "") {
+    process.stderr.write(`${PAIR_USAGE}
+`);
+    return 2;
+  }
+  const adapter = adapterFor(agent);
+  if (adapter === null) {
+    process.stderr.write(`attestari-hook: pairing ${oneLine2(agent)} is not built yet
+${PAIR_USAGE}
+`);
+    return 2;
+  }
+  let redeemed;
+  try {
+    redeemed = await redeem(accountsBase(), code, {
+      agent_client: adapter.client,
+      device_name: oneLine2((0, import_node_os2.hostname)()).trim().slice(0, 80) || void 0,
+      os: `${(0, import_node_os2.platform)()} ${(0, import_node_os2.release)()}`.slice(0, 80),
+      hook_version: HOOK_VERSION
+    });
+  } catch (error) {
+    if (!(error instanceof ApiError)) throw error;
+    if (error.error === "invalid_grant") process.stderr.write(`${INVALID_CODE}
+`);
+    else if (error.status === 0) process.stderr.write("Attestari could not be reached. Try again in a moment.\n");
+    else process.stderr.write(`Pairing was refused: ${error.error}.
+`);
+    return 1;
+  }
+  try {
+    writeToken(agent, redeemed.token);
+  } catch (error) {
+    process.stderr.write(`The token could not be kept: ${oneLine2(message(error))}
+`);
+    return 1;
+  }
+  const organization = oneLine2(String(redeemed.organization.name ?? "")).trim() || "your organization";
+  const cwd = process.cwd();
+  let refreshed = null;
+  try {
+    resolveAndKeep(adapter, cwd);
+    refreshed = await refresh(adapter, cwd);
+  } catch (error) {
+    say(`the first check-in failed: ${message(error)}`);
+  }
+  if (readToken(agent) === null) {
+    process.stderr.write(`${TOKEN_REFUSED}
+`);
+    return 1;
+  }
+  if (refreshed !== null && refreshed.policy !== null) {
+    process.stdout.write(`Paired with ${organization}: ${refreshed.servers} servers, policy ${refreshed.policy.policy.version}.
+`);
+  } else {
+    const servers = readResolution(agent, cwd)?.servers.length ?? 0;
+    process.stdout.write(`Paired with ${organization}: ${servers} servers, no policy yet (it is asked for at the next session).
+`);
+  }
+  installHook(adapter);
+  return 0;
+}
+function afterInstall(agent) {
+  switch (agent) {
+    case "cursor":
+      return ["Cursor reads ~/.cursor/hooks.json itself; nothing to restart."];
+    case "codex":
+      return ["Codex runs no user hook until you trust it: in Codex, run /hooks and trust the Attestari handlers."];
+    case "gemini":
+      return ["Gemini CLI runs hooks in trusted folders only; the hook decides there."];
+    default:
+      return [];
+  }
+}
+function installHook(adapter) {
+  if (adapter.name === "claude-code") {
+    if (process.env.CLAUDE_PLUGIN_ROOT) {
+      say("the Attestari plugin is installed in Claude Code already; the hook decides from the next session");
+      return true;
+    }
+    let plugin;
+    try {
+      plugin = installPlugin();
+    } catch (error) {
+      plugin = { installed: false, why: `The install failed (${oneLine2(message(error))})` };
+    }
+    if (plugin.installed) say("the Attestari plugin is installed in Claude Code; it runs from the next session");
+    else process.stderr.write(`${plugin.why}, so the Attestari plugin was not installed. Run:
+${installCommands()}`);
+    return plugin.installed;
+  }
+  try {
+    const done = adapter.install(home());
+    if ("path" in done) say(`the hook is installed in ${done.path}${done.before === done.after ? " (it was already)" : ""}`);
+    for (const line of afterInstall(adapter.name)) say(line);
+    return true;
+  } catch (error) {
+    process.stderr.write(`The hook was not installed: ${oneLine2(message(error))}. Fix that and run: npx -y attestari@2.9 install --agent ${adapter.name}
+`);
+    return false;
+  }
+}
+function install4(args) {
+  let agent;
+  for (let i = 0; i < args.length; i++) {
+    const a = args[i];
+    if (a === "--agent" && i + 1 < args.length) agent = args[++i];
+    else if (a.startsWith("--agent=")) agent = a.slice("--agent=".length);
+    else {
+      process.stderr.write(`${INSTALL_USAGE}
+`);
+      return 2;
+    }
+  }
+  const adapter = agent === void 0 ? null : adapterFor(agent);
+  if (adapter === null) {
+    process.stderr.write(`${INSTALL_USAGE}
+`);
+    return 2;
+  }
+  return installHook(adapter) ? 0 : 1;
+}
+
+// src/status.ts
+var import_node_fs10 = require("node:fs");
+var import_node_path10 = require("node:path");
+function age(ms) {
+  const minutes = Math.floor(ms / 6e4);
+  if (minutes < 60) return `${Math.max(minutes, 0)} min`;
+  const hours = Math.floor(minutes / 60);
+  if (hours < 48) return `${hours} h`;
+  return `${Math.floor(hours / 24)} days`;
+}
+function policyLine(dir) {
+  const file = (0, import_node_path10.join)(dir, "policy.json");
+  if (!(0, import_node_fs10.existsSync)(file)) return null;
+  let version = "unreadable";
+  try {
+    const document = JSON.parse((0, import_node_fs10.readFileSync)(file, "utf8"));
+    const v = document?.policy?.version;
+    if (typeof v === "number") version = String(v);
+  } catch {
+  }
+  return `policy ${version}, ${age(Date.now() - (0, import_node_fs10.statSync)(file).mtimeMs)} old`;
+}
+function status() {
+  const root = attestariDir();
+  const agents = (0, import_node_fs10.existsSync)(root) ? (0, import_node_fs10.readdirSync)(root, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name).sort() : [];
+  if (agents.length === 0) {
+    console.log("not paired");
+    return 0;
+  }
+  for (const agent of agents) {
+    const dir = agentDir(agent);
+    const token = (0, import_node_fs10.existsSync)((0, import_node_path10.join)(dir, "token")) ? "token present" : "no token";
+    const policy = policyLine(dir) ?? "no policy";
+    console.log(`${agent}: ${token}; ${policy}`);
+  }
+  return 0;
+}
+
+// src/main.ts
+var AGENTS = ["claude-code", "cursor", "codex", "gemini"];
+var EVENTS = ["session-start", "pre-tool-use", "refresh"];
+var USAGE = [
+  "usage: attestari-hook <agent> <event>",
+  "       attestari-hook pair --code <code> [--agent <agent>]",
+  "       attestari-hook install --agent <agent>",
+  "       attestari-hook status",
+  `agents: ${AGENTS.join(", ")}; events: ${EVENTS.join(", ")}`
+].join("\n");
+function notBuilt(name) {
+  console.error(`attestari-hook: ${name} is not built yet`);
+  return 2;
+}
+function stdin() {
+  return (0, import_node_fs11.readFileSync)(0, "utf8");
+}
+var COMMANDS = {
+  status: () => status(),
+  pair: (args) => pair(args),
+  install: (args) => install4(args)
+};
+function hook(agent, event, args) {
+  const adapter = adapterFor(agent);
+  if (adapter === null) return notBuilt(`${agent} ${event}`);
+  switch (event) {
+    case "pre-tool-use": {
+      const outcome = decideCall(adapter, adapter.events[0], stdin());
+      process.stdout.write(outcome.stdout);
+      return outcome.exitCode;
+    }
+    case "session-start": {
+      const outcome = sessionStart(stdin(), adapter);
+      process.stdout.write(outcome.stdout);
+      return outcome.exitCode;
+    }
+    // Detached, its output ignored: whatever happens it exits 0 and the next session or hour tries again.
+    // `--cwd <folder>`: the session's working folder, resolved first when it has no resolution.
+    case "refresh": {
+      const at = args.indexOf("--cwd");
+      return refresh(adapter, at >= 0 ? args[at + 1] : void 0).then(() => 0);
+    }
+    default:
+      return notBuilt(`${agent} ${event}`);
+  }
+}
+function run2(argv) {
+  const [first, second] = argv;
+  const command = first !== void 0 && Object.hasOwn(COMMANDS, first) ? COMMANDS[first] : void 0;
+  if (command) return command(argv.slice(1));
+  if (first !== void 0 && AGENTS.includes(first) && second !== void 0 && EVENTS.includes(second)) {
+    return hook(first, second, argv.slice(2));
+  }
+  console.error(USAGE);
+  return 2;
+}
+function failed(error) {
+  const message2 = error instanceof Error ? error.message : String(error);
+  console.error(`attestari-hook: ${message2.replace(/\s+/g, " ").trim() || "failed"}`);
+  process.exitCode = 2;
+}
+function failedLater(error) {
+  failed(error);
+  process.exit(2);
+}
+process.on("uncaughtException", failedLater);
+process.on("unhandledRejection", failedLater);
+try {
+  const exit = run2(process.argv.slice(2));
+  if (typeof exit === "number") process.exitCode = exit;
+  else exit.then((code) => process.exitCode = code, failedLater);
+} catch (error) {
+  failed(error);
+}