token-goat 2.9.28 → 2.9.30

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

@@ -0,0 +1,39 @@
+import { createRequire as __cjsRequire } from 'node:module';
+const require = __cjsRequire(import.meta.url);
+import {
+  DownloadCooldownError,
+  DownloadFailedError,
+  MODEL_DOWNLOAD_HOST,
+  RUNTIME_DOWNLOAD_HOST,
+  activeDownloadCooldown,
+  clearDownloadFailure,
+  describeCause,
+  downloadFailureRecordPath,
+  downloadHoldMs,
+  failedAtOf,
+  isExplicitDownload,
+  lastDownloadFailure,
+  recordDownloadFailure,
+  withExplicitDownload
+} from "./token-goat-chunk-SMVRN2HU.mjs";
+import "./token-goat-chunk-GOLEOXZP.mjs";
+import "./token-goat-chunk-AM5V6GSX.mjs";
+import "./token-goat-chunk-FNFBKLRD.mjs";
+import "./token-goat-chunk-VES7EL7O.mjs";
+import "./token-goat-chunk-A37V4PBF.mjs";
+export {
+  DownloadCooldownError,
+  DownloadFailedError,
+  MODEL_DOWNLOAD_HOST,
+  RUNTIME_DOWNLOAD_HOST,
+  activeDownloadCooldown,
+  clearDownloadFailure,
+  describeCause,
+  downloadFailureRecordPath,
+  downloadHoldMs,
+  failedAtOf,
+  isExplicitDownload,
+  lastDownloadFailure,
+  recordDownloadFailure,
+  withExplicitDownload
+};

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

@@ -0,0 +1,265 @@
+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-LOBGHXPB.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";
+import * as os from "node:os";
+var HANDSHAKE_TIMEOUT_MS = 150;
+var FIND_BUDGET_MS = 300;
+var HEDGE_MS = 40;
+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, race) {
+  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);
+    const cancel = () => {
+      if (!dispatched) finish({ kind: "busy" });
+    };
+    race?.onCancel(cancel);
+    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" });
+          if (race !== void 0 && !race.claim(cancel)) return finish({ kind: "busy" });
+          dispatched = true;
+          clearTimeout(timer);
+          if (request.kind !== "cli") 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 {
+    const child = spawn(process.execPath, [launcher, "hook-server", "run", "--slot", String(slot)], { cwd: os.tmpdir(), detached: true, stdio: "ignore", windowsHide: true });
+    child.on("error", () => void 0);
+    child.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;
+  const handshakeMs = opts.handshakeMs ?? HANDSHAKE_TIMEOUT_MS;
+  return new Promise((resolve) => {
+    let claimed = false;
+    let settled = false;
+    let exhausted = false;
+    let next = 0;
+    let pending = 0;
+    let hedge;
+    const cancels = [];
+    const settle = (value) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(hedge);
+      for (const cancel of cancels) cancel();
+      resolve(value);
+    };
+    const race = {
+      claim: (self) => {
+        if (claimed || settled) return false;
+        claimed = true;
+        clearTimeout(hedge);
+        for (const cancel of cancels) if (cancel !== self) cancel();
+        return true;
+      },
+      onCancel: (cancel) => cancels.push(cancel)
+    };
+    const askNext = () => {
+      clearTimeout(hedge);
+      if (settled || claimed || exhausted || next >= SERVER_SLOTS || Date.now() >= deadline) {
+        if (pending === 0 && !claimed) settle(void 0);
+        return;
+      }
+      const slot = next++;
+      pending++;
+      void attempt(slot, key, request, handshakeMs, void 0, race).then((outcome) => {
+        pending--;
+        if (outcome.kind === "served") return settle(outcome.reply);
+        if (outcome.kind === "lost") return settle("lost");
+        if (claimed) return;
+        if (outcome.kind === "stale" || outcome.kind === "oversize") return settle(void 0);
+        if (outcome.kind === "absent") {
+          if (autostart) startServer(slot);
+          exhausted = true;
+        }
+        askNext();
+      });
+      if (next < SERVER_SLOTS) hedge = setTimeout(askNext, HEDGE_MS);
+    };
+    askNext();
+  });
+}
+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",
+  "call-chain",
+  "callers",
+  "changed",
+  "context-for",
+  "dead",
+  "deps",
+  "exports",
+  "find",
+  "impact",
+  "imports",
+  "locate",
+  "map",
+  "outline",
+  "read",
+  "refs",
+  "scope",
+  "section",
+  "semantic",
+  "similar",
+  "skeleton",
+  "symbol",
+  "test-for",
+  "types"
+]);
+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
+};