@litterthanlit/hypher-cli 0.1.0

package/src/credentials.mjs

@@ -0,0 +1,134 @@
+/**
+ * The hook credential: a named, revocable Hypher API key.
+ *
+ * Stores: the macOS Keychain (through `security -i`, so the key goes in over
+ * stdin and never into an argument list), libsecret (`secret-tool store`
+ * reads stdin), else a 0600 file. HYPHER_CREDENTIAL_STORE picks one for
+ * tests (`file`, `keychain`, `libsecret`, `none`). With no store at all, as
+ * in a container, HYPHER_API_KEY is read. No command prints the key.
+ *
+ * Self-contained on purpose: the Cursor plugin vendors this file
+ * (extensions/cursor/scripts/vendor/hypher-credentials.mjs, refreshed with
+ * `node script/sync-hypher-git.mjs`), so its hooks use the same key.
+ */
+import { spawnSync } from "node:child_process";
+import { chmodSync, mkdirSync, readFileSync, renameSync, rmSync, writeFileSync } from "node:fs";
+import os from "node:os";
+import path from "node:path";
+
+const SERVICE = "hypher-cli";
+const ACCOUNT = "api-key";
+const KEY_SHAPE = /^hyp_[A-Za-z0-9]{16,128}$/;
+
+/** ~/.hypher/credentials, honoring HYPHER_HOME and HOME. */
+export function credentialsFile(env = process.env) {
+  const home = env.HOME || os.homedir();
+  return path.join(env.HYPHER_HOME || path.join(home, ".hypher"), "credentials");
+}
+
+function onPath(bin, env) {
+  const result = spawnSync("sh", ["-c", `command -v ${bin}`], { env, encoding: "utf8" });
+  return result.status === 0 && Boolean(result.stdout.trim());
+}
+
+/** @param {NodeJS.ProcessEnv} env @returns {"keychain" | "libsecret" | "file" | "none"} */
+export function credentialStore(env = process.env) {
+  const chosen = String(env.HYPHER_CREDENTIAL_STORE || "").trim();
+  if (["keychain", "libsecret", "file", "none"].includes(chosen)) return /** @type {any} */ (chosen);
+  if (process.platform === "darwin" && onPath("security", env)) return "keychain";
+  if (process.platform === "linux" && env.DBUS_SESSION_BUS_ADDRESS && onPath("secret-tool", env)) return "libsecret";
+  return "file";
+}
+
+/** The human step a store needs, as one line, or null. */
+export function credentialPromptLine(store) {
+  if (store === "keychain") return "macOS may ask once to let Hypher use the keychain. Click Always Allow.";
+  if (store === "libsecret") return "Your keyring may ask once to unlock. Unlock it to store the Hypher key.";
+  return null;
+}
+
+export function isApiKeyShape(value) {
+  return KEY_SHAPE.test(String(value ?? ""));
+}
+
+function readFileKey(env) {
+  try {
+    return JSON.parse(readFileSync(credentialsFile(env), "utf8"))?.apiKey ?? null;
+  } catch {
+    return null;
+  }
+}
+
+function writeFileKey(apiKey, env) {
+  const file = credentialsFile(env);
+  mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.tmp`;
+  writeFileSync(tmp, `${JSON.stringify({ apiKey }, null, 2)}\n`, { mode: 0o600 });
+  chmodSync(tmp, 0o600);
+  renameSync(tmp, file);
+}
+
+/**
+ * @param {string} apiKey
+ * @param {NodeJS.ProcessEnv} env
+ * @returns {{ ok: boolean, store: string, error?: string }}
+ */
+export function saveCredential(apiKey, env = process.env) {
+  if (!isApiKeyShape(apiKey)) return { ok: false, store: "none", error: "The server returned a key in an unexpected shape." };
+  const store = credentialStore(env);
+  if (store === "none") return { ok: false, store, error: "No credential store. Set HYPHER_API_KEY in the hook environment." };
+  if (store === "keychain") {
+    const result = spawnSync("security", ["-i"], {
+      input: `add-generic-password -U -s ${SERVICE} -a ${ACCOUNT} -l "Hypher CLI" -w ${apiKey}\n`,
+      env,
+      encoding: "utf8",
+      timeout: 60_000,
+    });
+    return result.status === 0 ? { ok: true, store } : { ok: false, store, error: "The keychain refused the key." };
+  }
+  if (store === "libsecret") {
+    const result = spawnSync("secret-tool", ["store", "--label=Hypher CLI", "service", SERVICE, "account", ACCOUNT], {
+      input: apiKey,
+      env,
+      encoding: "utf8",
+      timeout: 60_000,
+    });
+    return result.status === 0 ? { ok: true, store } : { ok: false, store, error: "The keyring refused the key." };
+  }
+  writeFileKey(apiKey, env);
+  return { ok: true, store };
+}
+
+/** @returns {{ apiKey: string | null, source: string }} */
+export function loadCredential(env = process.env) {
+  const store = credentialStore(env);
+  let apiKey = null;
+  if (store === "keychain") {
+    const result = spawnSync("security", ["find-generic-password", "-s", SERVICE, "-a", ACCOUNT, "-w"], {
+      env, encoding: "utf8", timeout: 5_000,
+    });
+    if (result.status === 0) apiKey = result.stdout.trim();
+  } else if (store === "libsecret") {
+    const result = spawnSync("secret-tool", ["lookup", "service", SERVICE, "account", ACCOUNT], {
+      env, encoding: "utf8", timeout: 5_000,
+    });
+    if (result.status === 0) apiKey = result.stdout.trim();
+  } else if (store === "file") {
+    apiKey = readFileKey(env);
+  }
+  if (isApiKeyShape(apiKey)) return { apiKey, source: store };
+  const fromEnv = String(env.HYPHER_API_KEY ?? "").trim();
+  if (isApiKeyShape(fromEnv)) return { apiKey: fromEnv, source: "HYPHER_API_KEY" };
+  return { apiKey: null, source: store };
+}
+
+export function deleteCredential(env = process.env) {
+  const store = credentialStore(env);
+  if (store === "keychain") {
+    spawnSync("security", ["delete-generic-password", "-s", SERVICE, "-a", ACCOUNT], { env, stdio: "ignore", timeout: 10_000 });
+  } else if (store === "libsecret") {
+    spawnSync("secret-tool", ["clear", "service", SERVICE, "account", ACCOUNT], { env, stdio: "ignore", timeout: 10_000 });
+  }
+  rmSync(credentialsFile(env), { force: true });
+  return store;
+}

package/src/device.mjs

@@ -0,0 +1,62 @@
+/**
+ * One-click connect, device-style (RFC 8628). The CLI shows a short user code
+ * and a link, and polls with a separate device code it never shows. The
+ * builder compares the code in the browser and clicks Approve. The browser
+ * opens only when a terminal is attached; otherwise the link is printed.
+ */
+import { spawn } from "node:child_process";
+import { machineName } from "./env.mjs";
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function openBrowser(url, env) {
+  const opener = process.platform === "darwin" ? "open" : process.platform === "win32" ? "explorer" : "xdg-open";
+  try {
+    const child = spawn(opener, [url], { env, stdio: "ignore", detached: true });
+    child.on("error", () => {});
+    child.unref();
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * @param {ReturnType<import("./api.mjs").createClient>} client
+ * @param {{ purpose: "connect" | "link", repository?: string | null, io: any, noBrowser?: boolean }} options
+ * @returns {Promise<{ ok: true, result: any } | { ok: false, error: string }>}
+ */
+export async function runDeviceFlow(client, { purpose, repository, io, noBrowser }) {
+  const started = await client.send("POST", "/api/cli/device", {
+    body: { purpose, machineName: machineName(io.env), ...(repository ? { repository } : {}) },
+    auth: purpose === "link",
+  });
+  if (!started.ok || !started.json?.deviceCode) {
+    return { ok: false, error: started.json?.error ?? `Hypher could not start the connection (HTTP ${started.status}).` };
+  }
+  const { deviceCode, userCode, verificationUri, verificationUriComplete, expiresIn = 600 } = started.json;
+  let interval = Math.max(1, Number(started.json.interval) || 5) * 1000;
+  const label = purpose === "link" ? `Link ${repository}` : "Connect this computer";
+  io.out(`  ${label} → ${verificationUri}   code ${userCode}`);
+  io.out("  Open the link, check that the code matches, and click Approve.");
+  if (io.isTTY && !noBrowser) openBrowser(verificationUriComplete ?? verificationUri, io.env);
+
+  const deadline = Date.now() + expiresIn * 1000;
+  while (Date.now() < deadline) {
+    await sleep(interval);
+    const polled = await client.send("POST", "/api/cli/device/token", { body: { deviceCode }, auth: false });
+    if (polled.ok && polled.json?.status === "approved") return { ok: true, result: polled.json };
+    const error = polled.json?.error;
+    if (error === "authorization_pending") continue;
+    if (error === "slow_down") {
+      interval += 5_000;
+      continue;
+    }
+    if (error === "access_denied") return { ok: false, error: "The request was cancelled in the browser." };
+    if (error === "expired_token") return { ok: false, error: "The code expired. Run the command again." };
+    return { ok: false, error: polled.json?.error_description ?? error ?? `Unexpected answer (HTTP ${polled.status}).` };
+  }
+  return { ok: false, error: "The code expired. Run the command again." };
+}

package/src/env.mjs

@@ -0,0 +1,75 @@
+/**
+ * Where everything lives. Every path honors HOME, HYPHER_HOME,
+ * CLAUDE_CONFIG_DIR, and CODEX_HOME, so tests and the rehearsal never touch
+ * the builder's real configuration.
+ */
+import os from "node:os";
+import path from "node:path";
+
+export const CLI_VERSION = "0.1.0";
+export const DEFAULT_API_BASE = "https://www.hypher.app";
+export const INTEGRATIONS_URL = "https://hypher.app/app/settings/integrations";
+export const API_KEYS_URL = "https://hypher.app/app/settings/api-keys";
+
+/** @param {NodeJS.ProcessEnv} [env] */
+export function paths(env = process.env) {
+  const home = env.HOME || os.homedir();
+  const hypherHome = env.HYPHER_HOME || path.join(home, ".hypher");
+  const claudeDir = env.CLAUDE_CONFIG_DIR || path.join(home, ".claude");
+  const codexHome = env.CODEX_HOME || path.join(home, ".codex");
+  return {
+    home,
+    hypherHome,
+    binDir: path.join(hypherHome, "bin"),
+    shim: path.join(hypherHome, "bin", "hypher"),
+    libDir: path.join(hypherHome, "lib"),
+    config: path.join(hypherHome, "config.json"),
+    links: path.join(hypherHome, "links.json"),
+    manifest: path.join(hypherHome, "manifest.json"),
+    credentials: path.join(hypherHome, "credentials"),
+    stateDir: path.join(hypherHome, "state"),
+    outboxDir: path.join(hypherHome, "state", "outbox"),
+    sessionsDir: path.join(hypherHome, "state", "sessions"),
+    repoStateDir: path.join(hypherHome, "state", "repos"),
+    sentLog: path.join(hypherHome, "state", "sent.jsonl"),
+    claudeDir,
+    claudeSettings: path.join(claudeDir, "settings.json"),
+    // Claude Code keeps user-scope MCP servers in ~/.claude.json, or inside CLAUDE_CONFIG_DIR when set.
+    claudeJson: env.CLAUDE_CONFIG_DIR
+      ? path.join(env.CLAUDE_CONFIG_DIR, ".claude.json")
+      : path.join(home, ".claude.json"),
+    codexHome,
+    codexConfig: path.join(codexHome, "config.toml"),
+    codexHooks: path.join(codexHome, "hooks.json"),
+    codexAgents: path.join(codexHome, "AGENTS.md"),
+  };
+}
+
+/** True for http URLs on this machine; everything else must be https. */
+export function isLoopbackUrl(value) {
+  try {
+    const url = new URL(value);
+    return ["127.0.0.1", "localhost", "[::1]"].includes(url.hostname);
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * The Hypher API base. HYPHER_API_URL wins, then the value `init` stored.
+ * Plain http is refused except on loopback, so the key never crosses a network in the clear.
+ * @param {NodeJS.ProcessEnv} env
+ * @param {{ apiBase?: string } | null} config
+ */
+export function apiBase(env, config) {
+  const raw = String(env.HYPHER_API_URL || config?.apiBase || DEFAULT_API_BASE).trim().replace(/\/+$/, "");
+  if (raw.startsWith("https://")) return raw;
+  if (raw.startsWith("http://") && isLoopbackUrl(raw)) return raw;
+  return DEFAULT_API_BASE;
+}
+
+/** A short, stable machine label for the key name. No user names. */
+export function machineName(env = process.env) {
+  const host = (env.HYPHER_MACHINE_NAME || os.hostname() || "this computer").replace(/\.local$/i, "");
+  return host.replace(/[^\w.-]+/g, "-").slice(0, 60) || "this-computer";
+}

package/src/fsutil.mjs

@@ -0,0 +1,70 @@
+import { createHash, randomBytes } from "node:crypto";
+import {
+  chmodSync,
+  existsSync,
+  mkdirSync,
+  readFileSync,
+  renameSync,
+  rmSync,
+  writeFileSync,
+} from "node:fs";
+import path from "node:path";
+
+export function sha256(data) {
+  return createHash("sha256").update(data).digest("hex");
+}
+
+export function fileSha256(file) {
+  const bytes = readBytes(file);
+  return bytes ? sha256(bytes) : null;
+}
+
+/** @returns {Buffer | null} */
+export function readBytes(file) {
+  try {
+    return readFileSync(file);
+  } catch {
+    return null;
+  }
+}
+
+export function readJson(file, fallback = null) {
+  const bytes = readBytes(file);
+  if (!bytes) return fallback;
+  try {
+    return JSON.parse(bytes.toString("utf8"));
+  } catch {
+    return fallback;
+  }
+}
+
+/** Write through a temp file and rename, so a crash never leaves half a file. */
+export function writeAtomic(file, data, { mode } = {}) {
+  mkdirSync(path.dirname(file), { recursive: true });
+  const tmp = `${file}.${process.pid}.${randomBytes(4).toString("hex")}.tmp`;
+  writeFileSync(tmp, data, mode ? { mode } : undefined);
+  if (mode) chmodSync(tmp, mode);
+  renameSync(tmp, file);
+}
+
+export function writeJson(file, value, options) {
+  writeAtomic(file, `${JSON.stringify(value, null, 2)}\n`, options);
+}
+
+export function removeFile(file) {
+  rmSync(file, { force: true });
+}
+
+export function exists(file) {
+  return existsSync(file);
+}
+
+/** Stable JSON: object keys sorted, so equal content hashes equally. */
+export function canonicalJson(value) {
+  if (Array.isArray(value)) return `[${value.map(canonicalJson).join(",")}]`;
+  if (value && typeof value === "object") {
+    return `{${Object.keys(value).sort().filter((key) => value[key] !== undefined)
+      .map((key) => `${JSON.stringify(key)}:${canonicalJson(value[key])}`).join(",")}}`;
+  }
+  return JSON.stringify(value);
+}

package/src/hookConfig.mjs

@@ -0,0 +1,86 @@
+/**
+ * Hook lists in the shape Claude Code and Codex share:
+ * { hooks: { <Event>: [{ matcher?, hooks: [{ type: "command", command, timeout }] }] } }.
+ * Hypher's entries carry a tag in their command, so they can be found again,
+ * and are appended after the builder's own, so removing them never shifts
+ * the position of anything the builder added.
+ */
+
+/** @param {string} tag e.g. "hook claude-code" */
+export function hookCommand(shim, tag, event) {
+  return `"${shim}" ${tag} ${event}`;
+}
+
+export function isTaggedCommand(command, tag) {
+  return typeof command === "string" && command.includes(tag) && /hypher/.test(command);
+}
+
+function withoutTagged(groups, tag) {
+  const kept = [];
+  for (const group of Array.isArray(groups) ? groups : []) {
+    if (!group || typeof group !== "object" || !Array.isArray(group.hooks)) {
+      kept.push(group);
+      continue;
+    }
+    const hooks = group.hooks.filter((hook) => !isTaggedCommand(hook?.command, tag));
+    if (hooks.length === group.hooks.length) kept.push(group);
+    else if (hooks.length > 0) kept.push({ ...group, hooks });
+  }
+  return kept;
+}
+
+/**
+ * @param {Record<string, any>} config the parsed file
+ * @param {{ event: string, matcher?: string, timeout: number }[]} specs
+ * @param {string} shim absolute path of the `hypher` shim
+ * @param {string} tag
+ */
+export function mergeHooks(config, specs, shim, tag) {
+  const next = { ...config, hooks: { ...(config.hooks ?? {}) } };
+  for (const spec of specs) {
+    const groups = withoutTagged(next.hooks[spec.event], tag);
+    groups.push({
+      ...(spec.matcher ? { matcher: spec.matcher } : {}),
+      hooks: [{ type: "command", command: hookCommand(shim, tag, spec.event), timeout: spec.timeout }],
+    });
+    next.hooks[spec.event] = groups;
+  }
+  return next;
+}
+
+export function removeHooks(config, tag) {
+  if (!config?.hooks || typeof config.hooks !== "object") return config;
+  const hooks = {};
+  for (const [event, groups] of Object.entries(config.hooks)) {
+    const kept = withoutTagged(groups, tag);
+    if (kept.length > 0) hooks[event] = kept;
+  }
+  const next = { ...config };
+  if (Object.keys(hooks).length > 0) next.hooks = hooks;
+  else delete next.hooks;
+  return next;
+}
+
+export function installedEvents(config, specs, tag) {
+  return specs.filter((spec) =>
+    (config?.hooks?.[spec.event] ?? []).some((group) =>
+      (group?.hooks ?? []).some((hook) => isTaggedCommand(hook?.command, tag))))
+    .map((spec) => spec.event);
+}
+
+/** Where each tagged hook sits: [event, groupIndex, hookIndex]. Codex keys its trust by this position. */
+export function taggedPositions(config, tag) {
+  const found = [];
+  for (const [event, groups] of Object.entries(config?.hooks ?? {})) {
+    (Array.isArray(groups) ? groups : []).forEach((group, groupIndex) => {
+      (group?.hooks ?? []).forEach((hook, hookIndex) => {
+        if (isTaggedCommand(hook?.command, tag)) found.push([event, groupIndex, hookIndex]);
+      });
+    });
+  }
+  return found;
+}
+
+export function renderJson(value) {
+  return `${JSON.stringify(value, null, 2)}\n`;
+}

package/src/hooks/index.mjs

@@ -0,0 +1,134 @@
+/**
+ * Agent hooks, for Claude Code and Codex alike (both send the same payload
+ * shape). SessionStart injects the note (after startup, resume, clear, and
+ * compact); Stop, PreCompact, and SessionEnd record a checkpoint; Stop asks
+ * once for a seal when the tree changed. Hooks never acknowledge, never block
+ * twice in a row, and never block on Hypher being down. In a repository no
+ * human linked they record and upload nothing.
+ */
+import { createClient } from "../api.mjs";
+import { linkFor } from "../config.mjs";
+import { enqueue, flushOutbox, shouldFlush } from "../outbox.mjs";
+import { resumeHere } from "../session.mjs";
+import { takeSnapshot } from "../snapshot.mjs";
+import { branchState, readWorktreeState, updateWorktreeState, withBranchState } from "../state.mjs";
+import { findSecret } from "../secrets.mjs";
+
+export const ASK_AGAIN_AFTER_MS = 15 * 60_000;
+const HOOK_TIMEOUT_MS = 2_500;
+const MAX_FILES = 200;
+
+/** The linked snapshot at cwd, or null: not git, no remote, or not linked. */
+function linkedSnapshot(env, cwd) {
+  const snapshot = takeSnapshot(cwd);
+  if (!snapshot?.repository || !snapshot.tree) return null;
+  const link = linkFor(snapshot.repository, env);
+  return link ? { snapshot, link } : null;
+}
+
+/** Record a deterministic checkpoint in the outbox: identity, tree hash, file names. */
+export function recordCheckpoint(env, snapshot, event, now = Date.now(), agent = "claude-code") {
+  const changedFiles = snapshot.changedFiles
+    .slice(0, MAX_FILES)
+    .map((name) => (findSecret(name) ? "[file name withheld]" : name));
+  return enqueue({
+    kind: "checkpoint",
+    key: `${snapshot.repository.toLowerCase()}#${snapshot.branch}`,
+    body: {
+      repository: snapshot.repository,
+      branch: snapshot.branch,
+      commit: snapshot.commit,
+      treeHash: snapshot.tree,
+      dirty: snapshot.dirty,
+      changedFiles: [...new Set(changedFiles)],
+      source: agent,
+      event,
+      capturedAt: now,
+    },
+  }, { env, now });
+}
+
+function sealRequest(firstHandoff) {
+  const goal = firstHandoff ? ' --goal "<the goal>"' : "";
+  return [
+    "Hypher: the working tree changed since the last handoff, and no one saved why.",
+    "Before you stop, record the decisions that changed and the next action for the next agent:",
+    `run \`hypher seal${goal} --decision "<a decision that changed>" --why "<why>" --next "<the next action>"\` in the terminal, or call the \`seal\` tool of the hypher MCP server with the same fields.`,
+    "Add one --decision/--why pair per changed decision (--replaces D1 names one it replaces), or none if no decision changed; --next is always needed.",
+    "It sends only your text, file names, and commit identity. Hypher asks once; if you cannot save now, say so and stop.",
+  ].join(" ");
+}
+
+async function sessionStart(agent, env, input) {
+  const result = await resumeHere({
+    env,
+    cwd: input.cwd || process.cwd(),
+    destination: agent,
+    sessionId: typeof input.session_id === "string" ? input.session_id : undefined,
+    timeoutMs: HOOK_TIMEOUT_MS,
+  });
+  if (result.status === "not-git" || !result.note) return null;
+  return { hookSpecificOutput: { hookEventName: "SessionStart", additionalContext: result.note } };
+}
+
+async function stop(agent, env, input, now = Date.now()) {
+  const found = linkedSnapshot(env, input.cwd || process.cwd());
+  if (!found) return null;
+  const { snapshot } = found;
+  recordCheckpoint(env, snapshot, "Stop", now, agent);
+  if (shouldFlush(env, now)) {
+    await flushOutbox(createClient({ env, timeoutMs: HOOK_TIMEOUT_MS }), { env, now }).catch(() => null);
+  }
+
+  const state = readWorktreeState(env, snapshot.root) ?? {};
+  const branch = branchState(state, snapshot.branch);
+  const pass = (patch = {}) => {
+    updateWorktreeState(env, snapshot.root, (current) => withBranchState(current, snapshot.branch, { blockedLast: false, ...patch }));
+    return null;
+  };
+  // Never block twice in a row: the version's flag when it sends one, else local state.
+  if (input.stop_hook_active === true || branch.blockedLast) return pass();
+  if (!branch.sealTree) return pass({ sealTree: snapshot.tree });
+  const changed = snapshot.tree !== branch.sealTree;
+  const askedRecently = typeof branch.askedAt === "number" && now - branch.askedAt < ASK_AGAIN_AFTER_MS;
+  if (!changed || askedRecently) return pass();
+  updateWorktreeState(env, snapshot.root, (current) => withBranchState(current, snapshot.branch, {
+    askedAt: now, askedTree: snapshot.tree, blockedLast: true,
+  }));
+  return { decision: "block", reason: sealRequest(!state.proposal) };
+}
+
+async function checkpointAndUpload(agent, env, input, event, now = Date.now()) {
+  const found = linkedSnapshot(env, input.cwd || process.cwd());
+  if (!found) return null;
+  recordCheckpoint(env, found.snapshot, event, now, agent);
+  await flushOutbox(createClient({ env, timeoutMs: HOOK_TIMEOUT_MS }), { env, now }).catch(() => null);
+  return null;
+}
+
+/** The agents that get hooks. Every other tool uses the standard door. */
+export const HOOK_AGENTS = ["claude-code", "codex"];
+
+/**
+ * @param {"claude-code" | "codex"} agent
+ * @param {string} event
+ * @param {Record<string, any>} input the hook payload
+ * @param {NodeJS.ProcessEnv} env
+ */
+export async function handleAgentHook(agent, event, input, env) {
+  switch (event) {
+    case "SessionStart":
+      return await sessionStart(agent, env, input);
+    case "Stop":
+      return await stop(agent, env, input);
+    case "PreCompact":
+    case "SessionEnd":
+      return await checkpointAndUpload(agent, env, input, event);
+    default:
+      return null;
+  }
+}
+
+export function handleClaudeHook(event, input, env) {
+  return handleAgentHook("claude-code", event, input, env);
+}