@solongate/proxy 0.83.20 → 0.83.21

package/dist/cli-launch.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/cli-launch.js

@@ -0,0 +1,69 @@
+#!/usr/bin/env node
+
+// src/cli-launch.ts
+import { accessSync, constants, existsSync } from "fs";
+import { spawnSync } from "child_process";
+import { createRequire } from "module";
+import { homedir } from "os";
+import { dirname, join, resolve } from "path";
+var GO_SUBCOMMANDS = /* @__PURE__ */ new Set([
+  "update",
+  "repair",
+  "logs-server",
+  "local-logs",
+  "policy",
+  "ratelimit",
+  "dlp",
+  "stats",
+  "audit",
+  "sessions",
+  "session",
+  "doctor",
+  "watch",
+  "alerts",
+  "webhooks",
+  "dataroom"
+]);
+var GO_INFO_ARGS = /* @__PURE__ */ new Set(["login", "help", "--help", "-h", "--version", "-v", "version"]);
+var argv = process.argv.slice(2);
+var first = argv[0] ?? "";
+var delegable = argv.length === 0 || GO_SUBCOMMANDS.has(first) || GO_INFO_ARGS.has(first);
+function candidates() {
+  const out = [];
+  if (process.env.SOLONGATE_CLI_BIN) out.push(process.env.SOLONGATE_CLI_BIN);
+  const exe = process.platform === "win32" ? "solongate.exe" : "solongate";
+  const os_ = process.platform === "win32" ? "win32" : process.platform;
+  const cpu = process.arch === "x64" ? "x64" : process.arch;
+  try {
+    const req = createRequire(import.meta.url);
+    out.push(join(dirname(req.resolve(`@solongate/guard-${os_}-${cpu}/package.json`)), exe));
+  } catch {
+  }
+  out.push(resolve(homedir(), ".solongate", "bin", exe));
+  return out;
+}
+function runGo() {
+  for (const bin of candidates()) {
+    try {
+      if (!existsSync(bin)) continue;
+      if (process.platform !== "win32") accessSync(bin, constants.X_OK);
+    } catch {
+      continue;
+    }
+    const r = spawnSync(bin, argv, { stdio: "inherit" });
+    if (r.error || r.signal) return null;
+    if (r.status === 69) return null;
+    return r.status ?? 0;
+  }
+  return null;
+}
+if (delegable && process.env.SOLONGATE_NO_GO_CLI !== "1") {
+  let code = null;
+  try {
+    code = runGo();
+  } catch {
+    code = null;
+  }
+  if (code !== null) process.exit(code);
+}
+await import(new URL("./index.js", import.meta.url).href);

package/dist/commands/index.js

@@ -10,9 +10,10 @@ import { resolve as resolve2, join as join2 } from "path";
 import { homedir as homedir2 } from "os";
 
 // src/global-install.ts
-import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, rmdirSync, readdirSync, statSync, chmodSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, rmdirSync, readdirSync, statSync, chmodSync, copyFileSync, renameSync } from "fs";
 import { resolve, join, dirname } from "path";
 import { homedir } from "os";
+import { createRequire } from "module";
 import { fileURLToPath } from "url";
 import { createInterface } from "readline";
 import { execFileSync, spawn } from "child_process";
@@ -26,10 +27,12 @@ function globalPaths() {
   const antigravityDir = join(home, ".gemini", "config");
   const codexDir = process.env["CODEX_HOME"] ? resolve(process.env["CODEX_HOME"]) : join(home, ".codex");
   const opencodeDir = join(process.env["XDG_CONFIG_HOME"] ? resolve(process.env["XDG_CONFIG_HOME"]) : join(home, ".config"), "opencode");
+  const binDir = join(sgDir, "bin");
   return {
     home,
     sgDir,
     hooksDir,
+    binDir,
     claudeDir,
     antigravityDir,
     codexDir,

package/dist/core/policy.d.ts

@@ -305,12 +305,12 @@ export declare const PolicySetSchema: z.ZodObject<{
     createdAt: z.ZodString;
     updatedAt: z.ZodString;
 }, "strip", z.ZodTypeAny, {
+    version: number;
     name: string;
     id: string;
     description: string;
     createdAt: string;
     updatedAt: string;
-    version: number;
     rules: {
         id: string;
         description: string;
@@ -343,12 +343,12 @@ export declare const PolicySetSchema: z.ZodObject<{
         } | undefined;
     }[];
 }, {
+    version: number;
     name: string;
     id: string;
     description: string;
     createdAt: string;
     updatedAt: string;
-    version: number;
     rules: {
         id: string;
         description: string;

package/dist/global-install.d.ts

@@ -19,6 +19,7 @@ export declare function globalPaths(): {
     home: string;
     sgDir: string;
     hooksDir: string;
+    binDir: string;
     claudeDir: string;
     antigravityDir: string;
     codexDir: string;

package/dist/global-install.js

@@ -1,7 +1,8 @@
 // src/global-install.ts
-import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, rmdirSync, readdirSync, statSync, chmodSync } from "fs";
+import { readFileSync, writeFileSync, existsSync, mkdirSync, rmSync, rmdirSync, readdirSync, statSync, chmodSync, copyFileSync, renameSync } from "fs";
 import { resolve, join, dirname } from "path";
 import { homedir } from "os";
+import { createRequire } from "module";
 import { fileURLToPath } from "url";
 import { createInterface } from "readline";
 import { execFileSync, spawn } from "child_process";
@@ -126,10 +127,12 @@ function globalPaths() {
   const antigravityDir = join(home, ".gemini", "config");
   const codexDir = process.env["CODEX_HOME"] ? resolve(process.env["CODEX_HOME"]) : join(home, ".codex");
   const opencodeDir = join(process.env["XDG_CONFIG_HOME"] ? resolve(process.env["XDG_CONFIG_HOME"]) : join(home, ".config"), "opencode");
+  const binDir = join(sgDir, "bin");
   return {
     home,
     sgDir,
     hooksDir,
+    binDir,
     claudeDir,
     antigravityDir,
     codexDir,
@@ -183,6 +186,38 @@ function readGuard() {
   const bundled = join(HOOKS_DIR, "guard.bundled.mjs");
   return existsSync(bundled) ? readFileSync(bundled, "utf-8") : readHook("guard.mjs");
 }
+function installGoBinaries(binDir) {
+  const os_ = process.platform === "win32" ? "win32" : process.platform;
+  const cpu = process.arch === "x64" ? "x64" : process.arch;
+  const suffix = process.platform === "win32" ? ".exe" : "";
+  const placed = [];
+  let pkgDir;
+  try {
+    const require_ = createRequire(import.meta.url);
+    pkgDir = dirname(require_.resolve(`@solongate/guard-${os_}-${cpu}/package.json`));
+  } catch {
+    return placed;
+  }
+  try {
+    mkdirSync(binDir, { recursive: true });
+  } catch {
+    return placed;
+  }
+  for (const name of ["solongate-guard", "solongate"]) {
+    const from = join(pkgDir, name + suffix);
+    const to = join(binDir, name + suffix);
+    try {
+      if (!existsSync(from)) continue;
+      const tmp = to + ".new";
+      copyFileSync(from, tmp);
+      chmodSync(tmp, 493);
+      renameSync(tmp, to);
+      placed.push(name + suffix);
+    } catch {
+    }
+  }
+  return placed;
+}
 var ANTIGRAVITY_GROUP = "solongate-guard";
 function antigravityHookCommand(guardAbs) {
   const nodeBin = process.execPath.replace(/\\/g, "/");
@@ -576,6 +611,7 @@ function installGlobalQuiet() {
     mkdirSync(p.claudeDir, { recursive: true });
     unlockProtected();
     writeFileSync(join(p.hooksDir, "guard.mjs"), readGuard());
+    installGoBinaries(p.binDir);
     writeFileSync(join(p.hooksDir, "audit.mjs"), readHook("audit.mjs"));
     writeFileSync(join(p.hooksDir, "stop.mjs"), readHook("stop.mjs"));
     writeFileSync(join(p.hooksDir, "shield.mjs"), readHook("shield.mjs"));

package/dist/index.js

@@ -6214,9 +6214,10 @@ __export(global_install_exports, {
   unlockProtected: () => unlockProtected,
   writeProtectedFile: () => writeProtectedFile
 });
-import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync3, rmSync as rmSync2, rmdirSync, readdirSync, statSync, chmodSync } from "fs";
+import { readFileSync as readFileSync4, writeFileSync as writeFileSync3, existsSync as existsSync3, mkdirSync as mkdirSync3, rmSync as rmSync2, rmdirSync, readdirSync, statSync, chmodSync, copyFileSync, renameSync } from "fs";
 import { resolve as resolve3, join as join4, dirname } from "path";
 import { homedir as homedir2 } from "os";
+import { createRequire } from "module";
 import { fileURLToPath } from "url";
 import { createInterface } from "readline";
 import { execFileSync as execFileSync2, spawn } from "child_process";
@@ -6339,10 +6340,12 @@ function globalPaths() {
   const antigravityDir = join4(home, ".gemini", "config");
   const codexDir = process.env["CODEX_HOME"] ? resolve3(process.env["CODEX_HOME"]) : join4(home, ".codex");
   const opencodeDir = join4(process.env["XDG_CONFIG_HOME"] ? resolve3(process.env["XDG_CONFIG_HOME"]) : join4(home, ".config"), "opencode");
+  const binDir = join4(sgDir, "bin");
   return {
     home,
     sgDir,
     hooksDir,
+    binDir,
     claudeDir,
     antigravityDir,
     codexDir,
@@ -6396,6 +6399,38 @@ function readGuard() {
   const bundled = join4(HOOKS_DIR, "guard.bundled.mjs");
   return existsSync3(bundled) ? readFileSync4(bundled, "utf-8") : readHook("guard.mjs");
 }
+function installGoBinaries(binDir) {
+  const os_ = process.platform === "win32" ? "win32" : process.platform;
+  const cpu = process.arch === "x64" ? "x64" : process.arch;
+  const suffix = process.platform === "win32" ? ".exe" : "";
+  const placed = [];
+  let pkgDir;
+  try {
+    const require_ = createRequire(import.meta.url);
+    pkgDir = dirname(require_.resolve(`@solongate/guard-${os_}-${cpu}/package.json`));
+  } catch {
+    return placed;
+  }
+  try {
+    mkdirSync3(binDir, { recursive: true });
+  } catch {
+    return placed;
+  }
+  for (const name of ["solongate-guard", "solongate"]) {
+    const from = join4(pkgDir, name + suffix);
+    const to = join4(binDir, name + suffix);
+    try {
+      if (!existsSync3(from)) continue;
+      const tmp = to + ".new";
+      copyFileSync(from, tmp);
+      chmodSync(tmp, 493);
+      renameSync(tmp, to);
+      placed.push(name + suffix);
+    } catch {
+    }
+  }
+  return placed;
+}
 function antigravityHookCommand(guardAbs) {
   const nodeBin = process.execPath.replace(/\\/g, "/");
   const call = process.platform === "win32" ? "& " : "";
@@ -6785,6 +6820,7 @@ function installGlobalQuiet() {
     mkdirSync3(p.claudeDir, { recursive: true });
     unlockProtected();
     writeFileSync3(join4(p.hooksDir, "guard.mjs"), readGuard());
+    installGoBinaries(p.binDir);
     writeFileSync3(join4(p.hooksDir, "audit.mjs"), readHook("audit.mjs"));
     writeFileSync3(join4(p.hooksDir, "stop.mjs"), readHook("stop.mjs"));
     writeFileSync3(join4(p.hooksDir, "shield.mjs"), readHook("shield.mjs"));

package/dist/tui/index.js

@@ -9,9 +9,10 @@ var __export = (target, all) => {
 };
 
 // src/global-install.ts
-import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync, rmSync, rmdirSync, readdirSync as readdirSync2, statSync as statSync2, chmodSync } from "fs";
+import { readFileSync as readFileSync3, writeFileSync as writeFileSync2, existsSync as existsSync2, mkdirSync, rmSync, rmdirSync, readdirSync as readdirSync2, statSync as statSync2, chmodSync, copyFileSync, renameSync } from "fs";
 import { resolve, join as join3, dirname } from "path";
 import { homedir as homedir3 } from "os";
+import { createRequire } from "module";
 import { fileURLToPath } from "url";
 import { createInterface } from "readline";
 import { execFileSync, spawn } from "child_process";
@@ -134,10 +135,12 @@ function globalPaths() {
   const antigravityDir = join3(home, ".gemini", "config");
   const codexDir = process.env["CODEX_HOME"] ? resolve(process.env["CODEX_HOME"]) : join3(home, ".codex");
   const opencodeDir = join3(process.env["XDG_CONFIG_HOME"] ? resolve(process.env["XDG_CONFIG_HOME"]) : join3(home, ".config"), "opencode");
+  const binDir = join3(sgDir, "bin");
   return {
     home,
     sgDir,
     hooksDir,
+    binDir,
     claudeDir,
     antigravityDir,
     codexDir,
@@ -183,6 +186,38 @@ function readGuard() {
   const bundled = join3(HOOKS_DIR, "guard.bundled.mjs");
   return existsSync2(bundled) ? readFileSync3(bundled, "utf-8") : readHook("guard.mjs");
 }
+function installGoBinaries(binDir) {
+  const os_ = process.platform === "win32" ? "win32" : process.platform;
+  const cpu = process.arch === "x64" ? "x64" : process.arch;
+  const suffix = process.platform === "win32" ? ".exe" : "";
+  const placed = [];
+  let pkgDir;
+  try {
+    const require_ = createRequire(import.meta.url);
+    pkgDir = dirname(require_.resolve(`@solongate/guard-${os_}-${cpu}/package.json`));
+  } catch {
+    return placed;
+  }
+  try {
+    mkdirSync(binDir, { recursive: true });
+  } catch {
+    return placed;
+  }
+  for (const name of ["solongate-guard", "solongate"]) {
+    const from = join3(pkgDir, name + suffix);
+    const to = join3(binDir, name + suffix);
+    try {
+      if (!existsSync2(from)) continue;
+      const tmp = to + ".new";
+      copyFileSync(from, tmp);
+      chmodSync(tmp, 493);
+      renameSync(tmp, to);
+      placed.push(name + suffix);
+    } catch {
+    }
+  }
+  return placed;
+}
 function antigravityHookCommand(guardAbs) {
   const nodeBin = process.execPath.replace(/\\/g, "/");
   const call = process.platform === "win32" ? "& " : "";
@@ -502,6 +537,7 @@ function installGlobalQuiet() {
     mkdirSync(p.claudeDir, { recursive: true });
     unlockProtected();
     writeFileSync2(join3(p.hooksDir, "guard.mjs"), readGuard());
+    installGoBinaries(p.binDir);
     writeFileSync2(join3(p.hooksDir, "audit.mjs"), readHook("audit.mjs"));
     writeFileSync2(join3(p.hooksDir, "stop.mjs"), readHook("stop.mjs"));
     writeFileSync2(join3(p.hooksDir, "shield.mjs"), readHook("shield.mjs"));

package/hooks/guard.bundled.mjs

@@ -6530,10 +6530,11 @@ var init_src = __esm({
 });
 
 // hooks/guard.mjs
-import { readFileSync, existsSync, statSync, readdirSync, writeFileSync, mkdirSync, chmodSync, renameSync, appendFileSync, rmSync, rmdirSync, openSync, readSync, closeSync } from "node:fs";
-import { spawn } from "node:child_process";
+import { readFileSync, existsSync, statSync, readdirSync, writeFileSync, mkdirSync, chmodSync, renameSync, appendFileSync, rmSync, rmdirSync, openSync, readSync, closeSync, accessSync, constants } from "node:fs";
+import { spawn, spawnSync } from "node:child_process";
 import { resolve, join, dirname, isAbsolute } from "node:path";
 import { homedir } from "node:os";
+import { createRequire } from "node:module";
 import { gunzipSync } from "node:zlib";
 import { createHash } from "node:crypto";
 function projectKey(dir) {
@@ -6579,6 +6580,87 @@ function sweepLegacyFlagDir() {
   }
 }
 var HOOK_VERSION = 80;
+var SG_REFRESH_ARG = process.argv.includes("--sg-refresh-policy");
+var SG_STDIN = SG_REFRESH_ARG ? "" : (() => {
+  try {
+    return readFileSync(0, "utf-8");
+  } catch {
+    return "";
+  }
+})();
+function sgGuardCandidates() {
+  const out = [];
+  if (process.env.SOLONGATE_GUARD_BIN)
+    out.push(process.env.SOLONGATE_GUARD_BIN);
+  const exe = process.platform === "win32" ? "solongate-guard.exe" : "solongate-guard";
+  const os_ = process.platform === "win32" ? "win32" : process.platform;
+  const cpu = process.arch === "x64" ? "x64" : process.arch;
+  try {
+    const req = createRequire(import.meta.url);
+    out.push(join(dirname(req.resolve(`@solongate/guard-${os_}-${cpu}/package.json`)), exe));
+  } catch {
+  }
+  out.push(resolve(homedir(), ".solongate", "bin", exe));
+  return out;
+}
+function sgTryGoGuard() {
+  for (const bin of sgGuardCandidates()) {
+    try {
+      if (!existsSync(bin))
+        continue;
+      if (process.platform !== "win32")
+        accessSync(bin, constants.X_OK);
+    } catch {
+      continue;
+    }
+    let version;
+    try {
+      const v = spawnSync(bin, ["--sg-version"], { encoding: "utf-8", timeout: 2e3 });
+      if (v.error || v.status !== 0)
+        continue;
+      version = String(v.stdout || "").trim();
+    } catch {
+      continue;
+    }
+    if (version !== String(HOOK_VERSION))
+      continue;
+    let r;
+    try {
+      r = spawnSync(bin, process.argv.slice(2), {
+        input: SG_STDIN,
+        encoding: "utf-8",
+        // Well past every network call the guard makes. A binary still running
+        // at this point is not going to produce an answer worth waiting for.
+        timeout: 1e4
+      });
+    } catch {
+      return;
+    }
+    if (!r || r.error || r.signal)
+      return;
+    const status = r.status;
+    const stdout = r.stdout || "";
+    if (status !== 0 && status !== 2)
+      return;
+    if (status === 2 && stdout.trim() === "")
+      return;
+    try {
+      if (stdout)
+        process.stdout.write(stdout);
+      if (r.stderr)
+        process.stderr.write(r.stderr);
+    } catch {
+      return;
+    }
+    process.exit(status);
+  }
+}
+if (!SG_REFRESH_ARG && process.env.SOLONGATE_NO_GO_GUARD !== "1") {
+  try {
+    sgTryGoGuard();
+  } catch {
+  }
+}
 function localLogsOnly(security) {
   if (security !== void 0) {
     const l = security && security.localLogs;
@@ -8451,10 +8533,7 @@ function readReferencedFiles(args, cwd) {
   return out;
 }
 if (!REFRESH_MODE) {
-  try {
-    input += readFileSync(0, "utf-8");
-  } catch {
-  }
+  input += SG_STDIN;
 }
 (async () => {
   try {

package/hooks/guard.mjs

@@ -21,10 +21,11 @@
  * Logs DENY decisions to SolonGate Cloud. ALLOWs are logged by audit.mjs.
  * Auto-installed by: npx @solongate/proxy init --global
  */
-import { readFileSync, existsSync, statSync, readdirSync, writeFileSync, mkdirSync, chmodSync, renameSync, appendFileSync, rmSync, rmdirSync, openSync, readSync, closeSync } from 'node:fs';
-import { spawn } from 'node:child_process';
+import { readFileSync, existsSync, statSync, readdirSync, writeFileSync, mkdirSync, chmodSync, renameSync, appendFileSync, rmSync, rmdirSync, openSync, readSync, closeSync, accessSync, constants } from 'node:fs';
+import { spawn, spawnSync } from 'node:child_process';
 import { resolve, join, dirname, isAbsolute } from 'node:path';
 import { homedir } from 'node:os';
+import { createRequire } from 'node:module';
 import { gunzipSync } from 'node:zlib';
 
 // ── Per-project scratch, kept OUT of the project ─────────────────────────────
@@ -83,6 +84,135 @@ import { createHash } from 'node:crypto';
 // reinstall — the same trust model as the OPA WASM this hook already runs.
 const HOOK_VERSION = 80;
 
+// ── The Go guard, when there is one and it is the right one ──────────────────
+//
+// Everything below this block is the Node decision engine. It stays, it stays
+// correct, and it stays the thing that runs whenever the fast path cannot be
+// trusted. THE RULE: a missing, stale, unreadable or crashing binary must mean
+// SLOW BUT GUARDED, never FAST BUT UNGUARDED. Every failure here falls through.
+//
+// Three things this gets right that a naive `exec the binary` would not:
+//
+// 1. STDIN IS READ HERE, ONCE, BEFORE THE BINARY RUNS. Handing the child fd 0
+//    directly would be faster to write and impossible to recover from: a binary
+//    that dies after consuming the payload leaves Node with nothing to fall back
+//    WITH, so it would evaluate an empty call and allow it. The payload is a few
+//    KB and the read is synchronous; the safety is worth more than the copy.
+//
+// 2. EXIT 2 IS AMBIGUOUS. It is this hook's block signal AND the code the Go
+//    runtime uses for an unhandled panic. A block always writes a decision to
+//    stdout first; a panic writes a stack trace to stderr and nothing to stdout.
+//    So exit 2 is honoured only with output to show for it, and a panic falls
+//    through to Node — which will reach its own verdict on the same payload.
+//
+// 3. THE VERSION MUST MATCH EXACTLY, not merely exist. This hook self-updates
+//    from the cloud on its own schedule while the binary only moves when npm
+//    moves it, so a machine can hold a hook from this week and a binary from
+//    last month. HOOK_VERSION bumps on every change to this file, and the binary
+//    prints the HOOK_VERSION it implements. Different numbers mean different
+//    decisions, and a binary that is merely OLD is not a smaller problem than
+//    one that is missing.
+//
+// SOLONGATE_NO_GO_GUARD=1 pins execution to Node. It exists so a failure can be
+// bisected without uninstalling anything.
+
+// The refresh invocation has no tool call on stdin — it is spawned detached and
+// its stdin may be a pipe nobody ever closes, so reading it would hang the hook
+// forever. It also has nothing for the binary to decide. Both paths skip it.
+const SG_REFRESH_ARG = process.argv.includes('--sg-refresh-policy');
+
+// The one read of fd 0 in this process. Everything downstream uses this string.
+const SG_STDIN = SG_REFRESH_ARG ? '' : (() => {
+  try { return readFileSync(0, 'utf-8'); } catch { return ''; }
+})();
+
+// Where a binary may legitimately live, in the order they are trusted.
+//
+// The env override is first so a build can be pointed at without reinstalling.
+// The platform package is the normal path for a project-local install. The copy
+// under ~/.solongate/bin is what a GLOBAL install has: the hook is written to
+// ~/.solongate/hooks as a lone file and launched from arbitrary working
+// directories, where resolving through node_modules finds nothing.
+function sgGuardCandidates() {
+  const out = [];
+  if (process.env.SOLONGATE_GUARD_BIN) out.push(process.env.SOLONGATE_GUARD_BIN);
+  const exe = process.platform === 'win32' ? 'solongate-guard.exe' : 'solongate-guard';
+  const os_ = process.platform === 'win32' ? 'win32' : process.platform;
+  const cpu = process.arch === 'x64' ? 'x64' : process.arch;
+  try {
+    // The manifest, not a main entry: these packages contain a binary and
+    // nothing else, so there is no JavaScript in them to resolve.
+    //
+    // createRequire rather than import.meta.resolve: the latter is not a sync
+    // function on every Node 18 this package supports, and a hook is not the
+    // place to find that out. node:module is a builtin, so importing it cannot
+    // fail the way a real dependency could.
+    const req = createRequire(import.meta.url);
+    out.push(join(dirname(req.resolve(`@solongate/guard-${os_}-${cpu}/package.json`)), exe));
+  } catch {
+    // Not installed for this platform, which is what optionalDependencies does
+    // on a host with no published binary, and is not an error.
+  }
+  out.push(resolve(homedir(), '.solongate', 'bin', exe));
+  return out;
+}
+
+// Hand the whole call to the binary. Returns only when Node must decide instead.
+function sgTryGoGuard() {
+  for (const bin of sgGuardCandidates()) {
+    try {
+      if (!existsSync(bin)) continue;
+      if (process.platform !== 'win32') accessSync(bin, constants.X_OK);
+    } catch { continue; }
+
+    // Ask what it is. Bounded, because this runs before anything has decided the
+    // binary can be trusted and it must not be able to hang what it speeds up.
+    let version;
+    try {
+      const v = spawnSync(bin, ['--sg-version'], { encoding: 'utf-8', timeout: 2000 });
+      if (v.error || v.status !== 0) continue;
+      version = String(v.stdout || '').trim();
+    } catch { continue; }
+    if (version !== String(HOOK_VERSION)) continue;
+
+    let r;
+    try {
+      r = spawnSync(bin, process.argv.slice(2), {
+        input: SG_STDIN,
+        encoding: 'utf-8',
+        // Well past every network call the guard makes. A binary still running
+        // at this point is not going to produce an answer worth waiting for.
+        timeout: 10000,
+      });
+    } catch { return; }
+
+    // Killed, timed out, or never started: Node decides.
+    if (!r || r.error || r.signal) return;
+    const status = r.status;
+    const stdout = r.stdout || '';
+    if (status !== 0 && status !== 2) return;
+    // See (2) above: a block without a decision to show is a crash wearing a
+    // block's exit code.
+    if (status === 2 && stdout.trim() === '') return;
+
+    try {
+      if (stdout) process.stdout.write(stdout);
+      if (r.stderr) process.stderr.write(r.stderr);
+    } catch {
+      // Writing the answer is the whole job. If it could not be delivered, Node
+      // has not written anything either, so it can still do the work.
+      return;
+    }
+    process.exit(status);
+  }
+}
+
+if (!SG_REFRESH_ARG && process.env.SOLONGATE_NO_GO_GUARD !== '1') {
+  // A throw anywhere in here is a bug in the fast path, and a bug in the fast
+  // path must not become an unguarded tool call.
+  try { sgTryGoGuard(); } catch {}
+}
+
 // True when local log storage is ON. In that mode logs are kept LOCAL ONLY and
 // nothing is sent to the cloud audit log — local and cloud are one or the
 // other, never both.
@@ -2455,15 +2585,21 @@ function readReferencedFiles(args, cwd) {
   return out;
 }
 
-// Read stdin SYNCHRONOUSLY (fd 0) instead of via the process.stdin stream. On
-// Windows + Node 24, calling process.exit() from inside the stdin stream's 'end'
-// callback aborts with `Assertion failed: !(handle->flags & UV_HANDLE_CLOSING),
-// file src\win\async.c` — libuv double-closes the stdin pipe handle mid-teardown,
-// the hook crashes before its exit code lands, and Claude Code treats the DENY as
-// a non-blocking hook failure (so the block never applies). Reading fd 0 to EOF
-// synchronously never creates that pipe handle, and the exit below no longer runs
-// inside a stream callback, so the loop tears down cleanly.
-if (!REFRESH_MODE) { try { input += readFileSync(0, 'utf-8'); } catch {} }
+// The payload was read at the top of this file, synchronously from fd 0, before
+// the Go guard was offered the call — see SG_STDIN. It is reused rather than
+// re-read for two reasons: fd 0 is already at EOF so a second read would return
+// nothing, and the fallback only means anything if Node still holds what the
+// binary was given.
+//
+// Reading fd 0 synchronously rather than through the process.stdin stream is
+// itself deliberate. On Windows + Node 24, calling process.exit() from inside the
+// stdin stream's 'end' callback aborts with `Assertion failed: !(handle->flags &
+// UV_HANDLE_CLOSING), file src\win\async.c` — libuv double-closes the stdin pipe
+// handle mid-teardown, the hook crashes before its exit code lands, and Claude
+// Code treats the DENY as a non-blocking hook failure (so the block never
+// applies). Reading fd 0 to EOF never creates that pipe handle, and the exit
+// below no longer runs inside a stream callback, so the loop tears down cleanly.
+if (!REFRESH_MODE) { input += SG_STDIN; }
 ;(async () => {
  // Safety backstop ONLY: the normal path exits by natural drain (~1ms after work
  // finishes). If the loop somehow fails to drain, force-exit — 8s is well past every

package/package.json

@@ -1,13 +1,13 @@
 {
   "name": "@solongate/proxy",
-  "version": "0.83.20",
+  "version": "0.83.21",
   "description": "AI tool security proxy: protect any AI tool server with customizable policies, path/command constraints, rate limiting, and audit logging. No code changes required.",
   "type": "module",
   "bin": {
-    "solongate": "./dist/index.js",
-    "solongate-proxy": "./dist/index.js",
-    "solongate-audit": "./dist/audit/index.js",
-    "proxy": "./dist/index.js"
+    "solongate": "./dist/cli-launch.js",
+    "solongate-proxy": "./dist/cli-launch.js",
+    "proxy": "./dist/cli-launch.js",
+    "solongate-audit": "./dist/audit/index.js"
   },
   "main": "./dist/lib.js",
   "types": "./dist/lib.d.ts",
@@ -32,7 +32,9 @@
     "build:hooks": "node scripts/bundle-hooks.mjs",
     "dev": "tsx src/index.ts",
     "typecheck": "tsc --noEmit",
-    "clean": "rm -rf dist .turbo"
+    "clean": "rm -rf dist .turbo platforms",
+    "test": "node test/run-all.mjs",
+    "build:go": "node scripts/build-go-binaries.mjs"
   },
   "keywords": [
     "ai-tool-security",
@@ -58,6 +60,14 @@
   "engines": {
     "node": ">=20.0.0"
   },
+  "optionalDependencies": {
+    "@solongate/guard-linux-x64": "0.83.21",
+    "@solongate/guard-linux-arm64": "0.83.21",
+    "@solongate/guard-darwin-x64": "0.83.21",
+    "@solongate/guard-darwin-arm64": "0.83.21",
+    "@solongate/guard-win32-x64": "0.83.21",
+    "@solongate/guard-win32-arm64": "0.83.21"
+  },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.26.0",
     "ink": "^5.0.1",