@hasna/hooks 0.7.10 → 0.8.0

package/bin/serve.js

@@ -17,90 +17,83 @@ var __export = (target, all) => {
 
 // src/lib/app-home.ts
 import { existsSync } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join2, resolve } from "path";
-
-// ../../node_modules/.bun/@hasna+paths@0.1.0/node_modules/@hasna/paths/dist/index.js
 import { homedir } from "os";
-import { join } from "path";
-var KIND_ENV = {
+import { join, resolve } from "path";
+import { homedir as pathsResolverHomedir } from "os";
+import { join as pathsResolverJoin } from "path";
+var PATHS_RESOLVER_KIND_ENV = {
   config: "HASNA_CONFIG_HOME",
   data: "HASNA_DATA_HOME",
   state: "HASNA_STATE_HOME",
   cache: "HASNA_CACHE_HOME"
 };
-var APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
-function assertApp(app) {
+var PATHS_RESOLVER_APP_SLUG_RE = /^[a-z0-9]+(?:-[a-z0-9]+)*$/;
+function pathsResolverAssertApp(app) {
   if (typeof app !== "string" || app.length === 0) {
     throw new TypeError("paths: app must be a non-empty string");
   }
-  if (!APP_SLUG_RE.test(app)) {
+  if (!PATHS_RESOLVER_APP_SLUG_RE.test(app)) {
     throw new TypeError(`paths: invalid app slug "${app}" \u2014 expected lowercase kebab-case ([a-z0-9]+(-[a-z0-9]+)*)`);
   }
 }
-function envOf(options) {
-  return options.env ?? process.env;
-}
-function envValue(options, kind) {
-  const value = envOf(options)[KIND_ENV[kind]];
-  return typeof value === "string" && value.length > 0 ? value : undefined;
-}
-function isMacOS(platform) {
-  return platform === "darwin";
+function pathsResolverAssertKind(kind) {
+  if (!Object.keys(PATHS_RESOLVER_KIND_ENV).includes(kind)) {
+    throw new TypeError(`paths: invalid path kind "${kind}" \u2014 expected one of ${Object.keys(PATHS_RESOLVER_KIND_ENV).join(", ")}`);
+  }
 }
-function baseDir(kind, options) {
-  const override = envValue(options, kind);
-  if (override)
+function pathsResolverBaseDir(kind, options) {
+  pathsResolverAssertKind(kind);
+  const env = options.env ?? process.env;
+  const override = env[PATHS_RESOLVER_KIND_ENV[kind]];
+  if (typeof override === "string" && override.length > 0)
     return override;
-  const home = options.home ?? homedir();
+  const home = options.home ?? pathsResolverHomedir();
   const platform = options.platform ?? process.platform;
-  if (isMacOS(platform)) {
+  if (platform === "darwin") {
     switch (kind) {
       case "config":
       case "data":
-        return join(home, "Library", "Application Support", "Hasna");
+        return pathsResolverJoin(home, "Library", "Application Support", "Hasna");
       case "cache":
-        return join(home, "Library", "Caches", "Hasna");
+        return pathsResolverJoin(home, "Library", "Caches", "Hasna");
       case "state":
-        return join(home, "Library", "Logs", "Hasna");
+        return pathsResolverJoin(home, "Library", "Logs", "Hasna");
     }
   }
   switch (kind) {
     case "config":
-      return join(home, ".config", "hasna");
+      return pathsResolverJoin(home, ".config", "hasna");
     case "data":
-      return join(home, ".local", "share", "hasna");
+      return pathsResolverJoin(home, ".local", "share", "hasna");
     case "state":
-      return join(home, ".local", "state", "hasna");
+      return pathsResolverJoin(home, ".local", "state", "hasna");
     case "cache":
-      return join(home, ".cache", "hasna");
+      return pathsResolverJoin(home, ".cache", "hasna");
   }
 }
-function resolvePath(kind, options) {
-  assertApp(options.app);
-  const appSegment = options.internal === true ? join("internal", options.app) : options.app;
-  return join(baseDir(kind, options), appSegment);
+function pathsResolverResolve(kind, options) {
+  pathsResolverAssertApp(options.app);
+  const appSegment = options.internal === true ? pathsResolverJoin("internal", options.app) : options.app;
+  return pathsResolverJoin(pathsResolverBaseDir(kind, options), appSegment);
 }
 function dataDir(options) {
-  return resolvePath("data", options);
+  return pathsResolverResolve("data", options);
 }
-
-// src/lib/app-home.ts
 var STORE_MARKER = "hooks.db";
 function getHomeDir(env = process.env) {
-  return env.HOME || env.USERPROFILE || homedir2();
+  return env.HOME || env.USERPROFILE || homedir();
 }
 function getResolverDataRoot(env = process.env) {
   return dataDir({ app: "hooks", home: getHomeDir(env), env });
 }
 function getLegacyDataRoot(env = process.env) {
-  return join2(getHomeDir(env), ".hasna", "hooks");
+  return join(getHomeDir(env), ".hasna", "hooks");
 }
 function adoptResolverDataRoot(resolved, env = process.env) {
   const dataOverride = env.HASNA_DATA_HOME;
   if (typeof dataOverride === "string" && dataOverride.trim().length > 0)
     return true;
-  return existsSync(join2(resolved, STORE_MARKER));
+  return existsSync(join(resolved, STORE_MARKER));
 }
 function getExplicitDataDir(env = process.env) {
   const dir = env.HASNA_HOOKS_DATA_DIR ?? env.HOOKS_DATA_DIR;
@@ -128,7 +121,7 @@ function getReportedDbPath(env = process.env) {
   const explicit = getExplicitDbPath(env);
   if (explicit)
     return explicit;
-  return join2(getEffectiveDataRoot(env), "hooks.db");
+  return join(getEffectiveDataRoot(env), "hooks.db");
 }
 function getExplicitDbPath(env = process.env) {
   const db = env.HASNA_HOOKS_DB_PATH ?? env.HOOKS_DB_PATH;
@@ -656,8 +649,8 @@ function getHook(name) {
 }
 
 // src/lib/manifest.ts
-import { existsSync as existsSync2, mkdirSync, readFileSync as readFileSync2, readdirSync, realpathSync, writeFileSync } from "fs";
-import { basename, dirname, isAbsolute, join as join5, normalize, resolve as resolve2, sep } from "path";
+import { existsSync as existsSync2, mkdirSync, readFileSync, readdirSync, realpathSync, writeFileSync } from "fs";
+import { basename, dirname, isAbsolute, join as join3, normalize, resolve as resolve2, sep } from "path";
 
 // ../../node_modules/.bun/zod@3.25.76/node_modules/zod/v3/external.js
 var exports_external = {};
@@ -4632,519 +4625,161 @@ var coerce = {
   date: (arg) => ZodDate.create({ ...arg, coerce: true })
 };
 var NEVER = INVALID;
-// ../contracts/dist/client/transport.js
-import { readFileSync, statSync } from "fs";
-import { createRequire } from "module";
-import { join as join3 } from "path";
-function envToken(name) {
-  return name.toUpperCase().replace(/-/g, "_");
-}
-function clientTransportEnvKeys(name) {
-  const envSegment = envToken(name);
-  return {
-    apiUrlKeys: [`HASNA_${envSegment}_API_URL`, `${envSegment}_API_URL`],
-    apiKeyKeys: [`HASNA_${envSegment}_API_KEY`, `${envSegment}_API_KEY`]
-  };
+// src/config.ts
+import { join as join2 } from "path";
+function getHooksDataDir() {
+  return getEffectiveDataRoot();
 }
-function credentialOverrideEnvKey(name) {
-  return `HASNA_${envToken(name)}_API_KEY_OVERRIDE`;
+function getCustomHooksDir() {
+  return join2(getHooksDataDir(), "hooks");
 }
-var CREDENTIAL_PROFILE_ENV_KEY = "HASNA_PROFILE";
-function credentialPointerEnvKey(name) {
-  return `HASNA_${envToken(name)}_API_KEY_REF`;
+function getLockPath() {
+  const explicit = process.env.HASNA_HOOKS_LOCK_PATH ?? process.env.HOOKS_LOCK_PATH;
+  if (explicit)
+    return explicit;
+  return join2(getHooksDataDir(), "hooks.lock");
 }
 
-class CredentialResolutionError extends Error {
-  appName;
-  attempted;
-  constructor(appName, message, attempted) {
-    super(message);
-    this.name = "CredentialResolutionError";
-    this.appName = appName;
-    this.attempted = attempted;
-  }
+// src/lib/semver.ts
+var NUMERIC_ID = "(0|[1-9]\\d{0,15})";
+var ALNUM_ID = "\\d*[A-Za-z-][0-9A-Za-z-]*";
+var SEMVER_PATTERN = new RegExp(`^${NUMERIC_ID}\\.${NUMERIC_ID}\\.${NUMERIC_ID}` + `(?:-(?:${NUMERIC_ID}|${ALNUM_ID})(?:\\.(?:${NUMERIC_ID}|${ALNUM_ID}))*)?` + `(?:\\+[0-9A-Za-z.-]+)?$`);
+
+// src/lib/manifest.ts
+var HOOK_NAME_RE = /^[\w-]+$/;
+var manifestSchema = exports_external.object({
+  name: exports_external.string().regex(HOOK_NAME_RE, "hook name must be /^[\\w-]+$/"),
+  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(),
+  env: exports_external.record(exports_external.string(), exports_external.string()).optional()
+});
+function parseManifest(json) {
+  const parsed = JSON.parse(json);
+  return manifestSchema.parse(parsed);
 }
-var HASNA_STATE_DIR = ".hasna";
-var FLEET_CREDENTIAL_DIR = "fleet-env";
-var LEGACY_CLOUD_DIR = "cloud";
-var CONFIG_DIR = ".config";
-var CONFIG_NAMESPACE = "hasna";
-var LEGACY_CLOUD_REMOVAL_DEADLINE = "2026-10-01";
-var MAX_CREDENTIAL_FILE_BYTES = 64 * 1024;
-var SAFE_APP_SLUG = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
-var SAFE_PROFILE = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
-var ILLEGAL_IN_HEADER_VALUE = /[^\t\x20-\x7e]/;
-var VAULT_POINTER_SHAPE = /^[a-z0-9][a-z0-9-]*(?:\/[a-z0-9][a-z0-9-_.]*){2,}$/;
-function homeDir(env) {
-  const home = env.HOME?.trim();
-  return home ? home : null;
+function shortManifestName(name) {
+  return name.startsWith("hook-") ? name.slice("hook-".length) : name;
 }
-function credentialDiskSourceList(name, env, profile = null) {
-  const home = homeDir(env);
-  if (!home || !SAFE_APP_SLUG.test(name))
-    return [];
-  const stem = profile ? `${name}.${profile}` : name;
-  const configStem = profile ? `${name}-${profile}` : name;
-  return [
-    {
-      path: join3(home, HASNA_STATE_DIR, FLEET_CREDENTIAL_DIR, `${stem}.env`),
-      tier: "fleet-env",
-      deprecated: false
-    },
-    {
-      path: join3(home, HASNA_STATE_DIR, LEGACY_CLOUD_DIR, `${stem}.env`),
-      tier: "legacy-cloud",
-      deprecated: true
-    },
-    {
-      path: join3(home, CONFIG_DIR, CONFIG_NAMESPACE, `${configStem}.env`),
-      tier: "config",
-      deprecated: false
-    },
-    {
-      path: join3(home, CONFIG_DIR, CONFIG_NAMESPACE, `${configStem}-cloud.env`),
-      tier: "config-legacy",
-      deprecated: true
-    }
-  ];
+
+class ScriptContainmentError extends Error {
+  constructor(path, hookDir, raw) {
+    super(raw && raw !== path ? `manifest script escapes the hook directory: '${path}' (from '${raw}') resolves outside '${hookDir}'` : `manifest script escapes the hook directory: '${path}' resolves outside '${hookDir}'`);
+    this.name = "ScriptContainmentError";
+  }
 }
-function credentialDiskSources(name, env) {
-  return credentialDiskSourceList(name, env, null).map((s) => s.path);
+function isWithin(child, parent) {
+  return child === parent || child.startsWith(parent + sep);
 }
-function profileDiskSources(name, env, profile) {
-  return credentialDiskSourceList(name, env, profile).map((s) => s.path);
+function assertContainedLexical(target, root, raw) {
+  const lexical = resolve2(target);
+  const rootLexical = resolve2(root);
+  if (!isWithin(lexical, rootLexical)) {
+    throw new ScriptContainmentError(target, root, raw);
+  }
+  return lexical;
 }
-function parseEnvFile(text) {
-  const values = new Map;
-  for (const rawLine of text.split(/\r?\n/)) {
-    const line = rawLine.trim();
-    if (line.length === 0 || line.startsWith("#"))
-      continue;
-    const withoutExport = line.startsWith("export ") ? line.slice("export ".length).trim() : line;
-    const equals = withoutExport.indexOf("=");
-    if (equals <= 0)
-      continue;
-    const key = withoutExport.slice(0, equals).trim();
-    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
-      continue;
-    let value = withoutExport.slice(equals + 1).trim();
-    const quote = value[0];
-    if (quote === '"' || quote === "'") {
-      if (value.length < 2 || !value.endsWith(quote))
-        continue;
-      value = value.slice(1, -1);
-    }
-    if (value.length === 0)
-      continue;
-    values.set(key, value);
+function realpathNearest(path) {
+  const tail = [];
+  let cur = path;
+  while (!existsSync2(cur)) {
+    const parent = dirname(cur);
+    if (parent === cur)
+      break;
+    tail.unshift(basename(cur));
+    cur = parent;
   }
-  return values;
+  return join3(realpathSync(cur), ...tail);
 }
-function readAppConfigFile(path) {
-  let text;
-  try {
-    const stats = statSync(path);
-    if (!stats.isFile() || stats.size > MAX_CREDENTIAL_FILE_BYTES)
-      return null;
-    text = readFileSync(path, "utf8");
-  } catch {
-    return null;
+function assertContainedReal(root, target, raw) {
+  const rootReal = realpathSync(root);
+  const targetReal = realpathNearest(target);
+  if (!isWithin(targetReal, rootReal)) {
+    throw new ScriptContainmentError(target, root, raw);
   }
-  return parseEnvFile(text);
 }
-function readCredentialFile(path, apiKeyKeys) {
-  const values = readAppConfigFile(path);
-  if (!values)
-    return null;
-  for (const key of apiKeyKeys) {
-    const value = values.get(key)?.trim();
-    if (value)
-      return value;
+function assertContained(target, root, raw) {
+  const lexical = assertContainedLexical(target, root, raw);
+  assertContainedReal(root, lexical, raw);
+  return lexical;
+}
+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 `script${ext}`;
   }
-  return null;
+  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 assertUsableCredential(appName, source, value) {
-  if (VAULT_POINTER_SHAPE.test(value)) {
-    throw new CredentialResolutionError(appName, `The credential from ${source} looks like a secrets-vault pointer (a path-shaped reference like ` + `'namespace/app/live/api_key'). A vault path is NEVER accepted as a literal API key. ` + `Use ${credentialPointerEnvKey(appName)} to resolve the key through the vault, or provide the actual key value.`, [source]);
+function resolveScript(manifest, manifestDir) {
+  if (isInlineScript(manifest))
+    return { path: scriptRelFor(manifest), content: manifest.script };
+  const rel = scriptRelFor(manifest);
+  const resolved = assertContained(join3(manifestDir, rel), manifestDir, manifest.script);
+  if (!existsSync2(resolved)) {
+    throw new Error(`manifest script file not found: ${resolved}`);
   }
-  if (!ILLEGAL_IN_HEADER_VALUE.test(value))
-    return;
-  throw new CredentialResolutionError(appName, `The credential from ${source} contains characters that cannot be sent in an HTTP header ` + `(a control character or non-ASCII byte). A file written with CR-only line endings is the usual ` + `cause. Rewrite that credential file with one LF-terminated KEY=value line. ` + `The value is not shown here, and is deliberately never logged.`, [source]);
+  return { path: rel, content: readFileSync(resolved, "utf-8") };
 }
-var INSPECT_CUSTOM = Symbol.for("nodejs.util.inspect.custom");
-var CREDENTIAL_SEAL = Symbol.for("hasna:contracts:sealedCredential");
-function sealCredential(fields) {
-  const { apiKey } = fields;
-  const visible = {
-    tier: fields.tier,
-    source: fields.source,
-    deliberate: fields.deliberate,
-    deprecated: fields.deprecated,
-    diskCandidates: Object.freeze([...fields.diskCandidates]),
-    warning: fields.warning
-  };
-  const sealed = { ...visible };
-  Object.defineProperty(sealed, "apiKey", {
-    value: apiKey,
-    enumerable: false,
-    writable: false,
-    configurable: false
-  });
-  if (fields.pointerVaultKey !== undefined) {
-    Object.defineProperty(sealed, "pointerVaultKey", {
-      value: fields.pointerVaultKey,
-      enumerable: false,
-      writable: false,
-      configurable: false
-    });
+function customHookDir(name) {
+  return join3(getCustomHooksDir(), shortManifestName(name));
+}
+function readCustomManifest(name) {
+  const dir = customHookDir(name);
+  const manifestPath = join3(dir, "manifest.json");
+  if (!existsSync2(manifestPath))
+    return;
+  try {
+    const manifest = parseManifest(readFileSync(manifestPath, "utf-8"));
+    const script = resolveScript(manifest, dir);
+    const scriptIsInline = isInlineScript(manifest);
+    return { manifest, scriptPath: join3(dir, script.path), scriptContent: script.content, scriptIsInline };
+  } catch (err) {
+    if (err instanceof ScriptContainmentError)
+      throw err;
+    return;
   }
-  Object.defineProperty(sealed, INSPECT_CUSTOM, {
-    value: () => ({ ...visible, apiKey: "[redacted]" }),
-    enumerable: false,
-    writable: false,
-    configurable: false
-  });
-  Object.defineProperty(sealed, CREDENTIAL_SEAL, {
-    value: true,
-    enumerable: false,
-    writable: false,
-    configurable: false
-  });
-  return Object.freeze(sealed);
 }
-function firstEnvValue(env, keys) {
-  for (const key of keys) {
-    const value = env[key]?.trim();
-    if (value)
-      return { key, value };
+function listCustomHooks() {
+  const dir = getCustomHooksDir();
+  if (!existsSync2(dir))
+    return [];
+  const results = [];
+  for (const entry of readdirSafe(dir)) {
+    const parsed = readCustomManifest(entry);
+    if (parsed)
+      results.push(parsed);
   }
-  return null;
+  return results.sort((a, b) => a.manifest.name.localeCompare(b.manifest.name));
 }
-var DEPRECATION_REGISTRY = Symbol.for("hasna:contracts:credentialDeprecationNotices");
-function deprecationNotified() {
-  const host = globalThis;
-  const existing = host[DEPRECATION_REGISTRY];
-  if (existing instanceof Set)
-    return existing;
-  const created = new Set;
-  host[DEPRECATION_REGISTRY] = created;
-  return created;
-}
-function defaultDeprecationSink(message) {
-  if (typeof process !== "undefined" && process.stderr) {
-    process.stderr.write(`${message}
-`);
-  }
-}
-function resolveCredential(name, env, options = {}) {
-  const { apiKeyKeys } = clientTransportEnvKeys(name);
-  const diskPaths = credentialDiskSources(name, env);
-  const explicitKey = options.apiKey?.trim();
-  if (explicitKey) {
-    assertUsableCredential(name, "the explicit apiKey argument", explicitKey);
-    return sealCredential({
-      apiKey: explicitKey,
-      tier: "argument",
-      source: "explicit apiKey argument",
-      deliberate: true,
-      deprecated: false,
-      diskCandidates: diskPaths,
-      warning: null
-    });
-  }
-  const overrideKeyName = credentialOverrideEnvKey(name);
-  const overrideRaw = env[overrideKeyName];
-  if (overrideRaw !== undefined) {
-    const override = overrideRaw.trim();
-    if (!override) {
-      throw new CredentialResolutionError(name, `${overrideKeyName} is set but empty. It is a deliberate override, so it is not resolved around: ` + `either give it a real key or unset it to fall back to the credential on disk.`, [overrideKeyName]);
-    }
-    assertUsableCredential(name, overrideKeyName, override);
-    return sealCredential({
-      apiKey: override,
-      tier: "override",
-      source: overrideKeyName,
-      deliberate: true,
-      deprecated: false,
-      diskCandidates: diskPaths,
-      warning: null
-    });
-  }
-  const pointerKeyName = credentialPointerEnvKey(name);
-  const pointerRaw = env[pointerKeyName];
-  if (pointerRaw !== undefined) {
-    const pointer = pointerRaw.trim();
-    if (!pointer) {
-      throw new CredentialResolutionError(name, `${pointerKeyName} is set but empty. It is a deliberate vault pointer, so it is not resolved around: ` + `either give it a vault item key or unset it to fall back to the credential on disk.`, [pointerKeyName]);
-    }
-    if (!VAULT_POINTER_SHAPE.test(pointer)) {
-      throw new CredentialResolutionError(name, `${pointerKeyName} must name a vault ITEM KEY (a path-shaped reference like ` + `'namespace/app/live/api_key'), not a credential value. A pointer that carries a literal is refused.`, [pointerKeyName]);
-    }
-    return sealCredential({
-      apiKey: "",
-      pointerVaultKey: pointer,
-      tier: "pointer",
-      source: pointerKeyName,
-      deliberate: true,
-      deprecated: false,
-      diskCandidates: diskPaths,
-      warning: null
-    });
-  }
-  const profile = options.profile?.trim() || env[CREDENTIAL_PROFILE_ENV_KEY]?.trim();
-  if (profile) {
-    const profileSource = options.profile?.trim() ? "explicit profile argument" : CREDENTIAL_PROFILE_ENV_KEY;
-    if (!SAFE_PROFILE.test(profile)) {
-      throw new CredentialResolutionError(name, `Profile name from ${profileSource} is not usable in a path. ` + `Use letters, digits, dot, dash, or underscore.`, [profileSource]);
-    }
-    const paths = profileDiskSources(name, env, profile);
-    for (const path of paths) {
-      const value = readCredentialFile(path, apiKeyKeys);
-      if (value) {
-        assertUsableCredential(name, path, value);
-        return sealCredential({
-          apiKey: value,
-          tier: "profile",
-          source: path,
-          deliberate: true,
-          deprecated: false,
-          diskCandidates: paths,
-          warning: null
-        });
-      }
-    }
-    throw new CredentialResolutionError(name, `Profile '${profile}' (from ${profileSource}) has no ${apiKeyKeys[0]} for '${name}'. ` + `Looked in: ${paths.join(", ") || "<no HOME in this environment>"}. ` + `A profile names WHICH identity to use, so it is never resolved around \u2014 ` + `create the profile's credential file or unset ${CREDENTIAL_PROFILE_ENV_KEY}.`, paths);
-  }
-  const diskSourceList = credentialDiskSourceList(name, env, null);
-  const diskHits = diskSourceList.map((src) => ({ src, value: readCredentialFile(src.path, apiKeyKeys) })).filter((hit) => hit.value !== null);
-  if (diskHits.length > 0) {
-    const winner = diskHits[0];
-    assertUsableCredential(name, winner.src.path, winner.value);
-    const divergentSources = [
-      ...diskHits.slice(1).filter((hit) => hit.value !== winner.value).map((hit) => hit.src.path),
-      ...(() => {
-        const legacyHit = firstEnvValue(env, apiKeyKeys);
-        return legacyHit && legacyHit.value !== winner.value ? [legacyHit.key] : [];
-      })()
-    ];
-    const warning = divergentSources.length > 0 ? `Credential sources disagree for '${name}': ${winner.src.path} and ` + `${divergentSources.join(", ")} hold different keys. ${winner.src.path} wins, because a file on ` + `disk is re-read on every call while an environment variable is a snapshot. Reconcile them \u2014 ` + `a rotation that updated only one leaves the other to fail 401 wherever it is loaded first.` : null;
-    let deprecated = winner.src.deprecated;
-    let finalWarning = warning;
-    if (winner.src.deprecated) {
-      deprecated = true;
-      const sink = options.onDeprecation ?? defaultDeprecationSink;
-      const notified = deprecationNotified();
-      const noticeKey = `${name}:${winner.src.path}`;
-      if (!notified.has(noticeKey)) {
-        notified.add(noticeKey);
-        const target = diskSourceList[0]?.path ?? "<none>";
-        const message = `[${name}] DEPRECATED: the API key came from ${winner.src.path} \u2014 a legacy credential location. ` + `The primary location is ${target} (~/.hasna/fleet-env/<app>.env). The legacy 'cloud' tiers are ` + `removed after ${LEGACY_CLOUD_REMOVAL_DEADLINE}. Migrate the key to the primary location.`;
-        sink(message);
-      }
-      finalWarning = [warning, `Legacy credential source: ${winner.src.path}. Removed after ${LEGACY_CLOUD_REMOVAL_DEADLINE}.`].filter(Boolean).join(" ") || null;
-    }
-    return sealCredential({
-      apiKey: winner.value,
-      tier: winner.src.tier,
-      source: winner.src.path,
-      deliberate: false,
-      deprecated,
-      diskCandidates: diskPaths,
-      warning: finalWarning
-    });
-  }
-  const legacy = firstEnvValue(env, apiKeyKeys);
-  if (legacy) {
-    assertUsableCredential(name, legacy.key, legacy.value);
-    const where = diskPaths.length > 0 ? `Put the current key in ${diskPaths[0]} \u2014 it is re-read on every call, so rotations take effect immediately.` : `This environment has no HOME, so no credential file could be consulted at all; the disk tier is ` + `unavailable here and this process will keep using the environment snapshot.`;
-    const message = `[${name}] DEPRECATED: the API key came from ${legacy.key} in this process's environment. ` + `Environment variables are a snapshot taken when this process started, so a shell that started ` + `before a key rotation keeps using the old key until it exits. ${where}`;
-    const sink = options.onDeprecation ?? defaultDeprecationSink;
-    const notified = deprecationNotified();
-    if (!notified.has(name)) {
-      notified.add(name);
-      sink(message);
-    }
-    return sealCredential({
-      apiKey: legacy.value,
-      tier: "legacy-env",
-      source: legacy.key,
-      deliberate: false,
-      deprecated: true,
-      diskCandidates: diskPaths,
-      warning: message
-    });
-  }
-  return null;
-}
-var SECRETS_PACKAGE_SPECIFIER = "@hasna/" + "secrets";
-var requireSecretsSdk = createRequire(import.meta.url);
-var IDEMPOTENT_METHODS = new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
-var AUTHORITY_OVERRIDE_HEADERS = new Set([
-  "host",
-  ":authority",
-  "forwarded",
-  "x-forwarded-host",
-  "x-original-host"
-]);
-
-// src/config.ts
-import { join as join4 } from "path";
-function getHooksDataDir() {
-  return getEffectiveDataRoot();
-}
-function getCustomHooksDir() {
-  return join4(getHooksDataDir(), "hooks");
-}
-function getLockPath() {
-  const explicit = process.env.HASNA_HOOKS_LOCK_PATH ?? process.env.HOOKS_LOCK_PATH;
-  if (explicit)
-    return explicit;
-  return join4(getHooksDataDir(), "hooks.lock");
-}
-function resolveApiKey() {
-  return resolveCredential("hooks", process.env)?.apiKey;
-}
-
-// src/lib/semver.ts
-var NUMERIC_ID = "(0|[1-9]\\d{0,15})";
-var ALNUM_ID = "\\d*[A-Za-z-][0-9A-Za-z-]*";
-var SEMVER_PATTERN = new RegExp(`^${NUMERIC_ID}\\.${NUMERIC_ID}\\.${NUMERIC_ID}` + `(?:-(?:${NUMERIC_ID}|${ALNUM_ID})(?:\\.(?:${NUMERIC_ID}|${ALNUM_ID}))*)?` + `(?:\\+[0-9A-Za-z.-]+)?$`);
-
-// src/lib/manifest.ts
-var HOOK_NAME_RE = /^[\w-]+$/;
-var manifestSchema = exports_external.object({
-  name: exports_external.string().regex(HOOK_NAME_RE, "hook name must be /^[\\w-]+$/"),
-  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(),
-  env: exports_external.record(exports_external.string(), exports_external.string()).optional()
-});
-function parseManifest(json) {
-  const parsed = JSON.parse(json);
-  return manifestSchema.parse(parsed);
-}
-function shortManifestName(name) {
-  return name.startsWith("hook-") ? name.slice("hook-".length) : name;
-}
-
-class ScriptContainmentError extends Error {
-  constructor(path, hookDir, raw) {
-    super(raw && raw !== path ? `manifest script escapes the hook directory: '${path}' (from '${raw}') resolves outside '${hookDir}'` : `manifest script escapes the hook directory: '${path}' resolves outside '${hookDir}'`);
-    this.name = "ScriptContainmentError";
-  }
-}
-function isWithin(child, parent) {
-  return child === parent || child.startsWith(parent + sep);
-}
-function assertContainedLexical(target, root, raw) {
-  const lexical = resolve2(target);
-  const rootLexical = resolve2(root);
-  if (!isWithin(lexical, rootLexical)) {
-    throw new ScriptContainmentError(target, root, raw);
-  }
-  return lexical;
-}
-function realpathNearest(path) {
-  const tail = [];
-  let cur = path;
-  while (!existsSync2(cur)) {
-    const parent = dirname(cur);
-    if (parent === cur)
-      break;
-    tail.unshift(basename(cur));
-    cur = parent;
-  }
-  return join5(realpathSync(cur), ...tail);
-}
-function assertContainedReal(root, target, raw) {
-  const rootReal = realpathSync(root);
-  const targetReal = realpathNearest(target);
-  if (!isWithin(targetReal, rootReal)) {
-    throw new ScriptContainmentError(target, root, raw);
-  }
-}
-function assertContained(target, root, raw) {
-  const lexical = assertContainedLexical(target, root, raw);
-  assertContainedReal(root, lexical, raw);
-  return lexical;
-}
-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 `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(join5(manifestDir, rel), manifestDir, manifest.script);
-  if (!existsSync2(resolved)) {
-    throw new Error(`manifest script file not found: ${resolved}`);
-  }
-  return { path: rel, content: readFileSync2(resolved, "utf-8") };
-}
-function customHookDir(name) {
-  return join5(getCustomHooksDir(), shortManifestName(name));
-}
-function readCustomManifest(name) {
-  const dir = customHookDir(name);
-  const manifestPath = join5(dir, "manifest.json");
-  if (!existsSync2(manifestPath))
-    return;
-  try {
-    const manifest = parseManifest(readFileSync2(manifestPath, "utf-8"));
-    const script = resolveScript(manifest, dir);
-    const scriptIsInline = isInlineScript(manifest);
-    return { manifest, scriptPath: join5(dir, script.path), scriptContent: script.content, scriptIsInline };
-  } catch (err) {
-    if (err instanceof ScriptContainmentError)
-      throw err;
-    return;
-  }
-}
-function listCustomHooks() {
-  const dir = getCustomHooksDir();
-  if (!existsSync2(dir))
-    return [];
-  const results = [];
-  for (const entry of readdirSafe(dir)) {
-    const parsed = readCustomManifest(entry);
-    if (parsed)
-      results.push(parsed);
-  }
-  return results.sort((a, b) => a.manifest.name.localeCompare(b.manifest.name));
-}
-function readdirSafe(dir) {
-  try {
-    return readdirSync(dir);
-  } catch {
-    return [];
+function readdirSafe(dir) {
+  try {
+    return readdirSync(dir);
+  } catch {
+    return [];
   }
 }
 
 // src/lib/store.ts
 import { createHash } from "crypto";
-import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync4, writeFileSync as writeFileSync2, renameSync } from "fs";
+import { existsSync as existsSync5, mkdirSync as mkdirSync3, readFileSync as readFileSync3, writeFileSync as writeFileSync2, renameSync } from "fs";
 import { readFile } from "fs/promises";
 
 // src/db/index.ts
 import { Database } from "bun:sqlite";
 import { existsSync as existsSync4, mkdirSync as mkdirSync2, cpSync } from "fs";
-import { join as join7 } from "path";
+import { join as join5 } from "path";
 
 // src/db/schema.ts
 var CREATE_HOOK_EVENTS_TABLE = `
@@ -5316,9 +4951,9 @@ function runMigrations(db) {
 }
 
 // src/db/legacy-import.ts
-import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync3 } from "fs";
-import { join as join6 } from "path";
-import { homedir as homedir3 } from "os";
+import { existsSync as existsSync3, readdirSync as readdirSync2, readFileSync as readFileSync2 } from "fs";
+import { join as join4 } from "path";
+import { homedir as homedir2 } from "os";
 var META_KEY = "legacy_import_done";
 function ensureMetaTable(db) {
   db.exec(`
@@ -5342,7 +4977,7 @@ function nanoid() {
 function importJsonlFile(db, filePath) {
   let count = 0;
   try {
-    const lines = readFileSync3(filePath, "utf-8").split(`
+    const lines = readFileSync2(filePath, "utf-8").split(`
 `).filter(Boolean);
     for (const line of lines) {
       try {
@@ -5368,7 +5003,7 @@ function importJsonlFile(db, filePath) {
 function importErrorsLog(db, filePath) {
   let count = 0;
   try {
-    const lines = readFileSync3(filePath, "utf-8").split(`
+    const lines = readFileSync2(filePath, "utf-8").split(`
 `).filter(Boolean);
     const linePattern = /^\[(.+?)\]\s+(?:\[session:(\S+)\]\s+)?(.+?)\s+\u2014\s+(.+)$/;
     for (const line of lines) {
@@ -5393,25 +5028,25 @@ function importErrorsLog(db, filePath) {
   } catch {}
   return count;
 }
-function runLegacyImport(db, homeDir2 = homedir3()) {
+function runLegacyImport(db, homeDir = homedir2()) {
   try {
     if (isAlreadyDone(db))
       return;
     let total = 0;
-    const claudeProjectsDir = join6(homeDir2, ".claude", "projects");
+    const claudeProjectsDir = join4(homeDir, ".claude", "projects");
     if (existsSync3(claudeProjectsDir)) {
       try {
         const projectDirs = readdirSync2(claudeProjectsDir);
         for (const dir of projectDirs) {
-          const projectDir = join6(claudeProjectsDir, dir);
+          const projectDir = join4(claudeProjectsDir, dir);
           try {
             const files = readdirSync2(projectDir);
             for (const file of files) {
               if (file.match(/^session-log-\d{4}-\d{2}-\d{2}\.jsonl$/)) {
-                total += importJsonlFile(db, join6(projectDir, file));
+                total += importJsonlFile(db, join4(projectDir, file));
               }
               if (file === "errors.log") {
-                total += importErrorsLog(db, join6(projectDir, file));
+                total += importErrorsLog(db, join4(projectDir, file));
               }
             }
           } catch {}
@@ -5447,7 +5082,7 @@ function runRetention(db, days) {
 var instance = null;
 function resolveDataDir() {
   const effective = getEffectiveDataRoot();
-  const oldDir = join7(getHomeDir(), ".hooks");
+  const oldDir = join5(getHomeDir(), ".hooks");
   if (!existsSync4(effective) && existsSync4(oldDir)) {
     mkdirSync2(effective, { recursive: true });
     cpSync(oldDir, effective, { recursive: true });
@@ -5459,7 +5094,7 @@ function getDbPath() {
   if (explicitDb)
     return explicitDb;
   const dataDir2 = resolveDataDir();
-  return join7(dataDir2, "hooks.db");
+  return join5(dataDir2, "hooks.db");
 }
 function ensureDir(dbPath) {
   const dir = dbPath.substring(0, dbPath.lastIndexOf("/"));
@@ -5558,7 +5193,7 @@ function readLock() {
     return { hooks: {} };
   let raw;
   try {
-    raw = readFileSync4(path, "utf-8");
+    raw = readFileSync3(path, "utf-8");
   } catch {
     throw new LockFileError(`hooks.lock (${path}) could not be read. Repair: fix permissions or move the file aside and run 'hooks sync'.`);
   }
@@ -5590,7 +5225,7 @@ function setPinnedHook(name, entry) {
   return writeLock(lock);
 }
 function retrustHook(name, scriptPath, version, source) {
-  const actual = sha256Of(readFileSync4(scriptPath));
+  const actual = sha256Of(readFileSync3(scriptPath));
   const db = getDb();
   upsertHookRecord(db, {
     name,
@@ -5604,14 +5239,14 @@ function retrustHook(name, scriptPath, version, source) {
 }
 
 // src/lib/resolve.ts
-import { dirname as dirname2, join as join8 } from "path";
+import { dirname as dirname2, join as join6 } from "path";
 import { existsSync as existsSync6 } from "fs";
 import { fileURLToPath } from "url";
 function resolveBundledHooksDir(moduleDir = dirname2(fileURLToPath(import.meta.url))) {
-  const sourceLayout = join8(moduleDir, "..", "..", "hooks");
-  if (existsSync6(join8(sourceLayout, "hook-gitguard")))
+  const sourceLayout = join6(moduleDir, "..", "..", "hooks");
+  if (existsSync6(join6(sourceLayout, "hook-gitguard")))
     return sourceLayout;
-  return join8(moduleDir, "..", "hooks");
+  return join6(moduleDir, "..", "hooks");
 }
 function resolveHookDir(name) {
   const custom2 = readCustomManifest(name);
@@ -5622,10 +5257,10 @@ function resolveHookDir(name) {
     return;
   const short = shortManifestName(name);
   const bundledBase = resolveBundledHooksDir();
-  const direct = join8(bundledBase, short);
+  const direct = join6(bundledBase, short);
   if (existsSync6(direct))
     return direct;
-  const prefixed = join8(bundledBase, `hook-${short}`);
+  const prefixed = join6(bundledBase, `hook-${short}`);
   return existsSync6(prefixed) ? prefixed : undefined;
 }
 function resolveScriptPath(name) {
@@ -5635,7 +5270,7 @@ function resolveScriptPath(name) {
   const dir = resolveHookDir(name);
   if (!dir)
     return;
-  const script = join8(dir, "src", "hook.ts");
+  const script = join6(dir, "src", "hook.ts");
   return existsSync6(script) ? script : undefined;
 }
 function resolveHookMeta(name) {
@@ -5689,9 +5324,554 @@ function resolveHook(name) {
 
 // src/serve.ts
 import { readFileSync as readFileSync5 } from "fs";
-import { dirname as dirname3, join as join9 } from "path";
+import { dirname as dirname3, join as join8 } from "path";
 import { fileURLToPath as fileURLToPath2 } from "url";
 
+// ../contracts/dist/client/transport.js
+import { spawnSync } from "child_process";
+import { closeSync, fstatSync, openSync, readFileSync as readFileSync4 } from "fs";
+import { O_NOFOLLOW, O_NONBLOCK, O_RDONLY } from "constants";
+import { createRequire } from "module";
+import { hostname as osHostname } from "os";
+import { isAbsolute as isAbsolute2, join as join7 } from "path";
+function envToken(name) {
+  return name.toUpperCase().replace(/-/g, "_");
+}
+function clientTransportEnvKeys(name) {
+  const envSegment = envToken(name);
+  return {
+    apiUrlKeys: [`HASNA_${envSegment}_API_URL`, `${envSegment}_API_URL`],
+    apiKeyKeys: [`HASNA_${envSegment}_API_KEY`, `${envSegment}_API_KEY`]
+  };
+}
+function credentialOverrideEnvKey(name) {
+  return `HASNA_${envToken(name)}_API_KEY_OVERRIDE`;
+}
+var CREDENTIAL_PROFILE_ENV_KEY = "HASNA_PROFILE";
+function credentialPointerEnvKey(name) {
+  return `HASNA_${envToken(name)}_API_KEY_REF`;
+}
+
+class CredentialResolutionError extends Error {
+  appName;
+  attempted;
+  constructor(appName, message, attempted) {
+    super(message);
+    this.name = "CredentialResolutionError";
+    this.appName = appName;
+    this.attempted = attempted;
+  }
+}
+
+class CredentialFileUnsafeError extends Error {
+  path;
+  constructor(path, reason) {
+    super(`Refusing unsafe credential/config file ${path}: ${reason}.`);
+    this.name = "CredentialFileUnsafeError";
+    this.path = path;
+  }
+}
+var HASNA_HOME_ENV_KEY = "HASNA_HOME";
+var HASNA_CONFIG_HOME_ENV_KEY = "HASNA_CONFIG_HOME";
+var KEYCHAIN_STATION_ENV_KEY = "HASNA_STATION";
+var HASNA_HOME_DIR = ".hasna";
+var CONFIG_SUBDIR = "config";
+var CREDENTIALS_FILE = "credentials";
+var KEYCHAIN_SECURITY_BIN = "/usr/bin/security";
+var KEYCHAIN_SERVICE_PREFIX = "hasna.credentials";
+var KEYCHAIN_ITEM_NOT_FOUND_STATUS = 44;
+var KEYCHAIN_SPAWN_TIMEOUT_MS = 1e4;
+var MAX_CREDENTIAL_FILE_BYTES = 64 * 1024;
+var SAFE_APP_SLUG = /^[a-z0-9](?:[a-z0-9-]*[a-z0-9])?$/;
+var SAFE_PROFILE = /^[A-Za-z0-9](?:[A-Za-z0-9._-]*[A-Za-z0-9])?$/;
+var ILLEGAL_IN_HEADER_VALUE = /[^\t\x20-\x7e]/;
+var VAULT_POINTER_SHAPE = /^[a-z0-9][a-z0-9-]*(?:\/[a-z0-9][a-z0-9-_.]*){2,}$/;
+function homeDir(env) {
+  const home = env.HOME?.trim();
+  return home ? home : null;
+}
+function absoluteOverride(env, key) {
+  const value = env[key]?.trim();
+  return value && isAbsolute2(value) ? value : null;
+}
+function hasnaHomeDir(env) {
+  const override = absoluteOverride(env, HASNA_HOME_ENV_KEY);
+  if (override)
+    return override;
+  const home = homeDir(env);
+  return home ? join7(home, HASNA_HOME_DIR) : null;
+}
+function appConfigDir(name, env) {
+  const configRoot = absoluteOverride(env, HASNA_CONFIG_HOME_ENV_KEY);
+  if (configRoot)
+    return join7(configRoot, name);
+  const root = hasnaHomeDir(env);
+  return root ? join7(root, name, CONFIG_SUBDIR) : null;
+}
+function credentialDiskSourceList(name, env, profile = null) {
+  if (!SAFE_APP_SLUG.test(name))
+    return [];
+  const directory = appConfigDir(name, env);
+  if (!directory)
+    return [];
+  const file = profile ? `${CREDENTIALS_FILE}-${profile}` : CREDENTIALS_FILE;
+  return [{ path: join7(directory, file), tier: "disk" }];
+}
+function credentialDiskSources(name, env) {
+  return credentialDiskSourceList(name, env, null).map((s) => s.path);
+}
+function profileDiskSources(name, env, profile) {
+  return credentialDiskSourceList(name, env, profile).map((s) => s.path);
+}
+function parseEnvFile(text) {
+  const values = new Map;
+  const unusable = new Set;
+  for (const rawLine of text.split(/\r?\n/)) {
+    const line = rawLine.trim();
+    if (line.length === 0 || line.startsWith("#"))
+      continue;
+    const withoutExport = line.startsWith("export ") ? line.slice("export ".length).trim() : line;
+    const equals = withoutExport.indexOf("=");
+    if (equals <= 0)
+      continue;
+    const key = withoutExport.slice(0, equals).trim();
+    if (!/^[A-Za-z_][A-Za-z0-9_]*$/.test(key))
+      continue;
+    let value = withoutExport.slice(equals + 1).trim();
+    const quote = value[0];
+    if (quote === '"' || quote === "'") {
+      if (value.length < 2 || !value.endsWith(quote)) {
+        unusable.add(key);
+        continue;
+      }
+      value = value.slice(1, -1);
+    }
+    if (value.trim().length === 0) {
+      unusable.add(key);
+      continue;
+    }
+    if (values.has(key) && values.get(key) !== value)
+      unusable.add(key);
+    values.set(key, value);
+  }
+  return { values, unusable };
+}
+function configFileModeAllowed(mode) {
+  const permissions = mode & 4095;
+  return permissions === 256 || permissions === 384;
+}
+function configFileReadsCoherent(before, after) {
+  return before.dev === after.dev && before.ino === after.ino && before.size === after.size && before.mtimeMs === after.mtimeMs && before.ctimeMs === after.ctimeMs;
+}
+function readAppConfigFile(path) {
+  const unsafe = (reason) => {
+    throw new CredentialFileUnsafeError(path, reason);
+  };
+  let fd = -1;
+  try {
+    fd = openSync(path, O_RDONLY | O_NOFOLLOW | O_NONBLOCK);
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ENOTDIR")
+      return null;
+    if (code === "ELOOP")
+      unsafe("the path is a symlink");
+    unsafe(`the path could not be opened (${code ?? "unknown error"})`);
+  }
+  try {
+    const before = fstatSync(fd);
+    if (!before.isFile())
+      unsafe("the path is not a regular file");
+    if (!configFileModeAllowed(before.mode)) {
+      unsafe(`permission mode ${(before.mode & 4095).toString(8).padStart(4, "0")} is not owner-only 0400 or 0600`);
+    }
+    const uid = process.getuid?.() ?? process.geteuid?.();
+    if (uid !== undefined && before.uid !== uid)
+      unsafe("the file is not owned by the current user");
+    if (before.size > MAX_CREDENTIAL_FILE_BYTES)
+      unsafe("the file exceeds the size limit");
+    const bytes = readFileSync4(fd);
+    const after = fstatSync(fd);
+    if (!configFileReadsCoherent(before, after)) {
+      unsafe("the file changed while being read");
+    }
+    return parseEnvFile(bytes.toString("utf8"));
+  } finally {
+    if (fd !== -1)
+      closeSync(fd);
+  }
+}
+function readCredentialFile(path, apiKeyKeys) {
+  const parsed = readAppConfigFile(path);
+  if (!parsed)
+    return null;
+  for (const key of apiKeyKeys) {
+    if (parsed.unusable.has(key)) {
+      throw new CredentialFileUnsafeError(path, `${key} is declared but blank or malformed`);
+    }
+  }
+  const values = apiKeyKeys.map((key) => parsed.values.get(key)?.trim()).filter((value) => Boolean(value));
+  if (new Set(values).size > 1) {
+    throw new CredentialFileUnsafeError(path, "credential aliases disagree");
+  }
+  return values[0] ?? null;
+}
+function assertUsableCredential(appName, source, value) {
+  if (VAULT_POINTER_SHAPE.test(value)) {
+    throw new CredentialResolutionError(appName, `The credential from ${source} looks like a secrets-vault pointer (a path-shaped reference like ` + `'namespace/app/live/api_key'). A vault path is NEVER accepted as a literal API key. ` + `Use ${credentialPointerEnvKey(appName)} to resolve the key through the vault, or provide the actual key value.`, [source]);
+  }
+  if (!ILLEGAL_IN_HEADER_VALUE.test(value))
+    return;
+  throw new CredentialResolutionError(appName, `The credential from ${source} contains characters that cannot be sent in an HTTP header ` + `(a control character or non-ASCII byte). A file written with CR-only line endings is the usual ` + `cause. Rewrite that credential file with one LF-terminated KEY=value line. ` + `The value is not shown here, and is deliberately never logged.`, [source]);
+}
+var INSPECT_CUSTOM = Symbol.for("nodejs.util.inspect.custom");
+var CREDENTIAL_SEAL = Symbol.for("hasna:contracts:sealedCredential");
+function sealCredential(fields) {
+  const { apiKey } = fields;
+  const visible = {
+    tier: fields.tier,
+    source: fields.source,
+    deliberate: fields.deliberate,
+    diskCandidates: Object.freeze([...fields.diskCandidates]),
+    warning: fields.warning
+  };
+  const sealed = { ...visible };
+  Object.defineProperty(sealed, "apiKey", {
+    value: apiKey,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  if (fields.pointerVaultKey !== undefined) {
+    Object.defineProperty(sealed, "pointerVaultKey", {
+      value: fields.pointerVaultKey,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+  Object.defineProperty(sealed, INSPECT_CUSTOM, {
+    value: () => ({ ...visible, apiKey: "[redacted]" }),
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  Object.defineProperty(sealed, CREDENTIAL_SEAL, {
+    value: true,
+    enumerable: false,
+    writable: false,
+    configurable: false
+  });
+  return Object.freeze(sealed);
+}
+function firstEnvValue(env, keys) {
+  for (const key of keys) {
+    if (!Object.prototype.hasOwnProperty.call(env, key))
+      continue;
+    const value = env[key]?.trim();
+    if (value)
+      return { key, value };
+  }
+  return null;
+}
+var AMBIENT_ENVIRONMENT = Symbol.for("hasna:contracts:ambientClientEnvironment");
+function isAmbientEnvironment(env) {
+  return env === process.env || env[AMBIENT_ENVIRONMENT] === true;
+}
+function defaultKeychainRunner(argv) {
+  const result = spawnSync(KEYCHAIN_SECURITY_BIN, [...argv], {
+    encoding: "utf8",
+    stdio: ["ignore", "pipe", "pipe"],
+    timeout: KEYCHAIN_SPAWN_TIMEOUT_MS
+  });
+  return {
+    status: result.status,
+    stdout: result.stdout ?? "",
+    stderr: result.error ? result.error.message : result.stderr ?? ""
+  };
+}
+function keychainTierEnabled(env, options) {
+  if ((options.platform ?? process.platform) !== "darwin")
+    return false;
+  if (options.enabled !== undefined)
+    return options.enabled;
+  return options.run !== undefined || isAmbientEnvironment(env);
+}
+function keychainAccount(env, options) {
+  const station = env[KEYCHAIN_STATION_ENV_KEY]?.trim();
+  if (station)
+    return station;
+  const host = (options.hostname ?? osHostname)().split(".")[0]?.trim() ?? "";
+  if (host)
+    return host;
+  const user = env.USER?.trim();
+  return user || null;
+}
+function keychainFailureHint(text) {
+  const line = text.split(/\r?\n/).find((entry) => entry.trim().length > 0)?.trim() ?? "";
+  const clean = line.replace(/[\u0000-\u001f\u007f]/g, "").slice(0, 200);
+  return clean ? `: ${clean}` : "";
+}
+function readKeychainItem(name, env, kind, options) {
+  if (!SAFE_APP_SLUG.test(name) || !keychainTierEnabled(env, options))
+    return null;
+  const account = keychainAccount(env, options);
+  if (!account)
+    return null;
+  const service = `${KEYCHAIN_SERVICE_PREFIX}.${name}.${kind}`;
+  const source = `keychain:${service}@${account}`;
+  const run = options.run ?? defaultKeychainRunner;
+  let result;
+  try {
+    result = run(["find-generic-password", "-a", account, "-s", service, "-w"]);
+  } catch (error) {
+    const reason = keychainFailureHint(error instanceof Error ? error.message : String(error));
+    throw new CredentialResolutionError(name, `The Keychain lookup for ${source} could not run${reason}. A Keychain failure is never resolved ` + `around: fix the keychain, or delete the item to fall through to the credential on disk.`, [source]);
+  }
+  if (result.status === KEYCHAIN_ITEM_NOT_FOUND_STATUS)
+    return null;
+  if (result.status !== 0) {
+    throw new CredentialResolutionError(name, `The Keychain lookup for ${source} failed (security exited ` + `${result.status ?? "without a status"}${keychainFailureHint(result.stderr)}). A Keychain item that ` + `exists but cannot be read is never resolved around: unlock the keychain, run from a session that ` + `may use it, or delete the item to fall through to the credential on disk.`, [source]);
+  }
+  const value = result.stdout.trim();
+  if (!value) {
+    throw new CredentialResolutionError(name, `${source} exists but holds an empty value; a declared item never falls through to another ` + `identity. Store a value in it or delete the item.`, [source]);
+  }
+  return { value, source };
+}
+function snapshotClientEnvironment(name, env) {
+  const keys = clientTransportEnvKeys(name);
+  const ambient = isAmbientEnvironment(env);
+  const snapshot = Object.create(null);
+  for (const key of [
+    ...keys.apiUrlKeys,
+    ...keys.apiKeyKeys,
+    credentialOverrideEnvKey(name),
+    credentialPointerEnvKey(name),
+    CREDENTIAL_PROFILE_ENV_KEY,
+    "HOME",
+    HASNA_HOME_ENV_KEY,
+    HASNA_CONFIG_HOME_ENV_KEY,
+    KEYCHAIN_STATION_ENV_KEY,
+    "USER"
+  ]) {
+    const descriptor = Object.getOwnPropertyDescriptor(env, key);
+    if (!descriptor)
+      continue;
+    if (!("value" in descriptor)) {
+      throw new CredentialResolutionError(name, `${key} is accessor-backed; client configuration requires own data properties.`, [key]);
+    }
+    if (descriptor.value !== undefined && typeof descriptor.value !== "string") {
+      throw new CredentialResolutionError(name, `${key} must be a string data property.`, [key]);
+    }
+    snapshot[key] = descriptor.value;
+  }
+  if (ambient) {
+    Object.defineProperty(snapshot, AMBIENT_ENVIRONMENT, {
+      value: true,
+      enumerable: false,
+      writable: false,
+      configurable: false
+    });
+  }
+  return Object.freeze(snapshot);
+}
+function resolveCredential(name, env, options = {}) {
+  env = snapshotClientEnvironment(name, env);
+  const { apiKeyKeys } = clientTransportEnvKeys(name);
+  const diskPaths = credentialDiskSources(name, env);
+  if (options.apiKey !== undefined) {
+    const explicitKey = options.apiKey.trim();
+    if (!explicitKey) {
+      throw new CredentialResolutionError(name, "The explicit apiKey argument is blank; an explicit credential never falls through to another identity.", ["explicit apiKey argument"]);
+    }
+    assertUsableCredential(name, "the explicit apiKey argument", explicitKey);
+    return sealCredential({
+      apiKey: explicitKey,
+      tier: "argument",
+      source: "explicit apiKey argument",
+      deliberate: true,
+      diskCandidates: diskPaths,
+      warning: null
+    });
+  }
+  const overrideKeyName = credentialOverrideEnvKey(name);
+  const overrideRaw = Object.prototype.hasOwnProperty.call(env, overrideKeyName) ? env[overrideKeyName] : undefined;
+  if (overrideRaw !== undefined) {
+    const override = overrideRaw.trim();
+    if (!override) {
+      throw new CredentialResolutionError(name, `${overrideKeyName} is set but empty. It is a deliberate override, so it is not resolved around: ` + `either give it a real key or unset it to fall back to the credential on disk.`, [overrideKeyName]);
+    }
+    assertUsableCredential(name, overrideKeyName, override);
+    return sealCredential({
+      apiKey: override,
+      tier: "override",
+      source: overrideKeyName,
+      deliberate: true,
+      diskCandidates: diskPaths,
+      warning: null
+    });
+  }
+  const pointerKeyName = credentialPointerEnvKey(name);
+  const pointerRaw = Object.prototype.hasOwnProperty.call(env, pointerKeyName) ? env[pointerKeyName] : undefined;
+  if (pointerRaw !== undefined) {
+    const pointer = pointerRaw.trim();
+    if (!pointer) {
+      throw new CredentialResolutionError(name, `${pointerKeyName} is set but empty. It is a deliberate vault pointer, so it is not resolved around: ` + `either give it a vault item key or unset it to fall back to the credential on disk.`, [pointerKeyName]);
+    }
+    if (!VAULT_POINTER_SHAPE.test(pointer)) {
+      throw new CredentialResolutionError(name, `${pointerKeyName} must name a vault ITEM KEY (a path-shaped reference like ` + `'namespace/app/live/api_key'), not a credential value. A pointer that carries a literal is refused.`, [pointerKeyName]);
+    }
+    return sealCredential({
+      apiKey: "",
+      pointerVaultKey: pointer,
+      tier: "pointer",
+      source: pointerKeyName,
+      deliberate: true,
+      diskCandidates: diskPaths,
+      warning: null
+    });
+  }
+  if (options.profile !== undefined && !options.profile.trim()) {
+    throw new CredentialResolutionError(name, "The explicit profile argument is blank; an explicit identity selection never falls through.", ["explicit profile argument"]);
+  }
+  const profileRaw = Object.prototype.hasOwnProperty.call(env, CREDENTIAL_PROFILE_ENV_KEY) ? env[CREDENTIAL_PROFILE_ENV_KEY] : undefined;
+  if (profileRaw !== undefined && !profileRaw.trim()) {
+    throw new CredentialResolutionError(name, `${CREDENTIAL_PROFILE_ENV_KEY} is set but blank.`, [CREDENTIAL_PROFILE_ENV_KEY]);
+  }
+  const profile = options.profile?.trim() || profileRaw?.trim();
+  if (profile) {
+    const profileSource = options.profile?.trim() ? "explicit profile argument" : CREDENTIAL_PROFILE_ENV_KEY;
+    if (!SAFE_PROFILE.test(profile)) {
+      throw new CredentialResolutionError(name, `Profile name from ${profileSource} is not usable in a path. ` + `Use letters, digits, dot, dash, or underscore.`, [profileSource]);
+    }
+    const paths = profileDiskSources(name, env, profile);
+    for (const path of paths) {
+      const value = readCredentialFile(path, apiKeyKeys);
+      if (value) {
+        assertUsableCredential(name, path, value);
+        return sealCredential({
+          apiKey: value,
+          tier: "profile",
+          source: path,
+          deliberate: true,
+          diskCandidates: paths,
+          warning: null
+        });
+      }
+    }
+    throw new CredentialResolutionError(name, `Profile '${profile}' (from ${profileSource}) has no ${apiKeyKeys[0]} for '${name}'. ` + `Looked in: ${paths.join(", ") || "<no HOME in this environment>"}. ` + `A profile names WHICH identity to use, so it is never resolved around \u2014 ` + `create the profile's credential file or unset ${CREDENTIAL_PROFILE_ENV_KEY}.`, paths);
+  }
+  const definedEnvEntries = apiKeyKeys.filter((key) => Object.prototype.hasOwnProperty.call(env, key) && env[key] !== undefined).map((key) => ({ key, value: String(env[key]).trim() }));
+  const blankEnv = definedEnvEntries.find((entry) => entry.value.length === 0);
+  if (blankEnv) {
+    throw new CredentialResolutionError(name, `${blankEnv.key} is set but blank; a declared credential never falls through to another alias or identity.`, [blankEnv.key]);
+  }
+  if (definedEnvEntries.length > 1 && new Set(definedEnvEntries.map((entry) => entry.value)).size > 1) {
+    throw new CredentialResolutionError(name, `${definedEnvEntries.map((entry) => entry.key).join(" and ")} disagree; credential aliases must be identical or only one may be set.`, definedEnvEntries.map((entry) => entry.key));
+  }
+  const envHit = firstEnvValue(env, apiKeyKeys);
+  const keychainHit = readKeychainItem(name, env, "api-key", options.keychain ?? {});
+  if (keychainHit) {
+    assertUsableCredential(name, keychainHit.source, keychainHit.value);
+    const warning = envHit && envHit.value !== keychainHit.value ? `Credential sources disagree for '${name}': ${keychainHit.source} and ${envHit.key} hold ` + `different keys. ${keychainHit.source} wins, because the Keychain is re-read on every call while ` + `an environment variable is a snapshot. Reconcile them \u2014 a rotation that updated only one leaves ` + `the other to fail 401 wherever it is loaded first.` : null;
+    return sealCredential({
+      apiKey: keychainHit.value,
+      tier: "keychain",
+      source: keychainHit.source,
+      deliberate: false,
+      diskCandidates: diskPaths,
+      warning
+    });
+  }
+  const diskSourceList = credentialDiskSourceList(name, env, null);
+  const diskHits = diskSourceList.map((src) => ({ src, value: readCredentialFile(src.path, apiKeyKeys) })).filter((hit) => hit.value !== null);
+  if (diskHits.length > 0) {
+    const winner = diskHits[0];
+    assertUsableCredential(name, winner.src.path, winner.value);
+    const divergentSources = [
+      ...diskHits.slice(1).filter((hit) => hit.value !== winner.value).map((hit) => hit.src.path),
+      ...envHit && envHit.value !== winner.value ? [envHit.key] : []
+    ];
+    const warning = divergentSources.length > 0 ? `Credential sources disagree for '${name}': ${winner.src.path} and ` + `${divergentSources.join(", ")} hold different keys. ${winner.src.path} wins, because a file on ` + `disk is re-read on every call while an environment variable is a snapshot. Reconcile them \u2014 ` + `a rotation that updated only one leaves the other to fail 401 wherever it is loaded first.` : null;
+    return sealCredential({
+      apiKey: winner.value,
+      tier: winner.src.tier,
+      source: winner.src.path,
+      deliberate: false,
+      diskCandidates: diskPaths,
+      warning
+    });
+  }
+  if (envHit) {
+    assertUsableCredential(name, envHit.key, envHit.value);
+    return sealCredential({
+      apiKey: envHit.value,
+      tier: "env",
+      source: envHit.key,
+      deliberate: false,
+      diskCandidates: diskPaths,
+      warning: null
+    });
+  }
+  return null;
+}
+var SECRETS_PACKAGE_SPECIFIER = "@hasna/" + "secrets";
+var requireSecretsSdk = createRequire(import.meta.url);
+var IDEMPOTENT_METHODS = new Set(["GET", "HEAD", "PUT", "DELETE", "OPTIONS"]);
+var AUTHORITY_OVERRIDE_HEADERS = new Set([
+  "host",
+  ":authority",
+  "forwarded",
+  "x-forwarded-host",
+  "x-original-host"
+]);
+
+// src/lib/local-opt-in.ts
+function hooksAuthorityEnvKeys() {
+  const keys = clientTransportEnvKeys("hooks");
+  return [
+    ...keys.apiUrlKeys,
+    ...keys.apiKeyKeys,
+    credentialOverrideEnvKey("hooks"),
+    credentialPointerEnvKey("hooks"),
+    CREDENTIAL_PROFILE_ENV_KEY
+  ];
+}
+function hooksResolverEnv(env) {
+  const blanks = hooksAuthorityEnvKeys().filter((key) => (key in env) && (env[key] ?? "").trim() === "");
+  if (blanks.length === 0)
+    return env;
+  const next = { ...env };
+  for (const key of blanks)
+    delete next[key];
+  return next;
+}
+var CONTRACTS_AMBIENT_ENVIRONMENT = Symbol.for("hasna:contracts:ambientClientEnvironment");
+function isAmbientHooksEnv(env) {
+  if (typeof process !== "undefined" && env === process.env)
+    return true;
+  return env[CONTRACTS_AMBIENT_ENVIRONMENT] === true;
+}
+function hooksResolverInputs(env, credentials = {}) {
+  const normalised = hooksResolverEnv(env);
+  if (normalised === env)
+    return { env: normalised, credentials };
+  const keychain = { ...credentials.keychain };
+  if (keychain.enabled === undefined && keychain.run === undefined) {
+    keychain.enabled = isAmbientHooksEnv(env);
+  }
+  return { env: normalised, credentials: { ...credentials, keychain } };
+}
+
+// src/lib/transport.ts
+function resolveHooksServePublishKey(env = process.env, options = {}) {
+  const { env: resolverEnv, credentials } = hooksResolverInputs(env, options.credentials);
+  const tier1 = options.credentials?.apiKey;
+  const credentialOptions = tier1 !== undefined ? { ...credentials, apiKey: tier1 } : credentials;
+  return resolveCredential("hooks", resolverEnv, credentialOptions)?.apiKey;
+}
+
 // src/lib/secure-compare.ts
 function secureEqual(a, b) {
   const enc = new TextEncoder;
@@ -5850,7 +6030,7 @@ var openApiDocument = {
       apiKey: {
         type: "http",
         scheme: "bearer",
-        description: "The registry API key (HASNA_HOOKS_API_KEY / HOOKS_API_KEY)."
+        description: "The registry API key \u2014 resolved by the client through the @hasna/contracts chain (HASNA_HOOKS_API_KEY, the Keychain item hasna.credentials.hooks.api-key, or ~/.hasna/hooks/config/credentials); the server compares the inbound bearer/x-api-key value."
       }
     }
   }
@@ -5862,7 +6042,7 @@ var SERVE_HOST = "127.0.0.1";
 var SERVE_SERVICE_NAME = "hooks-registry";
 function packageVersion() {
   try {
-    const pkgPath = join9(dirname3(fileURLToPath2(import.meta.url)), "..", "package.json");
+    const pkgPath = join8(dirname3(fileURLToPath2(import.meta.url)), "..", "package.json");
     return JSON.parse(readFileSync5(pkgPath, "utf-8")).version || "0.0.0";
   } catch {
     return "0.0.0";
@@ -6020,12 +6200,11 @@ function resolveServeOptions(options) {
 }
 function startServeServer(options) {
   const { port, host } = resolveServeOptions(options);
-  const apiKey = resolveApiKey();
   const server = Bun.serve({
     hostname: host,
     port,
     async fetch(req) {
-      return handleServeRequest(req, apiKey);
+      return handleServeRequest(req, resolveHooksServePublishKey());
     }
   });
   console.error(`hooks registry listening on http://${host}:${port} (publish requires an API key)`);