token-goat 2.9.29 → 2.9.31

package/dist/token-goat-chunk-IAGXMHIK.mjs

@@ -0,0 +1,863 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  serveOne,
+  swapEnv
+} from "./token-goat-chunk-XRKUX6CM.mjs";
+import {
+  relayInProcess
+} from "./token-goat-chunk-VXEXMJDL.mjs";
+import "./token-goat-chunk-Q5QDBC6O.mjs";
+import "./token-goat-chunk-G5PJ7AGM.mjs";
+import "./token-goat-chunk-5RG5SBL6.mjs";
+import "./token-goat-chunk-HLPW63A7.mjs";
+import {
+  HOOK_EVENTS
+} from "./token-goat-chunk-KKUFXAPD.mjs";
+import "./token-goat-chunk-6ENQSNRZ.mjs";
+import "./token-goat-chunk-PX5PQWTY.mjs";
+import "./token-goat-chunk-VWDXLT4F.mjs";
+import "./token-goat-chunk-DOWRSMWO.mjs";
+import "./token-goat-chunk-5AC66HNP.mjs";
+import "./token-goat-chunk-PUO5INXP.mjs";
+import "./token-goat-chunk-2XBMMDBD.mjs";
+import "./token-goat-chunk-PFWIMH2E.mjs";
+import "./token-goat-chunk-Z7N5OMMP.mjs";
+import "./token-goat-chunk-LCNQ2CNN.mjs";
+import "./token-goat-chunk-GWFLAUMQ.mjs";
+import "./token-goat-chunk-PJZXIS3G.mjs";
+import "./token-goat-chunk-JVFSHVFJ.mjs";
+import "./token-goat-chunk-ODBT2USM.mjs";
+import "./token-goat-chunk-DGS2LVNA.mjs";
+import "./token-goat-chunk-INNPTRUX.mjs";
+import "./token-goat-chunk-VWZA2H4P.mjs";
+import "./token-goat-chunk-N5LSOVSU.mjs";
+import "./token-goat-chunk-OBOFIHKN.mjs";
+import {
+  primeHiddenRulesAhead,
+  primeManagedPolicyAhead
+} from "./token-goat-chunk-QH7YVYOY.mjs";
+import "./token-goat-chunk-NOSS5VWY.mjs";
+import "./token-goat-chunk-NMD42SFQ.mjs";
+import "./token-goat-chunk-SAMFDIS2.mjs";
+import "./token-goat-chunk-4SMRO4TO.mjs";
+import "./token-goat-chunk-WBA5SKT4.mjs";
+import "./token-goat-chunk-MNWKPRAL.mjs";
+import "./token-goat-chunk-CIMQ2BB3.mjs";
+import "./token-goat-chunk-WDH44VAU.mjs";
+import "./token-goat-chunk-BPGCUMR7.mjs";
+import "./token-goat-chunk-KQBLRPBN.mjs";
+import "./token-goat-chunk-4ZBFWLXF.mjs";
+import {
+  materializeShrunkImageFile
+} from "./token-goat-chunk-C75NA7PL.mjs";
+import "./token-goat-chunk-CBIQ7WTD.mjs";
+import "./token-goat-chunk-P6VGNTQT.mjs";
+import {
+  COPILOT_CLI_TOOL_NAME_MAP,
+  foldToolName
+} from "./token-goat-chunk-76FGDLRO.mjs";
+import "./token-goat-chunk-GL3ETKSC.mjs";
+import "./token-goat-chunk-OXFMP75N.mjs";
+import "./token-goat-chunk-NISNMD7T.mjs";
+import "./token-goat-chunk-EVMZJ27Z.mjs";
+import "./token-goat-chunk-IK2DRMFX.mjs";
+import "./token-goat-chunk-5Y6ZYL6U.mjs";
+import "./token-goat-chunk-4NAPX7BA.mjs";
+import "./token-goat-chunk-U4WHMG6Y.mjs";
+import {
+  limitDbWaitsForHook
+} from "./token-goat-chunk-GVB2MUST.mjs";
+import "./token-goat-chunk-XB5KKOCG.mjs";
+import "./token-goat-chunk-OUKDTVNU.mjs";
+import "./token-goat-chunk-3BTK54F3.mjs";
+import "./token-goat-chunk-4GILLLWY.mjs";
+import {
+  HARNESS_PROTOCOL_VERSION,
+  PROTOCOL_VERSION,
+  SERVER_SLOTS,
+  bundleEntryFiles,
+  challengeMacV2,
+  configStamp,
+  doneFrameMac,
+  endpointFor,
+  ensureServerKey,
+  mac,
+  macMatches,
+  nonce,
+  outFrameMac,
+  readFrames,
+  removeMarker,
+  requestMacV2,
+  serverKeyPath,
+  touchMarker,
+  writeFrame
+} from "./token-goat-chunk-N5MMR2IW.mjs";
+import "./token-goat-chunk-BFCWY73P.mjs";
+import "./token-goat-chunk-KGEFFSHD.mjs";
+import "./token-goat-chunk-XX6O25RN.mjs";
+import "./token-goat-chunk-HAVAOB3S.mjs";
+import "./token-goat-chunk-F6PAUIEK.mjs";
+import "./token-goat-chunk-65N4RHP4.mjs";
+import "./token-goat-chunk-X2SUP3EI.mjs";
+import "./token-goat-chunk-T5P5ACNQ.mjs";
+import {
+  hookServerEnabled,
+  ownGet
+} from "./token-goat-chunk-7EZTZOMC.mjs";
+import "./token-goat-chunk-QYHO5CPH.mjs";
+import "./token-goat-chunk-4GBVPH3D.mjs";
+import {
+  clearPerRequestCaches
+} from "./token-goat-chunk-YZAAZU2S.mjs";
+import "./token-goat-chunk-IVE6U7KV.mjs";
+import "./token-goat-chunk-Y4AFKTHK.mjs";
+import "./token-goat-chunk-HU4TORC5.mjs";
+import "./token-goat-chunk-GGGG7RWB.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import {
+  VERSION,
+  configPath,
+  ensureDataDirPrivate
+} from "./token-goat-chunk-CO3UYX6G.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/hook_server.ts
+init_define_import_meta_env();
+import * as fs from "node:fs";
+import * as net from "node:net";
+import * as os from "node:os";
+
+// src/hook_adapters.ts
+init_define_import_meta_env();
+import * as crypto from "node:crypto";
+var ADAPTER_HARNESSES = ["claudecode", "codex", "grok", "kimi", "copilot_cli"];
+function isAdapterHarness(name) {
+  return typeof name === "string" && ADAPTER_HARNESSES.includes(name);
+}
+var HOOK_EVENT_SET = new Set(HOOK_EVENTS);
+var done = (stdout, exit = 0) => ({ stdout, exit });
+function get(v, k) {
+  return v === null || v === void 0 ? void 0 : v[k];
+}
+async function relayAsShim(event, input, io, harnessWaitMs) {
+  let payload;
+  try {
+    payload = JSON.parse(input);
+  } catch {
+    const text = input.trim();
+    let lenient = {};
+    if (text !== "") {
+      try {
+        lenient = JSON.parse(text);
+      } catch {
+        lenient = {};
+      }
+    }
+    const out = await io.relay(event, lenient);
+    return out === "" ? void 0 : out;
+  }
+  return io.relay(event, payload, harnessWaitMs);
+}
+var ASYNC_DETACH_TOOLS = /* @__PURE__ */ new Set(["Edit", "Write", "MultiEdit", "NotebookEdit"]);
+var ASYNC_DETACH_SKIP_EXT_RE = /\.(md|mdx|markdown|rst)$/i;
+var ASYNC_DETACH_BASH_MAX_BYTES = 200;
+var ASYNC_DETACH_BASH_TEXT_KEYS = ["output", "content", "text", "body", "stdout", "stderr"];
+var ASYNC_DETACH_LINE = '{"async":true}\n';
+function bashResultByteLength(resp) {
+  if (typeof resp === "string") return Buffer.byteLength(resp, "utf8");
+  if (resp && typeof resp === "object") {
+    const persisted = get(resp, "persistedOutputSize");
+    if (typeof persisted === "number") return persisted;
+    for (const key of ASYNC_DETACH_BASH_TEXT_KEYS) {
+      const text = get(resp, key);
+      if (typeof text === "string" && text !== "") return Buffer.byteLength(text, "utf8");
+    }
+    return Buffer.byteLength(JSON.stringify(resp), "utf8");
+  }
+  return 0;
+}
+var TG_LEDGER_PREFIX_RE = /^(?:(?:cd\s+(?:"[^"]*"|'[^']*'|\S+)|export[ \t]+[A-Za-z_]\w*=(?:"[^"]*"|'[^']*'|[^\s"'])*(?:[ \t]+[A-Za-z_]\w*=(?:"[^"]*"|'[^']*'|[^\s"'])*)*)[ \t]*(?:&&|;|\r?\n)\s*)+/;
+var TG_LEDGER_READ_RE = /^(?:[A-Za-z_][A-Za-z0-9_]*=\S+\s+)*(?:env\s+(?:(?:(?:-u|--unset)\s+\S+|-(?![A-Za-z]*C|-c)\S*|[A-Za-z_][A-Za-z0-9_]*=\S+)\s+)*)?(?:token-goat|tg|node(?:\.exe)?\s+["']?(?:\S*[\\/])?token-goat(?:\.mjs)?["']?)\s+(?:read|section|symbol)\b/i;
+function isLedgerReadCommand(cmd) {
+  if (typeof cmd !== "string") return false;
+  const body = cmd.trim().replace(/^\(\s*/, "");
+  return TG_LEDGER_READ_RE.test((body.replace(TG_LEDGER_PREFIX_RE, "") || body).trim());
+}
+function isAsyncDetachEligible(event, input) {
+  if (event === "subagent_stop") return true;
+  if (event !== "post_tool_use") return false;
+  try {
+    const payload = JSON.parse(input);
+    const toolName = get(payload, "tool_name");
+    if (ASYNC_DETACH_TOOLS.has(toolName)) {
+      const toolInput = get(payload, "tool_input") || {};
+      const filePath = get(toolInput, "file_path");
+      const notebookPath = get(toolInput, "notebook_path");
+      return !ASYNC_DETACH_SKIP_EXT_RE.test(typeof filePath === "string" ? filePath : typeof notebookPath === "string" ? notebookPath : "");
+    }
+    if (toolName === "Bash") return !isLedgerReadCommand(get(get(payload, "tool_input"), "command")) && bashResultByteLength(get(payload, "tool_response")) < ASYNC_DETACH_BASH_MAX_BYTES;
+    return false;
+  } catch {
+    return false;
+  }
+}
+var TG_CD_PREFIX_RE = /^(?:cd\s+(?:"[^"]*"|'[^']*'|\S+)[ \t]*(?:&&|;|\r?\n)\s*)+/;
+var TG_OWN_COMMAND_RE = /^(?:[A-Za-z_][A-Za-z0-9_]*=\S+\s+)*(?:token-goat\b|node(?:\.exe)?\s+["']?(?:\S*[\\/])?token-goat(?:\.mjs)?["']?\b)/i;
+function isOwnTokenGoatCommand(cmd) {
+  if (typeof cmd !== "string" || cmd.trim() === "") return false;
+  const body = (cmd.replace(TG_CD_PREFIX_RE, "") || cmd).trim();
+  if (/[;&|`]|\$\(/.test(body)) return false;
+  return TG_OWN_COMMAND_RE.test(body);
+}
+var claudecode = {
+  unknown: "{}",
+  events: HOOK_EVENTS,
+  lost: () => "{}",
+  async run(req, io) {
+    const { event, input } = req;
+    if (!HOOK_EVENT_SET.has(event)) return done("{}");
+    if (event === "pre_tool_use") {
+      try {
+        const payload = JSON.parse(input);
+        if (get(payload, "tool_name") === "Bash" && isOwnTokenGoatCommand(get(get(payload, "tool_input"), "command"))) return done("{}");
+      } catch {
+      }
+    }
+    let harnessWaitMs = req.harnessWaitMs;
+    if (isAsyncDetachEligible(event, input)) harnessWaitMs = io.early(ASYNC_DETACH_LINE);
+    return done(await relayAsShim(event, input, io, harnessWaitMs) ?? "{}");
+  }
+};
+function stripTg(value) {
+  if (Array.isArray(value)) return value.map(stripTg);
+  if (value && typeof value === "object") {
+    const out = {};
+    for (const [k, v] of Object.entries(value)) {
+      if (k.startsWith("_tg_")) continue;
+      out[k] = stripTg(v);
+    }
+    return out;
+  }
+  return value;
+}
+function codexTranslate(stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return "{}";
+  }
+  return JSON.stringify(stripTg(parsed));
+}
+var codex = {
+  unknown: "{}",
+  events: HOOK_EVENTS,
+  lost: () => "{}",
+  async run(req, io) {
+    process.env["TOKEN_GOAT_HARNESS_OVERRIDE"] = "codex";
+    if (!HOOK_EVENT_SET.has(req.event)) return done("{}");
+    const stdout = await relayAsShim(req.event, req.input, io, req.harnessWaitMs);
+    return done(stdout === void 0 ? "{}" : codexTranslate(stdout));
+  }
+};
+var GROK_EVENTS = ["pre_tool_use", "post_tool_use", "notification", "stop", "pre_compact", "user_prompt_submit", "subagent_stop"];
+var GROK_EVENT_SET = new Set(GROK_EVENTS);
+function grokAllow(event) {
+  return event === "pre_tool_use" ? '{"decision":"allow"}' : "{}";
+}
+function grokTranslate(event, stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return done(grokAllow(event));
+  }
+  if (event !== "pre_tool_use") return done(JSON.stringify(parsed));
+  if (parsed && get(parsed, "decision") === "block") {
+    return done(JSON.stringify({ decision: "deny", reason: get(parsed, "reason") || "blocked by token-goat" }), 2);
+  }
+  return done('{"decision":"allow"}');
+}
+var grok = {
+  unknown: "{}",
+  events: GROK_EVENTS,
+  lost: (event) => grokTranslate(event, "{}").stdout,
+  async run(req, io) {
+    if (!GROK_EVENT_SET.has(req.event)) return done("{}");
+    try {
+      const stdout = await relayAsShim(req.event, req.input, io, req.harnessWaitMs);
+      return stdout === void 0 ? done(grokAllow(req.event)) : grokTranslate(req.event, stdout);
+    } catch {
+      return done(grokAllow(req.event));
+    }
+  }
+};
+function kimiHintText(parsed) {
+  if (!parsed || typeof parsed !== "object") return "";
+  const hso = get(parsed, "hookSpecificOutput");
+  const context = get(hso, "additionalContext");
+  if (hso && typeof hso === "object" && typeof context === "string") return context;
+  const systemMessage = get(parsed, "systemMessage");
+  if (typeof systemMessage === "string") return systemMessage;
+  return "";
+}
+function kimiTranslate(stdout) {
+  let parsed;
+  try {
+    parsed = JSON.parse(stdout);
+  } catch {
+    return "";
+  }
+  if (!parsed || typeof parsed !== "object") return "";
+  const reason = get(parsed, "reason");
+  if (get(parsed, "decision") === "block" && typeof reason === "string" && reason) {
+    return JSON.stringify({ message: reason, hookSpecificOutput: { permissionDecision: "deny", permissionDecisionReason: reason } });
+  }
+  const hint = kimiHintText(parsed);
+  if (hint) return JSON.stringify({ message: hint });
+  return "";
+}
+var kimi = {
+  unknown: "",
+  events: HOOK_EVENTS,
+  lost: () => kimiTranslate("{}"),
+  async run(req, io) {
+    process.env["TOKEN_GOAT_HARNESS_OVERRIDE"] = "kimi";
+    if (!HOOK_EVENT_SET.has(req.event)) return done("");
+    try {
+      const stdout = await relayAsShim(req.event, req.input, io, req.harnessWaitMs);
+      return done(stdout === void 0 ? "" : kimiTranslate(stdout));
+    } catch {
+      return done("");
+    }
+  }
+};
+var COPILOT_TO_TG_EVENT = {
+  sessionStart: "session_start",
+  preToolUse: "pre_tool_use",
+  postToolUse: "post_tool_use",
+  preCompact: "pre_compact",
+  agentStop: "stop",
+  subagentStop: "subagent_stop",
+  userPromptSubmitted: "user_prompt_submit",
+  postToolUseFailure: "post_tool_use_failure",
+  subagentStart: "subagent_start"
+};
+var VSCODE_ONLY_TO_TG_EVENT = {
+  SubagentStart: "subagent_start"
+};
+var FOLDED_COPILOT_TOOL_TO_TG = {};
+for (const [k, v] of Object.entries(COPILOT_CLI_TOOL_NAME_MAP)) FOLDED_COPILOT_TOOL_TO_TG[foldToolName(k)] = v;
+for (const v of Object.values(COPILOT_CLI_TOOL_NAME_MAP)) FOLDED_COPILOT_TOOL_TO_TG[foldToolName(v)] = v;
+function ownLookup(map, key) {
+  return typeof key === "string" ? ownGet(map, key) : void 0;
+}
+function unqualified(name) {
+  return typeof name === "string" && name.includes(":") ? name.split(":").pop() : name;
+}
+function copilotCanonicalToolName(name) {
+  if (!name || typeof name !== "string") return name;
+  const direct = ownGet(COPILOT_CLI_TOOL_NAME_MAP, name);
+  if (direct !== void 0) return direct;
+  const stripped = unqualified(name);
+  const strippedDirect = ownLookup(COPILOT_CLI_TOOL_NAME_MAP, stripped);
+  if (strippedDirect !== void 0) return strippedDirect;
+  return ownGet(FOLDED_COPILOT_TOOL_TO_TG, foldToolName(name)) || ownGet(FOLDED_COPILOT_TOOL_TO_TG, foldToolName(stripped)) || name;
+}
+function parseMaybeJsonObject(value) {
+  if (value && typeof value === "object") return value;
+  if (typeof value === "string") {
+    try {
+      const parsed = JSON.parse(value);
+      if (parsed && typeof parsed === "object") return parsed;
+    } catch {
+    }
+  }
+  return {};
+}
+function stableFallbackSessionId(cwd) {
+  const key = typeof cwd === "string" && cwd ? cwd : process.cwd();
+  return "copilot-" + crypto.createHash("sha256").update(key).digest("hex").slice(0, 16);
+}
+function copilotContext(resp) {
+  const hso = resp && get(resp, "hookSpecificOutput");
+  const context = get(hso, "additionalContext");
+  if (hso && typeof context === "string") return context;
+  const systemMessage = get(resp, "systemMessage");
+  if (resp && typeof systemMessage === "string") return systemMessage;
+  return void 0;
+}
+function copilotTranslate(copilotEvent, resp, toolName, originalToolArgs) {
+  if (copilotEvent === "preToolUse") {
+    const hso = resp && get(resp, "hookSpecificOutput");
+    const denied = resp && (get(resp, "decision") === "block" || hso && get(hso, "permissionDecision") === "deny");
+    if (denied) {
+      const reason = resp && get(resp, "reason") || hso && get(hso, "permissionDecisionReason") || "blocked by token-goat";
+      return { permissionDecision: "deny", permissionDecisionReason: reason };
+    }
+    const context = copilotContext(resp);
+    const shrinkPayload = typeof context === "string" && context.includes("data:image/");
+    const out = {};
+    const updated = hso && get(hso, "updatedInput");
+    if (updated && typeof updated === "object") {
+      out["modifiedArgs"] = updated;
+    } else if (shrinkPayload && (toolName === "view" || foldToolName(toolName) === "view")) {
+      const shrunkPath = materializeShrunkImageFile(context);
+      if (shrunkPath) out["modifiedArgs"] = Object.assign({}, originalToolArgs, { path: shrunkPath });
+    }
+    if (context && !shrinkPayload) out["additionalContext"] = context;
+    return out;
+  }
+  if (copilotEvent === "postToolUse") {
+    const hso = resp && get(resp, "hookSpecificOutput");
+    const updatedToolOutput = hso && get(hso, "updatedToolOutput");
+    const context = copilotContext(resp);
+    const out = {};
+    if (typeof updatedToolOutput === "string") out["modifiedResult"] = { resultType: "success", textResultForLlm: updatedToolOutput };
+    if (context) out["additionalContext"] = context;
+    return out;
+  }
+  if (copilotEvent === "postToolUseFailure" || copilotEvent === "sessionStart" || copilotEvent === "subagentStart" || copilotEvent === "userPromptSubmitted") {
+    const context = copilotContext(resp);
+    return context ? { additionalContext: context } : {};
+  }
+  if (copilotEvent === "agentStop" || copilotEvent === "subagentStop") {
+    if (resp && get(resp, "decision") === "block") return { decision: "block", reason: resp && get(resp, "reason") || "blocked by token-goat" };
+    const stopHso = resp && get(resp, "hookSpecificOutput");
+    const modifiedResponse = stopHso && get(stopHso, "updatedToolOutput");
+    if (copilotEvent === "subagentStop" && typeof modifiedResponse === "string") return { modifiedResponse };
+    return { decision: "allow" };
+  }
+  return {};
+}
+function viaJson(value) {
+  return JSON.parse(JSON.stringify(value));
+}
+async function copilotRelayVscode(tgEvent, payload, scriptDir, io) {
+  process.env["TOKEN_GOAT_HARNESS_OVERRIDE"] = "vscode";
+  if (scriptDir !== void 0) process.env["TOKEN_GOAT_VSCODE_HOOKS_DIR"] = scriptDir;
+  const sessionId = get(payload, "session_id");
+  const input = typeof sessionId === "string" && sessionId !== "" ? payload : Object.assign({}, payload, { session_id: stableFallbackSessionId(process.cwd()) });
+  const stdout = await io.relay(tgEvent, viaJson(input));
+  try {
+    const parsed = JSON.parse(stdout);
+    return parsed !== null && typeof parsed === "object" && !Array.isArray(parsed) ? JSON.stringify(parsed) : "{}";
+  } catch {
+    return "{}";
+  }
+}
+async function copilotRun(req, io) {
+  const copilotEvent = req.event;
+  const vscodeOnly = ownGet(VSCODE_ONLY_TO_TG_EVENT, copilotEvent);
+  const tgEvent = ownGet(COPILOT_TO_TG_EVENT, copilotEvent) ?? vscodeOnly;
+  if (!tgEvent) return "{}";
+  let payload;
+  try {
+    payload = JSON.parse(req.input);
+  } catch {
+    return "{}";
+  }
+  if (payload !== null && typeof payload === "object" && typeof get(payload, "hook_event_name") === "string" && get(payload, "toolName") === void 0) {
+    return copilotRelayVscode(tgEvent, payload, req.scriptDir, io);
+  }
+  if (vscodeOnly !== void 0) return "{}";
+  const toolName = payload && get(payload, "toolName");
+  const workingDirectory = payload && (get(payload, "workingDirectory") || get(payload, "cwd"));
+  const canonical = {
+    session_id: payload && get(payload, "sessionId") || stableFallbackSessionId(workingDirectory),
+    cwd: workingDirectory
+  };
+  const agentId = payload && (get(payload, "agent_id") || get(payload, "agentId"));
+  if (typeof agentId === "string" && agentId !== "") canonical["agent_id"] = agentId;
+  const traceparent = payload && (get(payload, "traceparent") || get(payload, "traceParent"));
+  if (typeof traceparent === "string" && traceparent !== "") canonical["traceparent"] = traceparent;
+  const tracestate = payload && (get(payload, "tracestate") || get(payload, "traceState"));
+  if (typeof tracestate === "string" && tracestate !== "") canonical["tracestate"] = tracestate;
+  const prompt = get(payload, "prompt");
+  if (typeof prompt === "string" && prompt !== "") canonical["prompt"] = prompt;
+  const response = get(payload, "response");
+  if (typeof response === "string" && response !== "") canonical["last_assistant_message"] = response;
+  let originalToolArgs = {};
+  if (toolName) {
+    originalToolArgs = parseMaybeJsonObject(get(payload, "toolArgs"));
+    canonical["tool_name"] = copilotCanonicalToolName(toolName);
+    canonical["tool_input"] = originalToolArgs;
+  }
+  const error = get(payload, "error");
+  if (typeof error === "string" && error !== "") canonical["error"] = error;
+  const rawResult = get(payload, "toolResult");
+  if (rawResult && typeof rawResult === "object") {
+    const camel = get(rawResult, "textResultForLlm");
+    const text = typeof camel === "string" ? camel : get(rawResult, "text_result_for_llm");
+    if (typeof text === "string") canonical["tool_response"] = text;
+  }
+  process.env["TOKEN_GOAT_HARNESS_OVERRIDE"] = "copilot_cli";
+  if (req.scriptDir !== void 0) process.env["TOKEN_GOAT_COPILOT_HOOKS_DIR"] = req.scriptDir;
+  else delete process.env["TOKEN_GOAT_COPILOT_HOOKS_DIR"];
+  const stdout = await io.relay(tgEvent, viaJson(canonical));
+  let resp;
+  try {
+    resp = JSON.parse(stdout);
+  } catch {
+    return "{}";
+  }
+  return JSON.stringify(copilotTranslate(copilotEvent, resp, toolName, originalToolArgs));
+}
+var copilotCli = {
+  unknown: "{}",
+  events: [...Object.keys(COPILOT_TO_TG_EVENT), ...Object.keys(VSCODE_ONLY_TO_TG_EVENT)],
+  lost: (event) => JSON.stringify(copilotTranslate(event, {}, void 0, {})),
+  async run(req, io) {
+    try {
+      return done(await copilotRun(req, io));
+    } catch {
+      return done("{}");
+    }
+  }
+};
+var ADAPTERS = { claudecode, codex, grok, kimi, copilot_cli: copilotCli };
+async function runAdapter(harness, req, io) {
+  try {
+    return await ADAPTERS[harness].run(req, io);
+  } catch {
+    return done(harness === "grok" ? grokAllow(req.event) : ADAPTERS[harness].unknown);
+  }
+}
+function noopOutputs(harness) {
+  const adapter = ADAPTERS[harness];
+  const noops = [];
+  for (const event of [...adapter.events].sort()) {
+    const out = adapter.lost(event);
+    if (out !== adapter.unknown) noops.push([event, out]);
+  }
+  return { noop: adapter.unknown, noops };
+}
+function noopFor(harness, event) {
+  const { noop, noops } = noopOutputs(harness);
+  return noops.find(([e]) => e === event)?.[1] ?? noop;
+}
+
+// src/hook_server.ts
+var IDLE_EXIT_MS = { primary: 30 * 6e4, overflow: 3 * 6e4 };
+var KEY_CHECK_MS = 2e3;
+var HANDSHAKE_IDLE_MS = 1e4;
+function bundleStamp() {
+  return bundleEntryFiles().map((f) => {
+    try {
+      const st = fs.statSync(f);
+      return `${st.size}:${st.mtimeMs}`;
+    } catch {
+      return "-";
+    }
+  }).join("|");
+}
+var enabledMemo;
+function stillEnabled() {
+  const key = `${process.env["TOKEN_GOAT_HOOK_SERVER"] ?? ""}|${configPath()}|${configStamp()}`;
+  if (enabledMemo?.key !== key) enabledMemo = { key, enabled: hookServerEnabled() };
+  return enabledMemo.enabled;
+}
+function retirementReason(loadedStamp, judgeEnabled) {
+  if (bundleStamp() !== loadedStamp) return "bundle replaced";
+  if (judgeEnabled && !stillEnabled()) return "disabled";
+  return void 0;
+}
+async function handle(request, runCli, send) {
+  clearPerRequestCaches();
+  if (request.kind === "cli") {
+    const res = await serveOne({ id: 0, argv: request.argv, cwd: request.cwd, env: request.env }, runCli, clearPerRequestCaches);
+    return send({ ok: true, stdout: res.stdout, stderr: res.stderr, status: res.status });
+  }
+  limitDbWaitsForHook();
+  const startedAt = performance.now();
+  const cwdBefore = process.cwd();
+  const restoreEnv = swapEnv(request.env);
+  const afterReply = [];
+  try {
+    process.chdir(request.cwd);
+    const payload = JSON.parse(request.input);
+    const stdout = await relayInProcess(request.event, payload, request.harnessWaitMs, { elapsedMs: () => request.elapsedMs + (performance.now() - startedAt), afterReply: (work) => afterReply.push(work) });
+    send({ ok: true, stdout });
+    for (const work of afterReply) work();
+  } finally {
+    restoreEnv();
+    try {
+      process.chdir(cwdBefore);
+    } catch {
+    }
+    clearPerRequestCaches();
+  }
+}
+function parseHarnessRequest(body, harness) {
+  let r;
+  try {
+    r = JSON.parse(body);
+  } catch {
+    return void 0;
+  }
+  if (r === null || typeof r !== "object") return void 0;
+  const q = r;
+  const env = q["env"];
+  const wellFormed = q["kind"] === "hook" && q["harness"] === harness && typeof q["event"] === "string" && typeof q["input"] === "string" && typeof q["cwd"] === "string" && typeof q["elapsedMs"] === "number" && (q["harnessWaitMs"] === void 0 || typeof q["harnessWaitMs"] === "number") && (q["scriptDir"] === void 0 || typeof q["scriptDir"] === "string") && env !== null && typeof env === "object" && !Array.isArray(env) && Object.values(env).every((v) => typeof v === "string");
+  return wellFormed ? q : void 0;
+}
+async function handleHarness(request, harness, early, finish) {
+  clearPerRequestCaches();
+  limitDbWaitsForHook();
+  const startedAt = performance.now();
+  const cwdBefore = process.cwd();
+  const restoreEnv = swapEnv(request.env);
+  const afterReply = [];
+  const elapsedMs = () => request.elapsedMs + (performance.now() - startedAt);
+  try {
+    process.chdir(request.cwd);
+    const req = { event: request.event, input: request.input, ...request.harnessWaitMs === void 0 ? {} : { harnessWaitMs: request.harnessWaitMs }, ...request.scriptDir === void 0 ? {} : { scriptDir: request.scriptDir } };
+    const result = await runAdapter(harness, req, {
+      // An early frame is where the harness stops waiting, so the wait it records is its own clock up to here.
+      early: (data) => {
+        early(data);
+        return elapsedMs();
+      },
+      // Only native/tg-hook speaks this protocol, so every call served here is one the native client had served.
+      relay: (event, payload, harnessWaitMs) => relayInProcess(event, payload, harnessWaitMs, { elapsedMs, afterReply: (work) => afterReply.push(work), detail: "native" })
+    });
+    finish(result.stdout, result.exit);
+    for (const work of afterReply) work();
+  } finally {
+    restoreEnv();
+    try {
+      process.chdir(cwdBefore);
+    } catch {
+    }
+    clearPerRequestCaches();
+  }
+}
+function listen(server, endpoint) {
+  const tryListen = () => new Promise((resolve) => {
+    server.once("error", resolve);
+    server.listen({ path: endpoint, readableAll: false, writableAll: false }, () => {
+      server.removeListener("error", resolve);
+      resolve(void 0);
+    });
+  });
+  return tryListen().then(async (err) => {
+    if (err === void 0) return true;
+    if (err.code !== "EADDRINUSE" || process.platform === "win32") return false;
+    const alive = await new Promise((resolve) => {
+      const probe = net.connect(endpoint);
+      probe.once("connect", () => {
+        probe.destroy();
+        resolve(true);
+      });
+      probe.once("error", () => resolve(false));
+    });
+    if (alive) return false;
+    fs.rmSync(endpoint, { force: true });
+    return await tryListen() === void 0;
+  });
+}
+async function runHookServer(slot, runCli) {
+  if (!Number.isInteger(slot) || slot < 0 || slot >= SERVER_SLOTS) throw new Error(`--slot must be an integer from 0 to ${SERVER_SLOTS - 1}`);
+  if (!hookServerEnabled()) {
+    touchMarker("disabled", configStamp());
+    return;
+  }
+  ensureDataDirPrivate();
+  primeHiddenRulesAhead();
+  primeManagedPolicyAhead();
+  const key = ensureServerKey();
+  const keyPath = serverKeyPath();
+  const loadedStamp = bundleStamp();
+  const endpoint = endpointFor(slot);
+  process.chdir(os.tmpdir());
+  const status = { pid: process.pid, slot, version: VERSION, startedAt: Date.now(), lastUsedAt: Date.now(), served: 0, errors: 0 };
+  let busy = false;
+  let retiring = false;
+  let idleTimer;
+  const flushing = /* @__PURE__ */ new Set();
+  const awaitingRequest = /* @__PURE__ */ new Set();
+  const endWith = (socket, frame) => {
+    const flushed = new Promise((resolve) => {
+      socket.once("close", () => resolve());
+      writeFrame(socket, frame);
+      socket.end(() => resolve());
+    });
+    flushing.add(flushed);
+    void flushed.then(() => flushing.delete(flushed));
+  };
+  let socketIno;
+  const ownsEndpoint = () => {
+    if (socketIno === void 0) return true;
+    try {
+      return fs.statSync(endpoint, { bigint: true, throwIfNoEntry: false })?.ino === socketIno;
+    } catch {
+      return true;
+    }
+  };
+  const server = net.createServer((socket) => serveConnection(socket));
+  const exitOnceFlushed = () => void Promise.all(flushing).then(() => process.exit(0));
+  const stop = () => {
+    retiring = true;
+    if (idleTimer !== void 0) clearTimeout(idleTimer);
+    if (ownsEndpoint()) server.close();
+    for (const socket of awaitingRequest) endWith(socket, { t: "stale" });
+    awaitingRequest.clear();
+    if (!busy) exitOnceFlushed();
+  };
+  const armIdle = () => {
+    if (idleTimer !== void 0) clearTimeout(idleTimer);
+    idleTimer = setTimeout(stop, slot === 0 ? IDLE_EXIT_MS.primary : IDLE_EXIT_MS.overflow);
+  };
+  function serveConnection(socket) {
+    let nc = "";
+    let ns = "";
+    let harness;
+    socket.setTimeout(HANDSHAKE_IDLE_MS, () => socket.destroy());
+    socket.on("error", () => socket.destroy());
+    socket.once("close", () => awaitingRequest.delete(socket));
+    const onMessage = (msg) => {
+      if (msg["t"] === "hello" && nc === "") {
+        const v2 = msg["v"] === HARNESS_PROTOCOL_VERSION;
+        if (msg["v"] !== PROTOCOL_VERSION && !v2 || typeof msg["nc"] !== "string" || msg["nc"] === "") return void socket.destroy();
+        if (v2) {
+          if (typeof msg["h"] !== "string") return void socket.destroy();
+          if (!isAdapterHarness(msg["h"])) return void endWith(socket, { t: "refused", reason: "unknown harness" });
+          harness = msg["h"];
+        }
+        const reason = retiring ? "retiring" : retirementReason(loadedStamp, !busy);
+        if (reason !== void 0) {
+          if (reason === "disabled") touchMarker("disabled", configStamp());
+          if (reason === "bundle replaced") removeMarker(`spawn-${slot}`);
+          writeFrame(socket, { t: "stale" });
+          socket.end(() => {
+            if (!retiring) stop();
+          });
+          return;
+        }
+        if (busy && (harness !== void 0 || msg["ctl"] !== true)) {
+          writeFrame(socket, { t: "busy" });
+          return void socket.end();
+        }
+        nc = msg["nc"];
+        ns = nonce();
+        if (harness === void 0) {
+          writeFrame(socket, { t: "challenge", v: PROTOCOL_VERSION, ns, mac: mac(key, "S", nc, ns) });
+        } else {
+          const { noop, noops } = noopOutputs(harness);
+          writeFrame(socket, { t: "challenge", v: HARNESS_PROTOCOL_VERSION, ns, noop, noops, mac: challengeMacV2(key, nc, ns, harness, noop, noops) });
+        }
+        awaitingRequest.add(socket);
+        return;
+      }
+      if (msg["t"] === "req" && ns !== "" && harness !== void 0) {
+        const h = harness;
+        const body = msg["body"];
+        if (typeof body !== "string" || !macMatches(requestMacV2(key, nc, ns, h, body), msg["mac"])) return void socket.destroy();
+        if (!awaitingRequest.delete(socket)) return;
+        const request = parseHarnessRequest(body, h);
+        if (request === void 0) return void socket.destroy();
+        if (busy || retiring) {
+          writeFrame(socket, { t: retiring ? "stale" : "busy" });
+          return void socket.end();
+        }
+        busy = true;
+        socket.setTimeout(0);
+        let seq = 0;
+        let finished = false;
+        const early = (data) => {
+          if (finished) return;
+          writeFrame(socket, { t: "out", seq, data, mac: outFrameMac(key, nc, ns, seq, data) });
+          seq++;
+        };
+        const finish = (stdout, exit) => {
+          if (finished) return;
+          finished = true;
+          endWith(socket, { t: "done", stdout, exit, n: seq, mac: doneFrameMac(key, nc, ns, stdout, exit, seq) });
+        };
+        void (async () => {
+          try {
+            await handleHarness(request, h, early, finish);
+            status.served++;
+          } catch {
+            status.errors++;
+            finish(noopFor(h, request.event), 0);
+          }
+          busy = false;
+          status.lastUsedAt = Date.now();
+          if (retiring) stop();
+          else armIdle();
+        })();
+        return;
+      }
+      if (msg["t"] === "req" && ns !== "") {
+        const body = msg["body"];
+        if (typeof body !== "string" || !macMatches(mac(key, "C", nc, ns, body), msg["mac"])) return void socket.destroy();
+        if (!awaitingRequest.delete(socket)) return;
+        let request;
+        let parseError;
+        try {
+          request = JSON.parse(body);
+        } catch (e) {
+          parseError = e;
+        }
+        const kind = request?.kind;
+        if (kind === "status" || kind === "stop") {
+          const resBody = JSON.stringify({ ok: true, info: { ...status } });
+          endWith(socket, { t: "res", mac: mac(key, "R", nc, ns, resBody), body: resBody });
+          if (kind === "stop" && !retiring) stop();
+          return;
+        }
+        if (busy || retiring) {
+          writeFrame(socket, { t: retiring ? "stale" : "busy" });
+          return void socket.end();
+        }
+        busy = true;
+        socket.setTimeout(0);
+        let replied = false;
+        const reply = (res) => {
+          if (replied) return;
+          replied = true;
+          const resBody = JSON.stringify(res);
+          endWith(socket, { t: "res", mac: mac(key, "R", nc, ns, resBody), body: resBody });
+        };
+        void (async () => {
+          try {
+            if (request === void 0) throw parseError;
+            await handle(request, runCli, reply);
+            status.served++;
+          } catch (e) {
+            status.errors++;
+            reply({ ok: false, error: e instanceof Error ? e.message : String(e) });
+          }
+          busy = false;
+          status.lastUsedAt = Date.now();
+          if (retiring) stop();
+          else armIdle();
+        })();
+        return;
+      }
+      socket.destroy();
+    };
+    readFrames(socket, onMessage, () => void 0);
+  }
+  if (!await listen(server, endpoint)) return;
+  if (process.platform !== "win32") socketIno = fs.statSync(endpoint, { bigint: true }).ino;
+  removeMarker("failed");
+  setInterval(() => {
+    if (!fs.existsSync(keyPath) || !ownsEndpoint()) stop();
+  }, KEY_CHECK_MS).unref();
+  if (process.platform !== "win32") {
+    try {
+      fs.chmodSync(endpoint, 384);
+    } catch {
+    }
+  }
+  armIdle();
+}
+export {
+  runHookServer
+};