@hasna/hooks 0.6.4 → 0.6.6

package/dist/index.js

@@ -399,7 +399,61 @@ var init_db = __esm(() => {
   init_legacy_import();
 });
 
-// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/util.js
+// src/lib/redact.ts
+function redactText(value) {
+  let out = value;
+  for (const pattern of SECRET_SHAPES) {
+    out = out.replace(pattern, REDACTED);
+  }
+  return out;
+}
+function redactValue(value) {
+  if (typeof value === "string")
+    return redactText(value);
+  if (Array.isArray(value))
+    return value.map(redactValue);
+  if (value !== null && typeof value === "object") {
+    const out = {};
+    for (const [key, child] of Object.entries(value)) {
+      out[key] = SECRET_KEY_NAMES.test(key) ? REDACTED : redactValue(child);
+    }
+    return out;
+  }
+  return value;
+}
+function redactEventPayload(text) {
+  if (text === null || text === undefined)
+    return null;
+  try {
+    const parsed = JSON.parse(text);
+    return redactText(JSON.stringify(redactValue(parsed)));
+  } catch {
+    return redactText(text);
+  }
+}
+var REDACTED = "[REDACTED]", SECRET_KEY_NAMES, SECRET_SHAPES;
+var init_redact = __esm(() => {
+  SECRET_KEY_NAMES = /^(key|keys|token|tokens|secret|secrets|password|passwd|api[_-]?key|apikey|access[_-]?key|private[_-]?key|client[_-]?secret|refresh[_-]?token|authorization|auth|cookie|credential|credentials|session[_-]?id|otp|mfa[_-]?code|two[_-]?fa[_-]?code|verification[_-]?code|database_url|db_url|connection_string|dsn)$/i;
+  SECRET_SHAPES = [
+    /\bsk-(?:proj|svc|ant)-[A-Za-z0-9_-]{10,}/g,
+    /\bsk-[A-Za-z0-9]{16,}/g,
+    /\btpe_[A-Za-z0-9]{8,}/g,
+    /\b(?:rk|sk)_(?:live|test)_[A-Za-z0-9]{8,}/g,
+    /\bgithub_pat_[A-Za-z0-9_]{20,}/g,
+    /gh[pousr]_[A-Za-z0-9]{20,}/g,
+    /xox[baprs]-[A-Za-z0-9-]{20,}/g,
+    /AKIA[0-9A-Z]{16}/g,
+    /ASIA[0-9A-Z]{16}/g,
+    /eyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}/g,
+    /-----BEGIN [A-Z0-9 ]*PRIVATE KEY-----/g,
+    /-----BEGIN OPENSSH PRIVATE KEY-----/g,
+    /\bBearer\s+[A-Za-z0-9._~+/=-]{6,}/g,
+    /\b[a-z][a-z0-9+.-]*:\/\/[^/\s:@]+:[^/\s@]+@/gi,
+    /\b(?:password|passwd|pwd|token|api[_-]?key|secret|access[_-]?key|client[_-]?secret|authorization|auth|credential|database_url|db_url|connection_string|dsn)\s*[:=]\s*(?:"[^"]*"|'[^']*'|[^\s,;"']{6,})/gi
+  ];
+});
+
+// node_modules/zod/v3/helpers/util.js
 var util, objectUtil, ZodParsedType, getParsedType = (data) => {
   const t = typeof data;
   switch (t) {
@@ -530,7 +584,7 @@ var init_util = __esm(() => {
   ]);
 });
 
-// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/ZodError.js
+// node_modules/zod/v3/ZodError.js
 var ZodIssueCode, quotelessJson = (obj) => {
   const json = JSON.stringify(obj, null, 2);
   return json.replace(/"([^"]+)":/g, "$1:");
@@ -651,7 +705,7 @@ var init_ZodError = __esm(() => {
   };
 });
 
-// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/locales/en.js
+// node_modules/zod/v3/locales/en.js
 var errorMap = (issue, _ctx) => {
   let message;
   switch (issue.code) {
@@ -758,7 +812,7 @@ var init_en = __esm(() => {
   en_default = errorMap;
 });
 
-// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/errors.js
+// node_modules/zod/v3/errors.js
 function setErrorMap(map) {
   overrideErrorMap = map;
 }
@@ -771,7 +825,7 @@ var init_errors = __esm(() => {
   overrideErrorMap = en_default;
 });
 
-// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/parseUtil.js
+// node_modules/zod/v3/helpers/parseUtil.js
 function addIssueToContext(ctx, issueData) {
   const overrideMap = getErrorMap();
   const issue = makeIssue({
@@ -876,10 +930,10 @@ var init_parseUtil = __esm(() => {
   });
 });
 
-// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/typeAliases.js
+// node_modules/zod/v3/helpers/typeAliases.js
 var init_typeAliases = () => {};
 
-// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/helpers/errorUtil.js
+// node_modules/zod/v3/helpers/errorUtil.js
 var errorUtil;
 var init_errorUtil = __esm(() => {
   (function(errorUtil2) {
@@ -888,7 +942,7 @@ var init_errorUtil = __esm(() => {
   })(errorUtil || (errorUtil = {}));
 });
 
-// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/types.js
+// node_modules/zod/v3/types.js
 class ParseInputLazyPath {
   constructor(parent, value, path, key) {
     this._cachedPath = [];
@@ -4239,7 +4293,7 @@ var init_types = __esm(() => {
   NEVER = INVALID;
 });
 
-// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
+// node_modules/zod/v3/external.js
 var exports_external = {};
 __export(exports_external, {
   void: () => voidType,
@@ -4359,7 +4413,7 @@ var init_external = __esm(() => {
   init_ZodError();
 });
 
-// ../../node_modules/.bun/zod@3.25.76/node_modules/zod/index.js
+// node_modules/zod/index.js
 var init_zod = __esm(() => {
   init_external();
   init_external();
@@ -4414,24 +4468,30 @@ function resolveApiUrl() {
   const cfg = readConfig();
   return cfg.api_url ? cfg.api_url.replace(/\/+$/, "") : undefined;
 }
-function resolveApiKey(flagKey) {
-  if (flagKey && flagKey.length > 0)
-    return flagKey;
+function resolveApiKey() {
   return process.env.HASNA_HOOKS_API_KEY ?? process.env.HOOKS_API_KEY;
 }
 var init_config = () => {};
 
+// src/lib/semver.ts
+var SEMVER_PATTERN;
+var init_semver = __esm(() => {
+  SEMVER_PATTERN = /^\d+\.\d+\.\d+(-[0-9A-Za-z.-]+)?(\+[0-9A-Za-z.-]+)?$/;
+});
+
 // src/lib/manifest.ts
 var exports_manifest = {};
 __export(exports_manifest, {
   writeCustomHook: () => writeCustomHook,
   shortManifestName: () => shortManifestName,
+  scriptRelFor: () => scriptRelFor,
   resolveScript: () => resolveScript,
   readCustomManifest: () => readCustomManifest,
   parseManifest: () => parseManifest,
   normalizeManifestName: () => normalizeManifestName,
   manifestSchema: () => manifestSchema,
   listCustomHooks: () => listCustomHooks,
+  isInlineScript: () => isInlineScript,
   customHookDir: () => customHookDir,
   assertContained: () => assertContained,
   ScriptContainmentError: () => ScriptContainmentError,
@@ -4484,16 +4544,25 @@ function assertContained(target, root, raw) {
   assertContainedReal(root, lexical, raw);
   return lexical;
 }
-function resolveScript(manifest, manifestDir) {
-  if (manifest.script.includes(`
-`)) {
+function isInlineScript(manifest) {
+  return manifest.script_kind === "inline" || manifest.script_kind === undefined && manifest.script.includes(`
+`);
+}
+function scriptRelFor(manifest) {
+  if (isInlineScript(manifest)) {
     const ext = manifest.script.trim().startsWith("#!") ? ".sh" : ".ts";
-    return { path: `script${ext}`, content: manifest.script };
+    return `script${ext}`;
   }
   const rel = normalize(manifest.script);
   if (isAbsolute(rel)) {
     throw new Error(`manifest script must be relative or inline, got absolute path '${manifest.script}'`);
   }
+  return rel;
+}
+function resolveScript(manifest, manifestDir) {
+  if (isInlineScript(manifest))
+    return { path: scriptRelFor(manifest), content: manifest.script };
+  const rel = scriptRelFor(manifest);
   const resolved = assertContained(join4(manifestDir, rel), manifestDir, manifest.script);
   if (!existsSync4(resolved)) {
     throw new Error(`manifest script file not found: ${resolved}`);
@@ -4511,8 +4580,8 @@ function readCustomManifest(name) {
   try {
     const manifest = parseManifest(readFileSync3(manifestPath, "utf-8"));
     const script = resolveScript(manifest, dir);
-    return { manifest, scriptPath: join4(dir, script.path), scriptContent: script.content, scriptIsInline: manifest.script.includes(`
-`) };
+    const scriptIsInline = isInlineScript(manifest);
+    return { manifest, scriptPath: join4(dir, script.path), scriptContent: script.content, scriptIsInline };
   } catch (err) {
     if (err instanceof ScriptContainmentError)
       throw err;
@@ -4559,13 +4628,15 @@ var HOOK_NAME_RE, manifestSchema, ScriptContainmentError;
 var init_manifest = __esm(() => {
   init_zod();
   init_config();
+  init_semver();
   HOOK_NAME_RE = /^[\w-]+$/;
   manifestSchema = exports_external.object({
     name: exports_external.string().regex(HOOK_NAME_RE, "hook name must be /^[\\w-]+$/"),
-    version: exports_external.string().regex(/^\d+\.\d+\.\d+/, "version must be semver (e.g. 1.2.3)"),
+    version: exports_external.string().regex(SEMVER_PATTERN, "version must be full semver (e.g. 1.2.3 or 1.2.3-beta.1)"),
     description: exports_external.string().optional(),
     events: exports_external.array(exports_external.string()).min(1, "at least one event is required"),
     script: exports_external.string().min(1, "script must name a relative path or inline content"),
+    script_kind: exports_external.enum(["inline", "file"]).optional(),
     args: exports_external.array(exports_external.string()).optional(),
     timeout_ms: exports_external.number().int().positive().optional()
   });
@@ -4595,11 +4666,13 @@ __export(exports_store, {
   listHookRecords: () => listHookRecords,
   getPinnedHook: () => getPinnedHook,
   getHookRecord: () => getHookRecord,
-  checkScriptHash: () => checkScriptHash
+  checkScriptHash: () => checkScriptHash,
+  LockFileError: () => LockFileError
 });
 import { createHash } from "crypto";
-import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3 } from "fs";
+import { existsSync as existsSync6, mkdirSync as mkdirSync4, readFileSync as readFileSync4, writeFileSync as writeFileSync3, renameSync } from "fs";
 import { readFile } from "fs/promises";
+import { randomBytes } from "crypto";
 function sha256Of(input) {
   return createHash("sha256").update(input).digest("hex");
 }
@@ -4642,16 +4715,39 @@ function removeHookRecord(db, name) {
   const res = db.run("DELETE FROM hooks WHERE name = ?", [name]);
   return res.changes > 0;
 }
+function assertLockShape(parsed, path) {
+  if (parsed === null || typeof parsed !== "object" || Array.isArray(parsed)) {
+    throw new LockFileError(`hooks.lock (${path}) is malformed: expected a JSON object with a "hooks" map. ` + `Repair: fix the file by hand, or if it is unrecoverable move it aside and run 'hooks sync' to rebuild it. ` + `Nothing was trusted or rewritten \u2014 hooks are left in the refuse-to-run state until the lock is repaired.`);
+  }
+  const hooks = parsed.hooks;
+  if (hooks === null || typeof hooks !== "object" || Array.isArray(hooks)) {
+    throw new LockFileError(`hooks.lock (${path}) is malformed: missing or invalid "hooks" map. ` + `Repair: fix the file by hand, or if it is unrecoverable move it aside and run 'hooks sync' to rebuild it. ` + `Nothing was trusted or rewritten \u2014 hooks are left in the refuse-to-run state until the lock is repaired.`);
+  }
+  for (const [name, entry] of Object.entries(hooks)) {
+    const e = entry;
+    if (e === null || typeof e !== "object" || typeof e.version !== "string" || typeof e.sha256 !== "string") {
+      throw new LockFileError(`hooks.lock (${path}) is malformed: entry for '${name}' is not a valid pin (version and sha256 strings required). ` + `Repair: fix the file by hand, or if it is unrecoverable move it aside and run 'hooks sync' to rebuild it.`);
+    }
+  }
+}
 function readLock() {
+  const path = getLockPath();
+  if (!existsSync6(path))
+    return { hooks: {} };
+  let raw;
   try {
-    const path = getLockPath();
-    if (!existsSync6(path))
-      return { hooks: {} };
-    const parsed = JSON.parse(readFileSync4(path, "utf-8"));
-    return { hooks: parsed.hooks ?? {} };
+    raw = readFileSync4(path, "utf-8");
   } catch {
-    return { hooks: {} };
+    throw new LockFileError(`hooks.lock (${path}) could not be read. Repair: fix permissions or move the file aside and run 'hooks sync'.`);
+  }
+  let parsed;
+  try {
+    parsed = JSON.parse(raw);
+  } catch {
+    throw new LockFileError(`hooks.lock (${path}) is malformed: not valid JSON (${String((raw ?? "").slice(0, 80))}). ` + `Repair: fix the file by hand, or if it is unrecoverable move it aside and run 'hooks sync' to rebuild it. ` + `Nothing was trusted or rewritten \u2014 hooks are left in the refuse-to-run state until the lock is repaired.`);
   }
+  assertLockShape(parsed, path);
+  return parsed;
 }
 function writeLock(lock) {
   const path = getLockPath();
@@ -4660,8 +4756,10 @@ function writeLock(lock) {
   for (const name of Object.keys(lock.hooks).sort()) {
     sorted[name] = lock.hooks[name];
   }
-  writeFileSync3(path, JSON.stringify({ hooks: sorted }, null, 2) + `
+  const tmp = `${path}.tmp-${randomBytes(8).toString("hex")}`;
+  writeFileSync3(tmp, JSON.stringify({ hooks: sorted }, null, 2) + `
 `, "utf-8");
+  renameSync(tmp, path);
   return path;
 }
 function setPinnedHook(name, entry) {
@@ -4747,9 +4845,16 @@ function retrustHook(name, scriptPath, version, source) {
   setPinnedHook(name, { version, sha256: actual, source });
   return { ok: true, pinned: true, expected: actual, actual, name };
 }
+var LockFileError;
 var init_store = __esm(() => {
   init_db();
   init_config();
+  LockFileError = class LockFileError extends Error {
+    constructor(message) {
+      super(message);
+      this.name = "LockFileError";
+    }
+  };
 });
 
 // src/lib/profiles.ts
@@ -4895,13 +5000,73 @@ var init_profiles = __esm(() => {
   PROFILES_DIR = resolveProfilesDir();
 });
 
+// src/lib/hook-env.ts
+function isDeniedEnvName(name) {
+  const upper = name.toUpperCase();
+  if (DENY_PREFIXES.some((prefix) => upper.startsWith(prefix)))
+    return true;
+  if (DENY_SUFFIXES.some((suffix) => upper.endsWith(suffix)))
+    return true;
+  return DENY_CONTAINS.some((token) => upper.includes(token));
+}
+function buildHookEnv(source, extra) {
+  const out = {};
+  for (const name of ALLOWLIST) {
+    const value = source[name] ?? extra?.[name];
+    if (value !== undefined && value !== null)
+      out[name] = value;
+  }
+  for (const [from, to] of CONFIG_PROJECTIONS) {
+    const value = source[from] ?? extra?.[from];
+    if (value !== undefined && value !== null)
+      out[to] = value;
+  }
+  const merged = { ...source, ...extra ?? {} };
+  for (const [name, value] of Object.entries(merged)) {
+    if (out[name] !== undefined)
+      continue;
+    if (isDeniedEnvName(name))
+      continue;
+    if (value !== undefined && value !== null)
+      out[name] = value;
+  }
+  return out;
+}
+var ALLOWLIST, DENY_SUFFIXES, DENY_PREFIXES, DENY_CONTAINS, CONFIG_PROJECTIONS;
+var init_hook_env = __esm(() => {
+  ALLOWLIST = new Set(["PATH", "HOME", "LANG", "TZ", "SHELL", "TERM", "USER", "PWD"]);
+  DENY_SUFFIXES = ["KEY", "TOKEN", "SECRET", "PASSWORD", "PASSWD", "CREDENTIAL", "CREDENTIALS", "URL", "URI"];
+  DENY_PREFIXES = [
+    "HASNA_",
+    "AWS_",
+    "AZURE_",
+    "GCP_",
+    "VAULT_",
+    "GOOGLE_",
+    "OPENAI_",
+    "ANTHROPIC_",
+    "POSTGRES_",
+    "MYSQL_",
+    "REDIS_",
+    "MONGO_",
+    "MEMENTOS_"
+  ];
+  DENY_CONTAINS = ["DATABASE_URL"];
+  CONFIG_PROJECTIONS = [
+    ["HASNA_HOOKS_DATA_DIR", "HOOKS_DATA_DIR"],
+    ["HASNA_HOOKS_DB_PATH", "HOOKS_DB_PATH"],
+    ["HASNA_HOOKS_LOCK_PATH", "HOOKS_LOCK_PATH"],
+    ["HASNA_HOOKS_CONFIG_PATH", "HOOKS_CONFIG_PATH"]
+  ];
+});
+
 // src/lib/run.ts
 var exports_run = {};
 __export(exports_run, {
   executeVerifiedScript: () => executeVerifiedScript,
   HookTimeoutError: () => HookTimeoutError
 });
-import { randomBytes } from "crypto";
+import { randomBytes as randomBytes2 } from "crypto";
 import { rmSync as rmSync4, writeFileSync as writeFileSync6 } from "fs";
 import { basename as basename2, dirname as dirname4, isAbsolute as isAbsolute2, join as join9 } from "path";
 function extensionOf(scriptPath) {
@@ -4974,12 +5139,12 @@ async function readPipeWithDeadline(stream, deadlineMs) {
 async function executeVerifiedScript(options) {
   const scriptDir = dirname4(options.scriptPath);
   const interpreter = interpreterFor(options.name, options.scriptPath, options.content);
-  const tempPath = join9(scriptDir, `.hooks-verified-${randomBytes(12).toString("hex")}.${interpreter.tempExt}`);
+  const tempPath = join9(scriptDir, `.hooks-verified-${randomBytes2(12).toString("hex")}.${interpreter.tempExt}`);
   let proc = null;
   let timedOut = false;
   const timeoutTimer = options.timeout ? setTimeout(() => {
     timedOut = true;
-    killGroup(proc);
+    killGroup(proc, { leaderAlive: proc !== null && proc.exitCode === null });
   }, options.timeout) : null;
   try {
     writeFileSync6(tempPath, options.content, { flag: "wx", mode: 384 });
@@ -4987,7 +5152,7 @@ async function executeVerifiedScript(options) {
       stdin: new Response(options.stdin),
       stdout: "pipe",
       stderr: "pipe",
-      env: options.env ?? process.env,
+      env: buildHookEnv(process.env, options.env),
       detached: true
     });
     const exitCode = await proc.exited;
@@ -4998,7 +5163,7 @@ async function executeVerifiedScript(options) {
       readPipeWithDeadline(proc.stdout, 750),
       readPipeWithDeadline(proc.stderr, 750)
     ]);
-    killGroup(proc);
+    killGroup(proc, { leaderAlive: false });
     return { stdout: stdoutText, stderr: stderrText, exitCode };
   } finally {
     if (timeoutTimer)
@@ -5008,12 +5173,36 @@ async function executeVerifiedScript(options) {
     } catch {}
   }
 }
-function killGroup(proc) {
+function killGroup(proc, options) {
   if (!proc)
     return;
-  try {
-    process.kill(-proc.pid, "SIGKILL");
-  } catch {
+  const pgid = proc.pid;
+  for (let pass = 0;pass < 5; pass++) {
+    let members = [];
+    try {
+      const res = Bun.spawnSync(["ps", "-eo", "pid=,pgid="], { stdout: "pipe", stderr: "pipe" });
+      if (res.exitCode === 0) {
+        members = res.stdout.toString().split(`
+`).map((line) => line.trim().split(/\s+/)).filter((cols) => cols.length === 2 && cols[1] === String(pgid)).map((cols) => Number(cols[0])).filter((pid) => Number.isInteger(pid) && pid > 1).filter((pid) => options.leaderAlive || pid !== proc.pid);
+      }
+    } catch {}
+    if (members.length === 0)
+      break;
+    let killed = 0;
+    for (const pid of members) {
+      try {
+        const probe = Bun.spawnSync(["ps", "-o", "pid=,pgid=", "-p", String(pid)], { stdout: "pipe", stderr: "pipe" });
+        const cols = probe.stdout.toString().trim().split(/\s+/);
+        if (cols.length === 2 && cols[1] === String(pgid)) {
+          process.kill(pid, "SIGKILL");
+          killed++;
+        }
+      } catch {}
+    }
+    if (killed === 0)
+      break;
+  }
+  if (options.leaderAlive) {
     try {
       process.kill(proc.pid, "SIGKILL");
     } catch {}
@@ -5021,6 +5210,7 @@ function killGroup(proc) {
 }
 var HookTimeoutError, BASH_EXTENSIONS, BUN_EXTENSIONS;
 var init_run = __esm(() => {
+  init_hook_env();
   HookTimeoutError = class HookTimeoutError extends Error {
     timeoutMs;
     constructor(timeoutMs) {
@@ -5049,6 +5239,9 @@ function writeHookEvent(event) {
     const db = getDb();
     const id = nanoid2();
     const timestamp = event.timestamp ?? new Date().toISOString();
+    const toolInput = redactEventPayload(event.tool_input);
+    const error = redactEventPayload(event.error);
+    const metadata = redactEventPayload(event.metadata);
     db.run(`INSERT INTO hook_events
         (id, timestamp, session_id, hook_name, event_type, tool_name, tool_input, result, error, duration_ms, project_dir, metadata)
        VALUES (?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?, ?)`, [
@@ -5058,12 +5251,12 @@ function writeHookEvent(event) {
       event.hook_name,
       event.event_type,
       event.tool_name ?? null,
-      event.tool_input ? event.tool_input.slice(0, 500) : null,
+      toolInput ? toolInput.slice(0, 500) : null,
       event.result ?? null,
-      event.error ?? null,
+      error ?? null,
       event.duration_ms ?? null,
       event.project_dir ?? null,
-      event.metadata ?? null
+      metadata ?? null
     ]);
   } catch (err) {
     process.stderr.write(`[hooks db-writer] failed to write event: ${err}
@@ -5113,6 +5306,7 @@ function recordHookRun(record) {
 var ALLOWED_EVENT_TYPES;
 var init_db_writer = __esm(() => {
   init_db();
+  init_redact();
   ALLOWED_EVENT_TYPES = new Set([
     "PreToolUse",
     "PostToolUse",
@@ -5135,7 +5329,7 @@ var PG_MIGRATIONS = [
     timestamp    TEXT NOT NULL,
     session_id   TEXT NOT NULL,
     hook_name    TEXT NOT NULL,
-    event_type   TEXT NOT NULL CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit')),
+    event_type   TEXT NOT NULL CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit', 'SubagentStart')),
     tool_name    TEXT,
     tool_input   TEXT,
     result       TEXT CHECK (result IN ('continue', 'block', NULL)),
@@ -5168,7 +5362,10 @@ var PG_MIGRATIONS = [
   )`,
   `ALTER TABLE hook_events DROP CONSTRAINT IF EXISTS hook_events_event_type_check`,
   `ALTER TABLE hook_events ADD CONSTRAINT hook_events_event_type_check
-    CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit'))`
+    CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit'))`,
+  `ALTER TABLE hook_events DROP CONSTRAINT IF EXISTS hook_events_event_type_check`,
+  `ALTER TABLE hook_events ADD CONSTRAINT hook_events_event_type_check
+    CHECK (event_type IN ('PreToolUse', 'PostToolUse', 'Stop', 'Notification', 'SessionStart', 'SessionEnd', 'UserPromptSubmit', 'SubagentStart'))`
 ];
 
 // src/db/remote-storage.ts
@@ -5182,7 +5379,34 @@ function normalizeParams(params) {
   return flat.map((value) => value === undefined ? null : value);
 }
 function sslConfigFor(connectionString) {
-  return connectionString.includes("sslmode=require") || connectionString.includes("ssl=true") ? { rejectUnauthorized: false } : undefined;
+  const wantsSsl = wantsSslFor(connectionString);
+  if (!wantsSsl)
+    return;
+  const insecure = process.env.HASNA_HOOKS_PG_INSECURE_TLS === "1" || process.env.HOOKS_PG_INSECURE_TLS === "1";
+  if (insecure && false) {}
+  return insecure ? { rejectUnauthorized: false } : { rejectUnauthorized: true };
+}
+function wantsSslFor(connectionString) {
+  let raw;
+  try {
+    raw = new URL(connectionString).search.replace(/^\?/, "");
+  } catch {
+    raw = connectionString;
+  }
+  try {
+    raw = decodeURIComponent(raw);
+  } catch {}
+  const paramValue = (name) => {
+    const match = raw.match(new RegExp(`(?:^|[&\\s])${name}\\s*=\\s*([^&\\s]+)`, "i"));
+    return match ? match[1].toLowerCase() : undefined;
+  };
+  const sslmode = paramValue("sslmode");
+  if (sslmode !== undefined)
+    return sslmode !== "disable" && sslmode !== "allow";
+  const ssl = paramValue("ssl");
+  if (ssl !== undefined)
+    return ssl !== "false" && ssl !== "0" && ssl !== "no";
+  return false;
 }
 
 class PgAdapterAsync {
@@ -5204,6 +5428,7 @@ class PgAdapterAsync {
 }
 
 // src/db/storage-sync.ts
+init_redact();
 var STORAGE_TABLES = [
   "hook_events",
   "schema_migrations",
@@ -5380,9 +5605,15 @@ async function pushTable(db, remote, table) {
     result.rowsRead = rows.length;
     if (rows.length === 0)
       return result;
+    const projected = table === "hook_events" ? rows.map((row) => ({
+      ...row,
+      tool_input: typeof row.tool_input === "string" ? redactEventPayload(row.tool_input) : row.tool_input,
+      error: typeof row.error === "string" ? redactEventPayload(row.error) : row.error,
+      metadata: typeof row.metadata === "string" ? redactEventPayload(row.metadata) : row.metadata
+    })) : rows;
     const remoteColumns = await getRemoteColumns(remote, table);
-    const columns = filterRemoteColumns(remoteColumns, Object.keys(rows[0]));
-    result.rowsWritten = await upsertPg(remote, table, columns, rows, remoteColumns);
+    const columns = filterRemoteColumns(remoteColumns, Object.keys(projected[0]));
+    result.rowsWritten = await upsertPg(remote, table, columns, projected, remoteColumns);
   } catch (error) {
     result.errors.push(error instanceof Error ? error.message : String(error));
   }
@@ -5397,8 +5628,14 @@ async function pullTable(remote, db, table) {
     result.rowsRead = rows.length;
     if (rows.length === 0)
       return result;
-    const columns = filterLocalColumns(db, table, Object.keys(rows[0]));
-    result.rowsWritten = upsertSqlite(db, table, columns, rows);
+    const projected = table === "hook_events" ? rows.map((row) => ({
+      ...row,
+      tool_input: typeof row.tool_input === "string" ? redactEventPayload(row.tool_input) : row.tool_input,
+      error: typeof row.error === "string" ? redactEventPayload(row.error) : row.error,
+      metadata: typeof row.metadata === "string" ? redactEventPayload(row.metadata) : row.metadata
+    })) : rows;
+    const columns = filterLocalColumns(db, table, Object.keys(projected[0]));
+    result.rowsWritten = upsertSqlite(db, table, columns, projected);
   } catch (error) {
     result.errors.push(error instanceof Error ? error.message : String(error));
   }
@@ -6212,7 +6449,7 @@ function getGlobalSettingsPathOverride(target) {
 function getSettingsPath(scope = "global", target = "claude", codewithConfigPath) {
   if (target === "codewith" && codewithConfigPath)
     return codewithConfigPath;
-  if (target === "codewith" && process.env.HASNA_HOOKS_CODEWITH_CONFIG_PATH) {
+  if (target === "codewith" && scope === "global" && process.env.HASNA_HOOKS_CODEWITH_CONFIG_PATH) {
     return process.env.HASNA_HOOKS_CODEWITH_CONFIG_PATH;
   }
   const globalOverride = scope === "global" ? getGlobalSettingsPathOverride(target) : undefined;
@@ -6646,8 +6883,8 @@ function escapeRegExp(value) {
 function codewithHasHookEntryInText(configText, name) {
   return new RegExp(`hooks run ${escapeRegExp(name)}(?:\\s+--profile\\s+[\\w-]+)?(?:$|\\s|")`).test(configText);
 }
-function codewithHasHookEntry(name) {
-  const path = getSettingsPath("global", "codewith");
+function codewithHasHookEntry(name, scope = "global") {
+  const path = getSettingsPath(scope, "codewith");
   if (!existsSync7(path))
     return false;
   try {
@@ -6664,7 +6901,7 @@ function uninstallHook(name, scope = "global", target = "claude") {
   const registeredClaudeOrGemini = target === "all" ? existsInTarget("claude") || existsInTarget("gemini") : false;
   const registeredGlobal = registeredClaudeOrGemini || getRegisteredHooksForTarget("global", target === "all" ? "claude" : target).includes(shortName);
   const registeredProject = registeredClaudeOrGemini || getRegisteredHooksForTarget("project", target === "all" ? "claude" : target).includes(shortName);
-  const codewithOnly = (target === "codewith" || target === "all") && codewithHasHookEntry(shortName);
+  const codewithOnly = (target === "codewith" || target === "all") && codewithHasHookEntry(shortName, scope);
   if (!custom2 && !bundledMeta && !registeredGlobal && !registeredProject && !codewithOnly) {
     return { name: shortName, removed: false, source: null, settingsScopes: [], storeDirRemoved: false, pinRemoved: false, dbRecordRemoved: false, registrationsRemaining: [], error: `Hook '${shortName}' not found` };
   }
@@ -6681,7 +6918,7 @@ function uninstallHook(name, scope = "global", target = "claude") {
   }
   const registrationsRemaining = [];
   if (target === "codewith" || target === "all") {
-    const codewithPath = getSettingsPath("global", "codewith");
+    const codewithPath = getSettingsPath(scope, "codewith");
     if (existsSync7(codewithPath)) {
       const before = readFileSync5(codewithPath, "utf-8");
       const after = removeCodewithHookEntry(before, shortName);
@@ -6807,19 +7044,20 @@ async function installCustomSource(source) {
   return copyManifestDir(source, source, "local");
 }
 async function installManifestUrl(url) {
-  const res = await fetch(url, { redirect: "follow" });
+  const res = await fetch(url, { redirect: "error" });
   if (!res.ok) {
     throw new Error(`Failed to fetch manifest (${res.status}): ${url}`);
   }
   const manifest = parseManifest(await res.text());
   let script;
-  if (manifest.script.includes(`
-`)) {
+  const inline = manifest.script_kind === "inline" || manifest.script_kind === undefined && manifest.script.includes(`
+`);
+  if (inline) {
     script = { path: "script.ts", content: manifest.script };
   } else {
     const base = url.substring(0, url.lastIndexOf("/"));
     const scriptUrl = `${base}/${manifest.script}`;
-    const scriptRes = await fetch(scriptUrl, { redirect: "follow" });
+    const scriptRes = await fetch(scriptUrl, { redirect: "error" });
     if (!scriptRes.ok) {
       throw new Error(`Failed to fetch script (${scriptRes.status}): ${scriptUrl}`);
     }
@@ -6856,7 +7094,7 @@ function collectBundledCatalog() {
   }
   return out;
 }
-async function fetchJson(base, path) {
+async function fetchJson(base, path, opts) {
   const headers = { accept: "application/json" };
   const apiKey = resolveApiKey();
   if (apiKey)
@@ -6872,7 +7110,11 @@ async function fetchJson(base, path) {
   if (!res.ok) {
     throw new Error(`GET ${path} failed with status ${res.status}`);
   }
-  return res.json();
+  const body = await res.json();
+  if (opts?.withHeader) {
+    body[opts.withHeader] = res.headers.get("x-hook-sha256");
+  }
+  return body;
 }
 async function fetchRemoteState(apiUrl) {
   const catalog = await fetchJson(apiUrl, "/api/v1/catalog");
@@ -6885,6 +7127,16 @@ async function fetchRemoteState(apiUrl) {
   }
   return { catalog: catalog.hooks, remoteLock };
 }
+function classifyRemotePin(pin, remoteVersion, remoteSha) {
+  const pinnedLocally = pin !== undefined && pin.version === remoteVersion && pin.sha256 === remoteSha;
+  if (pinnedLocally)
+    return "unchanged";
+  if (pin !== undefined && pin.pinned === true && pin.version !== remoteVersion)
+    return "unchanged";
+  if (pin !== undefined)
+    return "updated";
+  return "added";
+}
 function computeDiff(catalog, remoteLock) {
   const local = readLock();
   const diff = { added: [], updated: [], unchanged: [], skipped: [] };
@@ -6892,30 +7144,30 @@ function computeDiff(catalog, remoteLock) {
     if (!entry.name || !entry.version || !entry.sha256)
       continue;
     const pin = local.hooks[entry.name];
-    const remotePin = remoteLock ? remoteLock.hooks[entry.name] : entry;
-    if (remoteLock && !remotePin) {
-      diff.skipped.push(entry.name);
-      continue;
-    }
-    const pinnedLocally = pin && pin.version === entry.version && pin.sha256 === entry.sha256;
-    if (pinnedLocally) {
-      diff.unchanged.push(entry.name);
-    } else if (pin) {
-      diff.updated.push(entry.name);
+    if (remoteLock) {
+      const remotePin = remoteLock.hooks[entry.name];
+      if (!remotePin) {
+        diff.skipped.push(entry.name);
+        continue;
+      }
+      if (remotePin.version !== entry.version) {
+        throw new Error(`remote registry is ambiguous for '${entry.name}': lock pins ${remotePin.version} but catalog latest is ${entry.version}. ` + `Fix the registry (or its lock) before syncing \u2014 nothing was changed.`);
+      }
+      diff[classifyRemotePin(pin, remotePin.version, remotePin.sha256)].push(entry.name);
     } else {
-      diff.added.push(entry.name);
+      diff[classifyRemotePin(pin, entry.version, entry.sha256)].push(entry.name);
     }
   }
   return diff;
 }
-async function planSync() {
+async function planSync(options = {}) {
   const apiUrl = resolveApiUrl();
   if (apiUrl) {
     const { catalog, remoteLock } = await fetchRemoteState(apiUrl);
-    return { apiUrl, dryRun: false, diff: computeDiff(catalog, remoteLock) };
+    return { apiUrl, dryRun: options.dryRun ?? false, diff: computeDiff(catalog, remoteLock) };
   }
   const diff = computeDiff(collectBundledCatalog(), null);
-  return { apiUrl: null, dryRun: false, diff };
+  return { apiUrl: null, dryRun: options.dryRun ?? false, diff };
 }
 async function syncHooks(options = {}) {
   const apiUrl = resolveApiUrl();
@@ -6923,10 +7175,10 @@ async function syncHooks(options = {}) {
   if (options.dryRun)
     return { ...plan, dryRun: true };
   if (!apiUrl) {
-    const db2 = getDb();
+    const db = getDb();
     for (const entry of collectBundledCatalog()) {
       setPinnedHook(entry.name, { version: entry.version, sha256: entry.sha256, source: "bundled" });
-      upsertHookRecord(db2, {
+      upsertHookRecord(db, {
         name: entry.name,
         version: entry.version,
         sha256: entry.sha256,
@@ -6939,13 +7191,17 @@ async function syncHooks(options = {}) {
   }
   const { catalog, remoteLock } = await fetchRemoteState(apiUrl);
   const diff = computeDiff(catalog, remoteLock);
-  const toFetch = [...diff.added, ...diff.updated];
-  const artifacts = new Map;
-  for (const name of toFetch) {
+  const staged = await stageSyncArtifacts(apiUrl, [...diff.added, ...diff.updated], remoteLock);
+  await commitSyncArtifacts(staged, apiUrl, remoteLock);
+  return { apiUrl, dryRun: false, diff };
+}
+async function stageSyncArtifacts(apiUrl, names, remoteLock) {
+  const staged = [];
+  for (const name of names) {
     const entry = remoteLock.hooks[name];
     if (!entry)
       continue;
-    const artifact = await fetchJson(apiUrl, `/api/v1/hooks/${name}/${entry.version}`);
+    const artifact = await fetchJson(apiUrl, `/api/v1/hooks/${encodeURIComponent(name)}/${encodeURIComponent(entry.version)}`);
     if (!artifact.manifest || typeof artifact.script !== "string") {
       throw new Error(`artifact for '${name}@${entry.version}' is malformed`);
     }
@@ -6953,34 +7209,64 @@ async function syncHooks(options = {}) {
     if (actualSha !== entry.sha256) {
       throw new Error(`sha256 mismatch for '${name}@${entry.version}': lock says ${entry.sha256}, artifact has ${actualSha}`);
     }
-    artifacts.set(name, artifact);
-  }
-  const db = getDb();
-  for (const name of toFetch) {
-    const artifact = artifacts.get(name);
-    const entry = remoteLock.hooks[name];
-    if (!artifact || !entry)
-      continue;
     const manifest = parseManifest(JSON.stringify({ ...artifact.manifest, name: shortManifestName(artifact.manifest.name || name) }));
-    const scriptRel = artifact.manifest.script.includes(`
-`) ? "script.ts" : artifact.manifest.script;
-    writeCustomHook(name, manifest, artifact.script, scriptRel);
-    const scriptPath = resolveScriptPath(name);
-    const actual = await sha256File(scriptPath);
-    if (actual !== entry.sha256) {
-      throw new Error(`sha256 mismatch after write for '${name}@${entry.version}': lock says ${entry.sha256}, on disk ${actual}`);
+    if (manifest.version !== entry.version) {
+      throw new Error(`artifact for '${name}@${entry.version}' declares a different version ('${manifest.version}')`);
     }
-    setPinnedHook(name, { version: entry.version, sha256: entry.sha256, source: entry.source ?? "remote" });
-    upsertHookRecord(db, {
+    const scriptRel = scriptRelFor(manifest);
+    staged.push({
       name,
       version: entry.version,
       sha256: entry.sha256,
-      source_type: entry.source ?? "remote",
-      source_ref: apiUrl,
-      last_verified_at: new Date().toISOString()
+      source: entry.source ?? "remote",
+      manifest,
+      scriptContent: artifact.script,
+      scriptRel
     });
   }
-  return { apiUrl, dryRun: false, diff };
+  return staged;
+}
+async function commitSyncArtifacts(staged, apiUrl, remoteLock) {
+  const db = getDb();
+  for (const item of staged) {
+    const entry = remoteLock.hooks[item.name];
+    if (!entry)
+      continue;
+    writeCustomHook(item.name, item.manifest, item.scriptContent, item.scriptRel);
+    const scriptPath = resolveScriptPath(item.name);
+    const actual = await sha256File(scriptPath);
+    if (actual !== entry.sha256) {
+      throw new Error(`sha256 mismatch after write for '${item.name}@${entry.version}': lock says ${entry.sha256}, on disk ${actual}`);
+    }
+  }
+  const lock = readLock();
+  for (const item of staged) {
+    const entry = remoteLock.hooks[item.name];
+    if (!entry)
+      continue;
+    lock.hooks[item.name] = { version: entry.version, sha256: entry.sha256, source: entry.source ?? "remote" };
+  }
+  writeLock(lock);
+  db.exec("BEGIN");
+  try {
+    for (const item of staged) {
+      const entry = remoteLock.hooks[item.name];
+      if (!entry)
+        continue;
+      upsertHookRecord(db, {
+        name: item.name,
+        version: entry.version,
+        sha256: entry.sha256,
+        source_type: entry.source ?? "remote",
+        source_ref: apiUrl,
+        last_verified_at: new Date().toISOString()
+      });
+    }
+    db.exec("COMMIT");
+  } catch (err) {
+    db.exec("ROLLBACK");
+    throw err;
+  }
 }
 async function fetchPinnedHook(name, version, apiUrl) {
   const remoteLock = await fetchJson(apiUrl, "/api/v1/lock");
@@ -6988,10 +7274,11 @@ async function fetchPinnedHook(name, version, apiUrl) {
   if (!entry) {
     throw new Error(`Hook '${name}' is not in the remote registry lock`);
   }
-  if (entry.version !== version) {
-    throw new Error(`Hook '${name}' version ${version} is not in the remote registry (available: ${entry.version})`);
+  const isLatest = entry.version === version;
+  if (!isLatest && !(entry.versions ?? []).includes(version)) {
+    throw new Error(`Hook '${name}' version ${version} is not in the remote registry (available: ${[entry.version, ...entry.versions ?? []].join(", ")})`);
   }
-  const artifact = await fetchJson(apiUrl, `/api/v1/hooks/${name}/${version}`);
+  const artifact = await fetchJson(apiUrl, `/api/v1/hooks/${encodeURIComponent(name)}/${encodeURIComponent(version)}`, { withHeader: "_headerSha" });
   if (!artifact.manifest || typeof artifact.script !== "string") {
     throw new Error(`artifact for '${name}@${version}' is malformed`);
   }
@@ -7003,24 +7290,31 @@ async function fetchPinnedHook(name, version, apiUrl) {
     throw new Error(`artifact for '${name}@${version}' declares a different version ('${artifact.manifest.version}')`);
   }
   const actualSha = sha256OfText(artifact.script);
-  if (actualSha !== entry.sha256) {
-    throw new Error(`sha256 mismatch for '${name}@${version}': lock says ${entry.sha256}, artifact has ${actualSha}`);
+  let expectedSha = entry.sha256;
+  if (!isLatest) {
+    const headerSha = artifact._headerSha;
+    if (!headerSha) {
+      throw new Error(`registry did not return a sha256 header for '${name}@${version}' (older pin); refusing to trust an unverified artifact`);
+    }
+    expectedSha = headerSha;
+  }
+  if (actualSha !== expectedSha) {
+    throw new Error(`sha256 mismatch for '${name}@${version}': expected ${expectedSha}, artifact has ${actualSha}`);
   }
   const manifest = parseManifest(JSON.stringify({ ...artifact.manifest, name: shortManifestName(artifact.manifest.name || name) }));
-  const scriptRel = artifact.manifest.script.includes(`
-`) ? "script.ts" : artifact.manifest.script;
+  const scriptRel = scriptRelFor(manifest);
   writeCustomHook(name, manifest, artifact.script, scriptRel);
   const scriptPath = resolveScriptPath(name);
   const actual = await sha256File(scriptPath);
-  if (actual !== entry.sha256) {
-    throw new Error(`sha256 mismatch after write for '${name}@${version}': lock says ${entry.sha256}, on disk ${actual}`);
+  if (actual !== expectedSha) {
+    throw new Error(`sha256 mismatch after write for '${name}@${version}': expected ${expectedSha}, on disk ${actual}`);
   }
   const db = getDb();
-  setPinnedHook(name, { version, sha256: entry.sha256, source: entry.source ?? "remote" });
+  setPinnedHook(name, { version, sha256: expectedSha, source: entry.source ?? "remote", pinned: true });
   upsertHookRecord(db, {
     name,
     version,
-    sha256: entry.sha256,
+    sha256: expectedSha,
     source_type: entry.source ?? "remote",
     source_ref: apiUrl,
     last_verified_at: new Date().toISOString()
@@ -7028,7 +7322,7 @@ async function fetchPinnedHook(name, version, apiUrl) {
   return {
     name,
     version,
-    sha256: entry.sha256,
+    sha256: expectedSha,
     source: entry.source ?? "remote",
     source_ref: apiUrl,
     artifact,
@@ -7054,6 +7348,7 @@ function secureEqual(a, b) {
 }
 
 // src/serve.ts
+init_semver();
 var DEFAULT_SERVE_PORT = 39428;
 var SERVE_HOST = "127.0.0.1";
 var SERVE_SERVICE_NAME = "hooks-registry";
@@ -7063,24 +7358,29 @@ async function buildCatalog() {
     const scriptPath = resolveHook(meta.name)?.scriptPath;
     if (!scriptPath)
       continue;
+    const sha = await sha256File(scriptPath);
     byName.set(meta.name, {
       name: meta.name,
       version: meta.version,
-      sha256: await sha256File(scriptPath),
+      sha256: sha,
       events: meta.events && meta.events.length > 0 ? meta.events : [meta.event],
       description: meta.description,
-      source: "bundled"
+      source: "bundled",
+      versions: [meta.version]
     });
   }
   for (const custom2 of listCustomHooks()) {
     const name = shortManifestName(custom2.manifest.name);
+    const sha = await sha256File(custom2.scriptPath);
+    const existing = byName.get(name);
     byName.set(name, {
       name,
       version: custom2.manifest.version,
-      sha256: await sha256File(custom2.scriptPath),
+      sha256: sha,
       events: custom2.manifest.events,
       description: custom2.manifest.description ?? "Custom hook",
-      source: byName.has(name) ? "custom-overrides-bundled" : "custom"
+      source: existing ? "custom-overrides-bundled" : "custom",
+      versions: existing ? [...new Set([...existing.versions, custom2.manifest.version])] : [custom2.manifest.version]
     });
   }
   return [...byName.values()].sort((a, b) => a.name.localeCompare(b.name));
@@ -7098,6 +7398,7 @@ async function artifactFor(name, version) {
     description: resolved.description,
     events: resolved.events,
     script: custom2 ? custom2.manifest.script : `src/hook.ts`,
+    script_kind: custom2?.manifest.script_kind,
     args: custom2?.manifest.args,
     timeout_ms: custom2?.manifest.timeout_ms
   };
@@ -7127,11 +7428,32 @@ function handleServeRequest(req, apiKey) {
     return buildCatalog().then((catalog) => json({ hooks: catalog }));
   }
   if (url.pathname === "/api/v1/lock" && req.method === "GET") {
-    return Promise.resolve(json(readLock()));
+    return buildCatalog().then((catalog) => {
+      const lock = readLock();
+      const byVersion = {};
+      for (const entry of catalog)
+        byVersion[entry.name] = entry.versions;
+      const hooks = {};
+      for (const [name, pin] of Object.entries(lock.hooks)) {
+        hooks[name] = { ...pin, versions: byVersion[name] ?? [pin.version] };
+      }
+      return json({ hooks });
+    });
   }
-  const artifactMatch = /^\/api\/v1\/hooks\/([\w-]+)\/(\d+\.\d+\.\d+)$/.exec(url.pathname);
+  const artifactMatch = /^\/api\/v1\/hooks\/([\w-]+)\/([0-9A-Za-z.%+_-]+)$/.exec(url.pathname);
   if (artifactMatch && req.method === "GET") {
-    const [, name, version] = artifactMatch;
+    const [, rawName, rawVersion] = artifactMatch;
+    let name;
+    let version;
+    try {
+      name = decodeURIComponent(rawName);
+      version = decodeURIComponent(rawVersion);
+    } catch {
+      return Promise.resolve(json({ error: "invalid URL encoding" }, 400));
+    }
+    if (!SEMVER_PATTERN.test(version)) {
+      return Promise.resolve(json({ error: `invalid semver version '${version}'` }, 400));
+    }
     return artifactFor(name, version).then(async (artifact) => {
       if (!artifact)
         return json({ error: `Hook '${name}@${version}' not found locally` }, 404);
@@ -7162,7 +7484,7 @@ function handleServeRequest(req, apiKey) {
 function startServeServer(options) {
   const port = options.port ?? DEFAULT_SERVE_PORT;
   const host = options.host ?? SERVE_HOST;
-  const apiKey = resolveApiKey(options.apiKey);
+  const apiKey = resolveApiKey();
   const server = Bun.serve({
     hostname: host,
     port,
@@ -7308,7 +7630,6 @@ async function runHook(name, input, options = {}) {
       content,
       args: custom2?.manifest.args ?? [],
       stdin: JSON.stringify(hookInput),
-      env: process.env,
       timeout: effectiveTimeout ?? undefined
     }));
   } catch (err) {