token-goat 2.9.26 → 2.9.29

package/dist/{token-goat-chunk-L45IWWMC.mjs → token-goat-chunk-RLP6J7WR.mjs}

@@ -2,26 +2,26 @@ import { createRequire as __cjsRequire } from 'node:module';
 const require = __cjsRequire(import.meta.url);
 import {
   renderWebFetchRow
-} from "./token-goat-chunk-MDV5VWF4.mjs";
+} from "./token-goat-chunk-G7IWXCFF.mjs";
 import {
   SESSIONS_SUBDIR,
   extractChecklistSection,
   getSkillFilePath,
   listSkills
-} from "./token-goat-chunk-M6CVNHTW.mjs";
+} from "./token-goat-chunk-H5J3C56Q.mjs";
 import {
   getBashOutput
-} from "./token-goat-chunk-43JFN26X.mjs";
+} from "./token-goat-chunk-O6I2XU4P.mjs";
 import {
   loadBlob
-} from "./token-goat-chunk-D2X7XN5M.mjs";
+} from "./token-goat-chunk-D4ETHJD6.mjs";
 import {
   resolveProjectRoot
-} from "./token-goat-chunk-LRIZ7K3F.mjs";
+} from "./token-goat-chunk-TGOXNAHW.mjs";
 import {
   runGit,
   safeSlice
-} from "./token-goat-chunk-6E2IDLHF.mjs";
+} from "./token-goat-chunk-XYWPOSCN.mjs";
 import {
   displaySafePath,
   displaySafeText,

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

@@ -0,0 +1,205 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  PROTOCOL_VERSION,
+  SERVER_SLOTS,
+  configStamp,
+  encodeFrame,
+  endpointFor,
+  envSnapshot,
+  frameFits,
+  launcherPath,
+  mac,
+  macMatches,
+  markerAgeMs,
+  nonce,
+  readFrames,
+  readMarker,
+  readServerKey,
+  touchMarker,
+  writeFrame
+} from "./token-goat-chunk-DPNLUJWB.mjs";
+import {
+  envBool
+} from "./token-goat-chunk-IVE6U7KV.mjs";
+import {
+  init_define_import_meta_env
+} from "./token-goat-chunk-A37V4PBF.mjs";
+
+// src/hook_client.ts
+init_define_import_meta_env();
+import { spawn } from "node:child_process";
+import * as fs from "node:fs";
+import * as net from "node:net";
+var HANDSHAKE_TIMEOUT_MS = 150;
+var FIND_BUDGET_MS = 300;
+var RESPONSE_TIMEOUT_MS = 12e4;
+var CONTROL_WAIT_MS = 1e4;
+var SPAWN_RETRY_MS = 3e4;
+var DISABLED_MARKER_TTL_MS = 10 * 6e4;
+function attempt(slot, key, request, handshakeMs, dir) {
+  return new Promise((resolve) => {
+    const socket = net.connect(endpointFor(slot, dir));
+    const nc = nonce();
+    let dispatched = false;
+    let settled = false;
+    const finish = (outcome) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.destroy();
+      resolve(outcome);
+    };
+    let timer = setTimeout(() => finish({ kind: "busy" }), handshakeMs);
+    socket.on("error", (e) => {
+      if (dispatched) finish({ kind: "lost" });
+      else finish({ kind: e.code === "ENOENT" || e.code === "ECONNREFUSED" ? "absent" : "refused" });
+    });
+    socket.on("close", () => finish({ kind: dispatched ? "lost" : "refused" }));
+    const control = request.kind === "status" || request.kind === "stop";
+    socket.on("connect", () => writeFrame(socket, { t: "hello", v: PROTOCOL_VERSION, nc, ...control ? { ctl: true } : {} }));
+    let ns = "";
+    readFrames(
+      socket,
+      (msg) => {
+        if (msg["t"] === "busy") return finish({ kind: "busy" });
+        if (msg["t"] === "stale") return finish({ kind: "stale" });
+        if (msg["t"] === "challenge" && !dispatched) {
+          ns = typeof msg["ns"] === "string" ? msg["ns"] : "";
+          if (ns === "" || msg["v"] !== PROTOCOL_VERSION || !macMatches(mac(key, "S", nc, ns), msg["mac"])) return finish({ kind: "refused" });
+          const body = JSON.stringify(request);
+          const frame = encodeFrame({ t: "req", mac: mac(key, "C", nc, ns, body), body });
+          if (!frameFits(frame)) return finish({ kind: "oversize" });
+          dispatched = true;
+          clearTimeout(timer);
+          timer = setTimeout(() => finish({ kind: "lost" }), RESPONSE_TIMEOUT_MS);
+          socket.write(frame);
+          return;
+        }
+        if (msg["t"] === "res" && dispatched) {
+          const body = msg["body"];
+          if (typeof body !== "string" || !macMatches(mac(key, "R", nc, ns, body), msg["mac"])) return finish({ kind: "lost" });
+          try {
+            return finish({ kind: "served", reply: JSON.parse(body) });
+          } catch {
+            return finish({ kind: "lost" });
+          }
+        }
+        finish({ kind: dispatched ? "lost" : "refused" });
+      },
+      () => finish({ kind: dispatched ? "lost" : "refused" })
+    );
+  });
+}
+function startServer(slot) {
+  const launcher = launcherPath();
+  const disabled = markerAgeMs("disabled") < DISABLED_MARKER_TTL_MS && readMarker("disabled") === configStamp();
+  if (disabled || markerAgeMs(`spawn-${slot}`) < SPAWN_RETRY_MS || !fs.existsSync(launcher)) return;
+  touchMarker(`spawn-${slot}`);
+  try {
+    spawn(process.execPath, [launcher, "hook-server", "run", "--slot", String(slot)], { detached: true, stdio: "ignore", windowsHide: true }).unref();
+  } catch {
+  }
+}
+function serverEnabled() {
+  return envBool("TOKEN_GOAT_HOOK_SERVER", true);
+}
+async function callServer(request, opts = {}) {
+  if (!serverEnabled()) return void 0;
+  const autostart = opts.autostart !== false;
+  const key = readServerKey();
+  if (key === void 0) {
+    if (autostart) startServer(0);
+    return void 0;
+  }
+  const deadline = Date.now() + FIND_BUDGET_MS;
+  for (let slot = 0; slot < SERVER_SLOTS && Date.now() < deadline; slot++) {
+    const outcome = await attempt(slot, key, request, opts.handshakeMs ?? HANDSHAKE_TIMEOUT_MS);
+    if (outcome.kind === "served") return outcome.reply;
+    if (outcome.kind === "lost") return "lost";
+    if (outcome.kind === "absent") {
+      if (autostart) startServer(slot);
+      return void 0;
+    }
+    if (outcome.kind === "stale" || outcome.kind === "oversize") return void 0;
+  }
+  return void 0;
+}
+async function relayViaServer(event, input, harnessWaitMs) {
+  try {
+    const request = {
+      kind: "hook",
+      event,
+      input: typeof input === "string" ? input : JSON.stringify(input),
+      elapsedMs: performance.now(),
+      env: envSnapshot(),
+      cwd: process.cwd()
+    };
+    if (harnessWaitMs !== void 0) request.harnessWaitMs = harnessWaitMs;
+    const reply = await callServer(request);
+    if (reply === void 0) return void 0;
+    if (reply === "lost" || !reply.ok || !("stdout" in reply)) return "{}";
+    return reply.stdout;
+  } catch {
+    return void 0;
+  }
+}
+var WARM_CLI_COMMANDS = /* @__PURE__ */ new Set([
+  "answer",
+  "brief",
+  "changed",
+  "exports",
+  "imports",
+  "map",
+  "outline",
+  "read",
+  "refs",
+  "section",
+  "semantic",
+  "skeleton",
+  "symbol"
+]);
+function warmCliEligible(argv) {
+  const command = argv[2];
+  if (command === void 0 || !WARM_CLI_COMMANDS.has(command) || process.stdout.isTTY === true) return false;
+  return !argv.slice(3).some((a) => a === "-" || a === "--stdin" || a === "--help" || a === "-h");
+}
+async function runCliViaServer(argv) {
+  if (!warmCliEligible(argv)) return false;
+  try {
+    const reply = await callServer({ kind: "cli", argv: argv.slice(2), env: envSnapshot(), cwd: process.cwd() });
+    if (reply === void 0 || reply === "lost" || !reply.ok || !("stdout" in reply)) return false;
+    if (reply.stdout !== "") process.stdout.write(reply.stdout);
+    if (reply.stderr !== void 0 && reply.stderr !== "") process.stderr.write(reply.stderr);
+    process.exitCode = reply.status ?? 0;
+    return true;
+  } catch {
+    return false;
+  }
+}
+async function serverStatuses(dir) {
+  return (await queryServers("status", dir)).flatMap(({ reply }) => reply.ok && "info" in reply ? [reply.info] : []);
+}
+async function queryServers(kind, dir) {
+  const key = readServerKey(dir);
+  if (key === void 0) return [];
+  const deadline = Date.now() + CONTROL_WAIT_MS;
+  const answered = [];
+  for (let slot = 0; slot < SERVER_SLOTS; slot++) {
+    let outcome = await attempt(slot, key, { kind }, 2e3, dir);
+    while (outcome.kind === "busy" && Date.now() < deadline) outcome = await attempt(slot, key, { kind }, 2e3, dir);
+    if (outcome.kind === "served") answered.push({ slot, reply: outcome.reply });
+  }
+  return answered;
+}
+
+export {
+  serverEnabled,
+  callServer,
+  relayViaServer,
+  WARM_CLI_COMMANDS,
+  warmCliEligible,
+  runCliViaServer,
+  serverStatuses,
+  queryServers
+};