@mcpjam/inspector 3.3.4 → 3.3.6

package/dist/server/chunk-7TOT3ZWN.js

@@ -0,0 +1,1902 @@
+// server/utils/logger.ts
+import * as Sentry from "@sentry/node";
+import { Axiom } from "@axiomhq/js";
+
+// server/utils/log-events.ts
+var warnedMissingEnv = false;
+var ALLOWED_ENVIRONMENTS = [
+  "prod",
+  "staging",
+  "preview",
+  "dev",
+  "local",
+  "test"
+];
+function resolveEnvironment() {
+  const fromEnv = process.env.ENVIRONMENT;
+  if (fromEnv && ALLOWED_ENVIRONMENTS.includes(fromEnv)) {
+    return fromEnv;
+  }
+  if (process.env.NODE_ENV === "test") return "test";
+  if (process.env.NODE_ENV === "production") {
+    if (!warnedMissingEnv) {
+      warnedMissingEnv = true;
+      process.stderr.write(
+        "[logging] ENVIRONMENT not set in production; defaulting to 'prod'\n"
+      );
+    }
+    return "prod";
+  }
+  return "dev";
+}
+var BAKED_VERSION = "3.3.6";
+function blankToNull(value) {
+  return value === void 0 || value.trim() === "" ? null : value;
+}
+function resolveAppVersion() {
+  return blankToNull(BAKED_VERSION) ?? blankToNull(process.env.npm_package_version);
+}
+function resolveRelease() {
+  return blankToNull(process.env.RAILWAY_GIT_COMMIT_SHA) ?? blankToNull(process.env.GIT_SHA) ?? resolveAppVersion();
+}
+
+// server/utils/log-scrubber.ts
+var FORBIDDEN_KEY_SUBSTRINGS = [
+  "authorization",
+  "cookie",
+  "password",
+  "token",
+  "secret",
+  "apikey",
+  "pkceverifier",
+  "pkcechallenge",
+  "stripecustomer",
+  "stripesubscription",
+  "stripeprice",
+  "x-mcp-session-auth",
+  "x-api-key",
+  // Header-broker model lease (E2B network-transform delivery). A signed model
+  // lease — never log it, even though the inspector never handles it directly
+  // (defense in depth).
+  "x-mcpjam-harness-lease"
+];
+var ALLOWLISTED_KEYS = /* @__PURE__ */ new Set(["emaildomain"]);
+var AUTH_HEADER_LIKE = /\b(authorization["']?\s*:\s*)["']?[^\n\r"'`]+/gi;
+var TOKEN_LIKE = /\bBearer\s+[A-Za-z0-9._\-+/=]+\b/gi;
+var EMAIL_LIKE = /\b[A-Z0-9._%+-]+@[A-Z0-9.-]+\.[A-Z]{2,}\b/gi;
+var SK_KEY_LIKE = /\bsk-[A-Za-z0-9]{16,}\b/g;
+var JWT_LIKE = /\beyJ[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\.[A-Za-z0-9_-]{10,}\b/g;
+var SECRET_PARAM_LIKE = /\b((?:api[_-]?key|apikey|access[_-]?token|refresh[_-]?token|id[_-]?token|client[_-]?secret|authorization|secret|password|passwd|pwd|token|auth|key|sig|signature)\s*[=:]\s*["']?)[^&\s"'`]+/gi;
+var URL_BASIC_AUTH_LIKE = /(\/\/[^\s/:@]+:)[^\s@/]+@/g;
+function isForbiddenKey(key) {
+  const lower = key.toLowerCase();
+  if (ALLOWLISTED_KEYS.has(lower)) return false;
+  if (lower === "email" || lower.endsWith("email")) return true;
+  return FORBIDDEN_KEY_SUBSTRINGS.some((s) => lower.includes(s));
+}
+function scrubString(s) {
+  return s.replace(AUTH_HEADER_LIKE, "$1[redacted]").replace(TOKEN_LIKE, "Bearer [redacted-token]").replace(JWT_LIKE, "[redacted-jwt]").replace(URL_BASIC_AUTH_LIKE, "$1[redacted]@").replace(EMAIL_LIKE, "[redacted-email]").replace(SK_KEY_LIKE, "[redacted-secret]").replace(SECRET_PARAM_LIKE, "$1[redacted]");
+}
+function scrubLogPayload(value) {
+  return scrubValue(value, /* @__PURE__ */ new WeakSet());
+}
+function scrubValue(value, seen) {
+  if (value === null || value === void 0) return value;
+  if (typeof value === "string") return scrubString(value);
+  if (typeof value !== "object") return value;
+  if (value instanceof Date) return value.toISOString();
+  if (value instanceof Error) {
+    return {
+      name: value.name,
+      message: scrubString(value.message),
+      stack: value.stack ? scrubString(value.stack) : void 0
+    };
+  }
+  if (typeof Buffer !== "undefined" && Buffer.isBuffer(value)) {
+    return "[buffer]";
+  }
+  if (seen.has(value)) return "[circular]";
+  seen.add(value);
+  if (Array.isArray(value)) return value.map((v) => scrubValue(v, seen));
+  const out = {};
+  for (const [k, v] of Object.entries(value)) {
+    if (isForbiddenKey(k)) {
+      out[k] = "[redacted]";
+      continue;
+    }
+    out[k] = scrubValue(v, seen);
+  }
+  return out;
+}
+
+// server/utils/error-capture-stamp.ts
+var CAPTURE_STAMP = Symbol.for("mcpjam.errorOriginCaptureHandled");
+function isStampable(value) {
+  return typeof value === "object" && value !== null;
+}
+function safeErrorMessage(value) {
+  try {
+    return value instanceof Error ? value.message : String(value);
+  } catch {
+    return "[unreadable error value]";
+  }
+}
+function markOriginCaptureHandled(value) {
+  if (!isStampable(value)) return;
+  try {
+    Object.defineProperty(value, CAPTURE_STAMP, {
+      value: true,
+      enumerable: false,
+      configurable: true,
+      writable: true
+    });
+  } catch {
+  }
+}
+function ensureStampable(value) {
+  if (!isStampable(value)) return new Error(String(value));
+  let extensible;
+  try {
+    extensible = Object.isExtensible(value);
+  } catch {
+    extensible = false;
+  }
+  if (!extensible) {
+    const wrapped = new Error(
+      safeErrorMessage(value)
+    );
+    Object.defineProperty(wrapped, "cause", {
+      value,
+      enumerable: false,
+      configurable: true,
+      writable: true
+    });
+    return wrapped;
+  }
+  return value;
+}
+var MAX_CAUSE_DEPTH = 8;
+function isOriginCaptureHandled(error) {
+  const seen = /* @__PURE__ */ new Set();
+  let current = error;
+  for (let depth = 0; depth < MAX_CAUSE_DEPTH; depth += 1) {
+    if (!isStampable(current) || seen.has(current)) return false;
+    seen.add(current);
+    try {
+      if (current[CAPTURE_STAMP] === true) return true;
+      const normalized = current.normalized;
+      if (isStampable(normalized) && normalized[CAPTURE_STAMP] === true) {
+        return true;
+      }
+      current = current.cause;
+    } catch {
+      return false;
+    }
+  }
+  return false;
+}
+
+// server/utils/logger.ts
+var isVerbose = () => process.env.VERBOSE_LOGS === "true";
+var isDev = () => process.env.NODE_ENV !== "production";
+var shouldLog = () => isVerbose() || isDev();
+function isTrackingDisabled() {
+  const dnt = process.env.DO_NOT_TRACK;
+  return dnt === "1" || dnt === "true";
+}
+var axiomClient;
+function getAxiom() {
+  if (isTrackingDisabled()) return null;
+  if (axiomClient === void 0) {
+    axiomClient = process.env.AXIOM_TOKEN && process.env.AXIOM_DATASET ? new Axiom({ token: process.env.AXIOM_TOKEN }) : null;
+  }
+  return axiomClient;
+}
+var dataset = () => process.env.AXIOM_DATASET ?? "";
+var environment = () => resolveEnvironment();
+function ingestToAxiom(level, message, context) {
+  const axiom = getAxiom();
+  if (!axiom) return;
+  axiom.ingest(dataset(), [
+    { ...context, level, message, environment: environment() }
+  ]);
+}
+function safeErrorText(error) {
+  try {
+    return error instanceof Error ? error.message : String(error);
+  } catch {
+    return "[unreadable error value]";
+  }
+}
+function captureOriginErrorToSentry(error, options) {
+  Sentry.captureException(error, options);
+}
+var logger = {
+  /**
+   * Log an error. Always sends to Sentry and Axiom, only prints to console in dev/verbose mode.
+   *
+   * This is the server's single Sentry capture path for free-form errors —
+   * `Hono.onError` routes through here, so route handlers never call
+   * `captureException` themselves and nothing double-counts.
+   *
+   * NOTE: For new production diagnostics in `server/routes/web/`, prefer `logger.event()` —
+   * free-form messages are not queryable in Axiom. Legacy callers (CLI, system code,
+   * non-route utilities) remain on this API. See `server/utils/LOGGING.md`.
+   */
+  error(message, error, context) {
+    if (!isOriginCaptureHandled(error)) {
+      Sentry.captureException(error ?? new Error(message), {
+        extra: { message, ...context }
+      });
+    }
+    ingestToAxiom("error", message, {
+      ...context,
+      error: safeErrorText(error)
+    });
+    if (shouldLog()) {
+      console.error(message, error);
+    }
+  },
+  /**
+   * Log a warning. Sends to Axiom, only prints to console in dev/verbose mode.
+   *
+   * Deliberately does NOT capture to Sentry. Every `logger.warn` in the tree
+   * used to become a Sentry event, which across thousands of self-hosted
+   * installs is the single largest quota-spike vector we have — and a warning
+   * is by definition something we chose not to treat as a failure. Axiom is
+   * the right home for it: queryable, cheap, no issue-tracker noise. A warning
+   * that genuinely needs a Sentry issue should be an explicit
+   * `logger.event(..., { error, sentry: true })` at the callsite that owns it.
+   *
+   * NOTE: For new production diagnostics in `server/routes/web/`, prefer `logger.event()` —
+   * free-form messages are not queryable in Axiom. Legacy callers (CLI, system code,
+   * non-route utilities) remain on this API. See `server/utils/LOGGING.md`.
+   */
+  warn(message, context) {
+    ingestToAxiom("warn", message, context);
+    if (shouldLog()) {
+      console.warn(message);
+    }
+  },
+  /**
+   * Log info. Always sends to Axiom. Only prints to console in dev/verbose mode.
+   *
+   * NOTE: For new production diagnostics in `server/routes/web/`, prefer `logger.event()` —
+   * free-form messages are not queryable in Axiom. Legacy callers (CLI, system code,
+   * non-route utilities) remain on this API. See `server/utils/LOGGING.md`.
+   */
+  info(message, context) {
+    ingestToAxiom("info", message, context);
+    if (shouldLog()) {
+      console.log(message);
+    }
+  },
+  /**
+   * Log debug info. Always sends to Axiom. Only prints to console in dev/verbose mode. Does not send to Sentry.
+   */
+  debug(message, ...args) {
+    ingestToAxiom("debug", message, args.length ? { args } : void 0);
+    if (shouldLog()) {
+      console.log(message, ...args);
+    }
+  },
+  /**
+   * Flush pending Axiom events. Call before process exit.
+   */
+  async flush() {
+    await getAxiom()?.flush();
+  },
+  event(eventName, base, payload, options) {
+    emit(eventName, base, payload, options);
+  },
+  systemEvent(eventName, base, payload, options) {
+    emit(eventName, base, payload, options);
+  }
+};
+var MAX_ERROR_MESSAGE_CHARS = 2e3;
+var MAX_ERROR_STACK_CHARS = 4e3;
+function serializeEmitError(error) {
+  try {
+    if (error instanceof Error) {
+      return {
+        name: error.name,
+        message: error.message.slice(0, MAX_ERROR_MESSAGE_CHARS),
+        ...error.stack ? { stack: error.stack.slice(0, MAX_ERROR_STACK_CHARS) } : {}
+      };
+    }
+    return String(error).slice(0, MAX_ERROR_MESSAGE_CHARS);
+  } catch {
+    return "[unserializable error]";
+  }
+}
+function emit(eventName, base, payload, options) {
+  const fullPayload = scrubLogPayload({
+    ...base,
+    ...payload,
+    ...options?.error !== void 0 ? { error: serializeEmitError(options.error) } : {},
+    event: eventName,
+    timestamp: (/* @__PURE__ */ new Date()).toISOString()
+  });
+  const axiom = getAxiom();
+  if (axiom) {
+    axiom.ingest(dataset(), [fullPayload]);
+  }
+  if (options?.sentry === true) {
+    if (options.error instanceof Error) {
+      Sentry.captureException(options.error, { extra: fullPayload });
+    } else {
+      Sentry.captureMessage(eventName, {
+        level: "error",
+        extra: {
+          ...fullPayload,
+          ...options.error !== void 0 ? { rawError: String(options.error) } : {}
+        }
+      });
+    }
+  }
+  if (shouldLog()) {
+    const consoleFn = eventName.endsWith(".failed") ? console.error : console.log;
+    consoleFn(`[event] ${eventName}`, fullPayload);
+  }
+}
+process.on("beforeExit", () => logger.flush());
+
+// server/utils/harness/local/runtime-install.ts
+import { createHash as createHash2, randomUUID } from "crypto";
+import { createReadStream, createWriteStream } from "fs";
+import {
+  mkdir,
+  readdir as readdir3,
+  readFile as readFile3,
+  rename,
+  rm,
+  stat as stat2,
+  writeFile
+} from "fs/promises";
+import { homedir } from "os";
+import { basename, join as join2 } from "path";
+import { pipeline } from "stream/promises";
+import { Readable } from "stream";
+import { x as extractTar } from "tar";
+
+// server/utils/harness/local/pack-digests.generated.ts
+var PACK_TREE_DIGESTS = {
+  "claude-code": {},
+  codex: {}
+};
+var PACK_RECORDS = {
+  "claude-code": {},
+  codex: {}
+};
+var EXPECTED_PACK_VERSION = "";
+
+// server/utils/harness/local/pack-signing-key.ts
+import { createPublicKey, verify as edVerify } from "crypto";
+var PACK_SIGNING_KEYS = [
+  {
+    // Generated 2026-09-02. The private half went straight into the CI secret
+    // `LOCAL_HARNESS_PACK_SIGNING_KEY` and exists nowhere else — there is no
+    // copy to lose, and recovery is rotation, not restore.
+    keyId: "pack-2026-09",
+    publicKeyPem: `-----BEGIN PUBLIC KEY-----
+MCowBQYDK2VwAyEAjaZXzr+4k5pJEuzIy5JUU858ksLJgjZv9b9jxmNhV6A=
+-----END PUBLIC KEY-----
+`
+  }
+];
+function verifyPackManifestSignature(manifestBytes, signatureBase64, keys = PACK_SIGNING_KEYS) {
+  if (keys.length === 0) {
+    return {
+      ok: false,
+      reason: "no-keys",
+      message: "this Inspector build carries no runtime pack signing key, so it cannot verify that a downloaded pack came from MCPJam. Packs are installable from a local path for development only."
+    };
+  }
+  let signature;
+  try {
+    signature = Buffer.from(signatureBase64.trim(), "base64");
+    if (signature.length === 0) throw new Error("empty");
+  } catch {
+    return {
+      ok: false,
+      reason: "malformed",
+      message: "the pack manifest signature is not valid base64"
+    };
+  }
+  for (const key of keys) {
+    try {
+      const publicKey = createPublicKey(key.publicKeyPem);
+      if (edVerify(null, manifestBytes, publicKey, signature)) {
+        return { ok: true, keyId: key.keyId };
+      }
+    } catch {
+      continue;
+    }
+  }
+  return {
+    ok: false,
+    reason: "bad-signature",
+    message: "the runtime pack manifest is not signed by any key this Inspector trusts, so the pack is refused"
+  };
+}
+
+// server/utils/harness/local/runtime-identity.ts
+import { createHash } from "crypto";
+import { execFile as execFile2 } from "child_process";
+import { readdir as readdir2, readFile as readFile2, realpath, stat } from "fs/promises";
+import { dirname, isAbsolute, join, normalize, relative, sep } from "path";
+
+// server/utils/harness/local/targets.ts
+var LOCAL_PACK_TARGETS = /* @__PURE__ */ new Set([
+  "darwin-arm64",
+  "darwin-x64",
+  "linux-x64",
+  "linux-arm64",
+  "win32-x64"
+]);
+function localPackTarget(platform = process.platform, arch = process.arch) {
+  const key = `${platform}-${arch}`;
+  return LOCAL_PACK_TARGETS.has(key) ? key : null;
+}
+var LOCAL_HARNESS_POLICY_VERSION = "local-harness-policy-2026-09-01";
+var LOCAL_ISOLATION_POLICY_VERSION = "local-isolation-policy-2026-09-01";
+function currentLocalPlatform(platform = process.platform) {
+  if (platform === "darwin" || platform === "linux" || platform === "win32") {
+    return platform;
+  }
+  return null;
+}
+
+// server/utils/harness/local/process-identity.ts
+import { execFile } from "child_process";
+import { readdir, readFile } from "fs/promises";
+var PS_TIMEOUT_MS = 3e3;
+function parseLinuxProcStat(raw) {
+  const close = raw.lastIndexOf(")");
+  if (close === -1) return null;
+  const fields = raw.slice(close + 2).split(" ");
+  const state = fields[0];
+  const starttime = fields[19];
+  if (!state || !/^[A-Za-z]$/.test(state)) return null;
+  if (!starttime || !/^\d+$/.test(starttime)) return null;
+  return { state, starttime };
+}
+function isDeadState(state) {
+  return state === "Z" || state === "X" || state === "x";
+}
+async function probeLinux(pid) {
+  let raw;
+  try {
+    raw = await readFile(`/proc/${pid}/stat`, "utf8");
+  } catch (error) {
+    const code = error.code;
+    if (code === "ENOENT" || code === "ESRCH") return { state: "gone" };
+    return {
+      state: "unknown",
+      reason: `/proc read failed (${code ?? "unknown"})`
+    };
+  }
+  const parsed = parseLinuxProcStat(raw);
+  if (parsed === null) {
+    return { state: "unknown", reason: "unparseable /proc stat line" };
+  }
+  if (isDeadState(parsed.state)) return { state: "gone" };
+  return { state: "alive", identity: `linux:${parsed.starttime}` };
+}
+function parseDarwinPsLine(raw) {
+  const line = raw.trim();
+  if (line.length === 0) return null;
+  const match = /^(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+(\S+)\s+([\s\S]+)$/.exec(line);
+  if (match === null) return null;
+  const state = match[1];
+  const lstart = [match[2], match[3], match[4], match[5], match[6]].join(" ");
+  const command = match[7];
+  return { state, lstart, command };
+}
+async function probeDarwin(pid) {
+  const result = await new Promise((resolve) => {
+    execFile(
+      "/bin/ps",
+      ["-o", "state=,lstart=,command=", "-p", String(pid)],
+      {
+        timeout: PS_TIMEOUT_MS,
+        maxBuffer: 16 * 1024,
+        encoding: "utf8",
+        env: {}
+      },
+      (error, out) => {
+        if (!error) {
+          resolve({ ok: true, stdout: typeof out === "string" ? out : "" });
+          return;
+        }
+        const err = error;
+        resolve({
+          ok: false,
+          // `ps` exits 1 when no process matches — that IS an answer. A kill
+          // (timeout) or a spawn failure is not.
+          exitCode: typeof err.code === "number" ? err.code : null,
+          reason: err.killed ? "ps timed out" : `ps failed (${String(err.code ?? "unknown")})`
+        });
+      }
+    );
+  });
+  if (!result.ok) {
+    if (result.exitCode === 1) return { state: "gone" };
+    return { state: "unknown", reason: result.reason };
+  }
+  const parsed = parseDarwinPsLine(result.stdout);
+  if (parsed === null) {
+    return result.stdout.trim().length === 0 ? { state: "gone" } : { state: "unknown", reason: "unparseable ps output" };
+  }
+  if (isDeadState(parsed.state.charAt(0))) return { state: "gone" };
+  return {
+    state: "alive",
+    identity: `darwin:${parsed.lstart}|${parsed.command}`
+  };
+}
+async function probeProcess(pid, platform = process.platform) {
+  if (!Number.isInteger(pid) || pid <= 0) {
+    return { state: "unknown", reason: "implausible pid" };
+  }
+  if (platform === "linux") return probeLinux(pid);
+  if (platform === "darwin") return probeDarwin(pid);
+  return { state: "unknown", reason: `no liveness primitive on ${platform}` };
+}
+async function readProcessBirthIdentity(pid, platform = process.platform) {
+  const probe = await probeProcess(pid, platform);
+  return probe.state === "alive" ? probe.identity : null;
+}
+function supportsOwnershipProof(platform = process.platform) {
+  if (platform === "linux" || platform === "darwin") return true;
+  if (platform === "win32") return windowsJobLauncherVerified;
+  return false;
+}
+var windowsJobLauncherVerified = false;
+function setWindowsJobLauncherVerified(verified) {
+  windowsJobLauncherVerified = verified;
+}
+function sameBirthIdentity(recorded, current) {
+  if (recorded === current) return true;
+  const r = /^darwin:([^|]+)\|([\s\S]*)$/.exec(recorded);
+  const c = /^darwin:([^|]+)\|([\s\S]*)$/.exec(current);
+  if (r === null || c === null) return false;
+  return r[1] === c[1] && /^\([^()]+\)$/.test(c[2]);
+}
+async function listGroupMembers(pgid, platform = process.platform) {
+  let pids = [];
+  if (platform === "darwin") {
+    const out = await new Promise((resolve) => {
+      execFile(
+        "/bin/ps",
+        ["-o", "pid=,state=", "-g", String(pgid)],
+        { timeout: PS_TIMEOUT_MS, maxBuffer: 64 * 1024, encoding: "utf8", env: {} },
+        (error, stdout) => resolve(error ? error.code === 1 ? "" : null : String(stdout))
+      );
+    });
+    if (out === null) return null;
+    pids = out.split("\n").map((l) => l.trim().split(/\s+/)).filter((f) => f.length >= 2 && /^\d+$/.test(f[0]) && !isDeadState(f[1].charAt(0))).map((f) => Number(f[0]));
+  } else if (platform === "linux") {
+    let entries;
+    try {
+      entries = await readdir("/proc");
+    } catch {
+      return null;
+    }
+    for (const entry of entries) {
+      if (!/^\d+$/.test(entry)) continue;
+      let raw;
+      try {
+        raw = await readFile(`/proc/${entry}/stat`, "utf8");
+      } catch {
+        continue;
+      }
+      const parsed = parseProcStatGroup(raw);
+      if (parsed !== null && parsed.pgrp === pgid && !isDeadState(parsed.state.charAt(0))) pids.push(Number(entry));
+    }
+  } else {
+    return null;
+  }
+  const members = [];
+  for (const pid of pids) {
+    if (pid === pgid) continue;
+    const identity = await readProcessBirthIdentity(pid, platform);
+    if (identity !== null) members.push({ pid, identity });
+  }
+  return members;
+}
+async function terminateOwnedProcess(args) {
+  const platform = args.platform ?? process.platform;
+  const initial = await probeProcess(args.pid, platform);
+  if (initial.state === "gone") return "already-gone";
+  if (initial.state === "unknown") return "unknown";
+  if (!sameBirthIdentity(args.identity, initial.identity)) return "not-owned";
+  const waitGone = async (ms) => {
+    const until = Date.now() + ms;
+    while (Date.now() < until) {
+      const p = await probeProcess(args.pid, platform);
+      if (p.state === "gone") return true;
+      await new Promise((r) => setTimeout(r, 50));
+    }
+    return false;
+  };
+  try {
+    process.kill(args.pid, "SIGTERM");
+  } catch {
+    return "already-gone";
+  }
+  if (await waitGone(args.graceMs)) return "graceful";
+  const again = await probeProcess(args.pid, platform);
+  if (again.state === "gone") return "graceful";
+  if (again.state === "unknown") return "unknown";
+  if (!sameBirthIdentity(args.identity, again.identity)) return "not-owned";
+  try {
+    process.kill(args.pid, "SIGKILL");
+  } catch {
+    return "graceful";
+  }
+  return await waitGone(500) ? "forced" : "escaped";
+}
+async function probeProcessGroup(pid, platform = process.platform) {
+  if (!Number.isInteger(pid) || pid <= 0) return "unknown";
+  if (platform === "linux") return probeLinuxGroup(pid);
+  if (platform === "darwin") return probeDarwinGroup(pid);
+  return "unknown";
+}
+async function readProcessGroupId(pid, platform = process.platform) {
+  if (!Number.isInteger(pid) || pid <= 0) return null;
+  if (platform === "linux") {
+    try {
+      const raw = await readFile(`/proc/${pid}/stat`, "utf8");
+      return parseProcStatGroup(raw)?.pgrp ?? null;
+    } catch {
+      return null;
+    }
+  }
+  if (platform === "darwin") {
+    return new Promise((resolvePromise) => {
+      execFile(
+        "/bin/ps",
+        ["-o", "pgid=", "-p", String(pid)],
+        {
+          timeout: PS_TIMEOUT_MS,
+          maxBuffer: 4 * 1024,
+          encoding: "utf8",
+          env: {}
+        },
+        (error, stdout) => {
+          if (error) {
+            resolvePromise(null);
+            return;
+          }
+          const parsed = Number(String(stdout).trim());
+          resolvePromise(Number.isInteger(parsed) && parsed > 0 ? parsed : null);
+        }
+      );
+    });
+  }
+  return null;
+}
+function parseProcStatGroup(raw) {
+  const close = raw.lastIndexOf(")");
+  if (close === -1) return null;
+  const fields = raw.slice(close + 1).trim().split(/\s+/);
+  const state = fields[0];
+  const pgrp = Number(fields[2]);
+  if (state === void 0 || !Number.isInteger(pgrp)) return null;
+  return { state, pgrp };
+}
+async function probeLinuxGroup(pgid) {
+  let entries;
+  try {
+    entries = await readdir("/proc");
+  } catch {
+    return "unknown";
+  }
+  let blind = false;
+  for (const entry of entries) {
+    if (!/^\d+$/.test(entry)) continue;
+    let raw;
+    try {
+      raw = await readFile(`/proc/${entry}/stat`, "utf8");
+    } catch (error) {
+      const code = error.code;
+      if (code !== "ENOENT" && code !== "ESRCH") blind = true;
+      continue;
+    }
+    const parsed = parseProcStatGroup(raw);
+    if (parsed === null) {
+      blind = true;
+      continue;
+    }
+    if (parsed.pgrp !== pgid) continue;
+    if (!isDeadState(parsed.state.charAt(0))) return "live";
+  }
+  return blind ? "unknown" : "empty";
+}
+async function probeDarwinGroup(pgid) {
+  const result = await new Promise((resolve) => {
+    execFile(
+      "/bin/ps",
+      ["-o", "state=", "-g", String(pgid)],
+      {
+        timeout: PS_TIMEOUT_MS,
+        maxBuffer: 64 * 1024,
+        encoding: "utf8",
+        env: {}
+      },
+      (error, out) => {
+        if (!error) {
+          resolve({ ok: true, stdout: typeof out === "string" ? out : "" });
+          return;
+        }
+        const err = error;
+        resolve({ ok: false, empty: err.killed !== true && err.code === 1 });
+      }
+    );
+  });
+  if (!result.ok) return result.empty ? "empty" : "unknown";
+  const states = result.stdout.split("\n").map((line) => line.trim()).filter((line) => line.length > 0);
+  if (states.some((state) => !isDeadState(state.charAt(0)))) return "live";
+  return "empty";
+}
+function signalProcessGroup(pid, signal, platform = process.platform) {
+  if (!Number.isInteger(pid) || pid <= 0) return false;
+  try {
+    if (platform === "win32") {
+      return false;
+    }
+    process.kill(-pid, signal);
+    return true;
+  } catch (error) {
+    if (error.code === "ESRCH") return true;
+    return false;
+  }
+}
+async function terminateOwnedProcessGroup(args) {
+  const platform = args.platform ?? process.platform;
+  const pollMs = args.pollMs ?? 50;
+  const settleGroup = async (goneOutcome, anchored) => {
+    const probeGroup = args.probeGroup ?? probeProcessGroup;
+    const before = await probeGroup(args.pid, platform);
+    if (before === "empty") return { outcome: goneOutcome };
+    if (before === "unknown") {
+      return {
+        outcome: "unknown",
+        reason: "the process group could not be enumerated, so a survivor could be neither ruled out nor signalled without risking a reused group id"
+      };
+    }
+    if (!anchored) {
+      return {
+        outcome: "unknown",
+        reason: "a live process group carries this id, but the root was already gone when the stop began, so the group cannot be tied to this tree"
+      };
+    }
+    signalProcessGroup(args.pid, "SIGKILL", platform);
+    await new Promise((r) => setTimeout(r, Math.min(args.graceMs, 500)));
+    const after = await probeGroup(args.pid, platform);
+    if (after === "empty") return { outcome: "forced" };
+    if (after === "unknown") {
+      return {
+        outcome: "unknown",
+        reason: "the process group could not be enumerated after SIGKILL"
+      };
+    }
+    return { outcome: "escaped" };
+  };
+  const initial = await probeProcess(args.pid, platform);
+  if (initial.state === "gone") return settleGroup("already-gone", false);
+  if (initial.state === "unknown") {
+    return { outcome: "unknown", reason: initial.reason };
+  }
+  if (!sameBirthIdentity(args.birthIdentity, initial.identity)) {
+    return { outcome: "not-owned" };
+  }
+  signalProcessGroup(args.pid, "SIGTERM", platform);
+  const deadline = Date.now() + args.graceMs;
+  while (Date.now() < deadline) {
+    await new Promise((r) => setTimeout(r, pollMs));
+    if ((await probeProcess(args.pid, platform)).state === "gone") {
+      return settleGroup("graceful", true);
+    }
+  }
+  const afterGrace = await probeProcess(args.pid, platform);
+  if (afterGrace.state === "gone") return settleGroup("graceful", true);
+  if (afterGrace.state === "unknown") {
+    return { outcome: "unknown", reason: afterGrace.reason };
+  }
+  if (!sameBirthIdentity(args.birthIdentity, afterGrace.identity)) {
+    return settleGroup("graceful", true);
+  }
+  signalProcessGroup(args.pid, "SIGKILL", platform);
+  const killDeadline = Date.now() + Math.max(args.graceMs, 1e3);
+  while (Date.now() < killDeadline) {
+    await new Promise((r) => setTimeout(r, pollMs));
+    if ((await probeProcess(args.pid, platform)).state === "gone") {
+      return settleGroup("forced", true);
+    }
+  }
+  const settled = await probeProcess(args.pid, platform);
+  if (settled.state === "gone") return settleGroup("forced", true);
+  if (settled.state === "unknown") {
+    return { outcome: "unknown", reason: settled.reason };
+  }
+  return { outcome: "escaped" };
+}
+
+// server/utils/harness/local/runtime-identity.ts
+var MAX_BUNDLE_FILES = 5e4;
+var MAX_BUNDLE_BYTES = 2 * 1024 * 1024 * 1024;
+var PROBE_TIMEOUT_MS = 5e3;
+var PROBE_MAX_BUFFER = 64 * 1024;
+async function computeTreeDigest(root) {
+  return (await digestTreeWithSnapshot(root)).digest;
+}
+async function digestTreeWithSnapshot(root) {
+  const hash = createHash("sha256");
+  const entriesSnapshot = [];
+  const executableDigests = {};
+  let files = 0;
+  let bytes = 0;
+  const walk = async (dir) => {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    entries.sort((a, b) => a.name < b.name ? -1 : a.name > b.name ? 1 : 0);
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      const rel = relative(root, full).split(sep).join("/");
+      if (entry.isSymbolicLink()) {
+        throw new Error(
+          `managed runtime bundle contains a symlink at ${rel}; bundles are built as plain files so their digest describes exactly what runs`
+        );
+      }
+      if (entry.isDirectory()) {
+        hash.update(`d\0${rel}\0`);
+        await walk(full);
+        continue;
+      }
+      if (!entry.isFile()) {
+        throw new Error(
+          `managed runtime bundle contains a non-regular file at ${rel}`
+        );
+      }
+      if (++files > MAX_BUNDLE_FILES) {
+        throw new Error(
+          "managed runtime bundle exceeds the file-count ceiling"
+        );
+      }
+      const info = await stat(full);
+      bytes += info.size;
+      if (bytes > MAX_BUNDLE_BYTES) {
+        throw new Error("managed runtime bundle exceeds the size ceiling");
+      }
+      const content = await readFile2(full);
+      const executable = (info.mode & 73) !== 0 ? "1" : "0";
+      const contentDigest = createHash("sha256").update(content).digest();
+      hash.update(`f\0${rel}\0${executable}\0${info.size}\0`);
+      hash.update(contentDigest);
+      entriesSnapshot.push({
+        path: rel,
+        size: info.size,
+        mtimeMs: info.mtimeMs,
+        ctimeMs: info.ctimeMs,
+        ino: Number(info.ino),
+        mode: info.mode
+      });
+      if (isBaselineHashed(rel)) {
+        executableDigests[rel] = contentDigest.toString("hex");
+      }
+    }
+  };
+  await walk(root);
+  return {
+    root,
+    digest: `sha256:${hash.digest("hex")}`,
+    entries: entriesSnapshot,
+    executableDigests
+  };
+}
+var ALWAYS_REHASHED_RELATIVE_PATHS = [
+  "launcher.mjs",
+  "bridge.mjs"
+];
+var STRICT_REHASHED_PATH_PATTERNS = [
+  /^bin\/node(\.exe)?$/,
+  /(^|\/)claude-agent-sdk-[a-z0-9-]+\/(claude|claude\.exe)$/,
+  /(^|\/)claude-code-[a-z0-9-]+\/(claude|claude\.exe)$/
+];
+function strictReverifyEnabled() {
+  return process.env.MCPJAM_LOCAL_HARNESS_STRICT_REVERIFY === "true";
+}
+function isBaselineHashed(relativePath) {
+  return ALWAYS_REHASHED_RELATIVE_PATHS.includes(relativePath) || STRICT_REHASHED_PATH_PATTERNS.some((pattern) => pattern.test(relativePath));
+}
+function isRehashedOnRevalidate(relativePath) {
+  if (ALWAYS_REHASHED_RELATIVE_PATHS.includes(relativePath)) return true;
+  return strictReverifyEnabled() && STRICT_REHASHED_PATH_PATTERNS.some((pattern) => pattern.test(relativePath));
+}
+var verifiedRuntimeCache = /* @__PURE__ */ new Map();
+var inFlightVerifications = /* @__PURE__ */ new Map();
+function verificationCacheKey(root, expectedDigest) {
+  return `${root}\0${expectedDigest}`;
+}
+var cacheGeneration = 0;
+function clearRuntimeVerificationCache() {
+  cacheGeneration += 1;
+  verifiedRuntimeCache.clear();
+  inFlightVerifications.clear();
+}
+async function verifyRuntime(root, expectedDigest) {
+  const key = verificationCacheKey(root, expectedDigest);
+  const cached = verifiedRuntimeCache.get(key);
+  if (cached !== void 0) {
+    return { ok: true, digest: cached.digest, snapshot: cached, cached: true };
+  }
+  const running = inFlightVerifications.get(key);
+  if (running !== void 0) return running;
+  const started = digestOnce(root, expectedDigest, key, cacheGeneration);
+  inFlightVerifications.set(key, started);
+  try {
+    return await started;
+  } finally {
+    if (inFlightVerifications.get(key) === started) {
+      inFlightVerifications.delete(key);
+    }
+  }
+}
+async function digestOnce(root, expectedDigest, key, generation) {
+  let snapshot;
+  try {
+    snapshot = await digestTreeWithSnapshot(root);
+  } catch (error) {
+    return {
+      ok: false,
+      reason: "unreadable",
+      message: error instanceof Error ? error.message : String(error)
+    };
+  }
+  if (snapshot.digest !== expectedDigest) {
+    return { ok: false, reason: "digest-mismatch", digest: snapshot.digest };
+  }
+  if (generation !== cacheGeneration) {
+    return {
+      ok: false,
+      reason: "unreadable",
+      message: "the runtime tree was replaced while it was being verified; verify again"
+    };
+  }
+  verifiedRuntimeCache.set(key, snapshot);
+  return { ok: true, digest: snapshot.digest, snapshot, cached: false };
+}
+function runtimeIdOf(parts) {
+  return `rt_${createHash("sha256").update(parts.join("\0")).digest("hex").slice(0, 32)}`;
+}
+async function resolveManagedBundle(args) {
+  const { manifest, runtimeRoot, platform } = args;
+  if (manifest.runtime.source !== "managed-bundle") {
+    return {
+      ok: false,
+      status: "bundle-absent",
+      message: `${manifest.harnessId} is not configured for a managed bundle`
+    };
+  }
+  const policy = manifest.runtime;
+  const root = join(runtimeRoot, policy.bundleName);
+  let canonicalRoot;
+  try {
+    canonicalRoot = await realpath(root);
+    const info = await stat(canonicalRoot);
+    if (!info.isDirectory()) throw new Error("not a directory");
+  } catch {
+    return {
+      ok: false,
+      status: "bundle-absent",
+      message: `the ${manifest.harnessId} runtime bundle is not present at ${root}. It ships with the Inspector install; reinstall or run the setup step that downloads it. Nothing is installed while a session starts.`
+    };
+  }
+  const arch = args.arch ?? process.arch;
+  const target = localPackTarget(platform, arch);
+  const expectedDigest = target === null ? void 0 : policy.bundleDigest[target];
+  if (expectedDigest === void 0) {
+    return {
+      ok: false,
+      status: "bundle-absent",
+      // The TARGET, not just the OS: on a machine whose architecture nobody
+      // builds for, "no pack for darwin" reads as a platform outage when the
+      // real answer is "no pack for darwin-x64". A user comparing that against
+      // the release assets needs the string that appears there.
+      message: `no ${manifest.harnessId} runtime pack has been built for ${platform}-${arch}, so there is no digest to verify one against`
+    };
+  }
+  const verification = await verifyRuntime(canonicalRoot, expectedDigest);
+  if (!verification.ok && verification.reason === "unreadable") {
+    return {
+      ok: false,
+      status: "bundle-corrupt",
+      message: `the ${manifest.harnessId} runtime bundle could not be digested: ${verification.message}`
+    };
+  }
+  if (!verification.ok) {
+    return {
+      ok: false,
+      status: "bundle-digest-mismatch",
+      message: `the ${manifest.harnessId} runtime bundle does not match the digest this Inspector was built with. Expected ${expectedDigest}, found ${verification.digest}. The bundle is not user- or session-writable by design, so a mismatch means it was replaced \u2014 local execution stays disabled until it is reinstalled.`
+    };
+  }
+  const digest = verification.digest;
+  const insideBundle = async (relativePath, label, requireExecutable) => {
+    const full = join(canonicalRoot, relativePath);
+    if (!normalize(full).startsWith(canonicalRoot + sep)) {
+      return {
+        ok: false,
+        message: `the ${manifest.harnessId} manifest points its ${label} outside the bundle whose digest was verified`
+      };
+    }
+    try {
+      const info = await stat(full);
+      if (!info.isFile()) throw new Error("not a file");
+      if (requireExecutable && platform !== "win32" && (info.mode & 73) === 0) {
+        throw new Error("not executable");
+      }
+    } catch {
+      return {
+        ok: false,
+        message: `the ${manifest.harnessId} runtime bundle has no usable ${label} at ${relativePath}`
+      };
+    }
+    return { ok: true, path: full };
+  };
+  const launcher = await insideBundle(
+    policy.launcherRelativePath,
+    "launcher",
+    false
+  );
+  if (!launcher.ok) {
+    return { ok: false, status: "bundle-corrupt", message: launcher.message };
+  }
+  const launcherPath = launcher.path;
+  const bundledNode = await insideBundle(
+    platform === "win32" ? `${policy.nodeLauncherRelativePath}.exe` : policy.nodeLauncherRelativePath,
+    "Node binary",
+    true
+  );
+  if (!bundledNode.ok) {
+    return { ok: false, status: "bundle-corrupt", message: bundledNode.message };
+  }
+  let jobLauncherPath;
+  if (platform === "win32" && policy.jobLauncherRelativePath) {
+    const helper = await insideBundle(
+      policy.jobLauncherRelativePath,
+      "job launcher",
+      true
+    );
+    if (helper.ok) jobLauncherPath = helper.path;
+  }
+  setWindowsJobLauncherVerified(jobLauncherPath !== void 0);
+  return {
+    ok: true,
+    runtime: {
+      runtimeId: runtimeIdOf([
+        "managed-bundle",
+        manifest.harnessId,
+        manifest.adapterVersion,
+        platform,
+        digest
+      ]),
+      source: "managed-bundle",
+      harnessId: manifest.harnessId,
+      platform,
+      adapterVersion: manifest.adapterVersion,
+      rootPath: canonicalRoot,
+      launcherPath,
+      nodePath: bundledNode.path,
+      ...jobLauncherPath !== void 0 ? { jobLauncherPath } : {},
+      digest,
+      vendorPackages: policy.vendorPackages
+    }
+  };
+}
+function systemInstallSearchPaths(platform) {
+  switch (platform) {
+    case "darwin":
+      return ["/usr/local/bin", "/opt/homebrew/bin", "/usr/bin"];
+    case "linux":
+      return ["/usr/local/bin", "/usr/bin", "/bin"];
+    case "win32":
+      return ["C:\\Program Files", "C:\\Program Files (x86)"];
+  }
+}
+function isUntrustedInstallPath(canonical, forbiddenRoots) {
+  for (const root of forbiddenRoots) {
+    if (canonical === root || canonical.startsWith(root + sep)) {
+      return root;
+    }
+  }
+  if (/(^|[\\/])node_modules([\\/]|$)/.test(canonical)) {
+    return "a node_modules directory";
+  }
+  return null;
+}
+function extractVersion(line) {
+  return /(\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?)/.exec(line)?.[1] ?? null;
+}
+function isSupportedVersionRange(range) {
+  return /^>=\s*\d+\.\d+\.\d+$/.test(range.trim());
+}
+function satisfiesMinimumRange(version, range) {
+  const match = /^>=\s*(\d+)\.(\d+)\.(\d+)$/.exec(range.trim());
+  if (!match) return false;
+  if (version.includes("-")) return false;
+  const parts = version.split(".").map((n) => Number.parseInt(n, 10));
+  if (parts.length !== 3 || parts.some((n) => !Number.isFinite(n)))
+    return false;
+  const min = [Number(match[1]), Number(match[2]), Number(match[3])];
+  for (let i = 0; i < 3; i += 1) {
+    if (parts[i] > min[i]) return true;
+    if (parts[i] < min[i]) return false;
+  }
+  return true;
+}
+async function defaultProbe(executable, args) {
+  return await new Promise((resolvePromise) => {
+    execFile2(
+      executable,
+      [...args],
+      {
+        timeout: PROBE_TIMEOUT_MS,
+        maxBuffer: PROBE_MAX_BUFFER,
+        encoding: "utf8",
+        windowsHide: true,
+        env: { PATH: "", LANG: "C" }
+      },
+      (error, stdout) => {
+        resolvePromise({
+          stdout: typeof stdout === "string" ? stdout : "",
+          exitCode: error ? 1 : 0
+        });
+      }
+    );
+  });
+}
+async function firstUntrustedAncestor(path, platform) {
+  if (platform === "win32") return null;
+  let dir = dirname(path);
+  for (; ; ) {
+    let info;
+    try {
+      info = await stat(dir);
+    } catch {
+      return dir;
+    }
+    const looselyWritable = (info.mode & 18) !== 0 && (info.mode & 512) === 0;
+    if (info.uid !== 0 || looselyWritable) return dir;
+    const parent = dirname(dir);
+    if (parent === dir) return null;
+    dir = parent;
+  }
+}
+async function resolveSystemInstall(opts) {
+  const { manifest, platform } = opts;
+  if (manifest.runtime.source !== "system-install") {
+    return {
+      ok: false,
+      status: "system-runtime-not-installed",
+      message: `${manifest.harnessId} is not configured for a system install`
+    };
+  }
+  if (platform === "darwin") {
+    return {
+      ok: false,
+      status: "system-runtime-untrusted-path",
+      message: `a system installation cannot be trusted on macOS by this Inspector: directory ACLs there can grant replacement rights without appearing in the file mode, and nothing here can read them. Use a managed bundle, whose digest is verified in full.`
+    };
+  }
+  const policy = manifest.runtime;
+  const searchPaths = opts.searchPaths ?? systemInstallSearchPaths(platform);
+  const probe = opts.probe ?? defaultProbe;
+  const accepted = [];
+  const rejections = [];
+  for (const dir of searchPaths) {
+    for (const name of policy.executableNames) {
+      const candidate = join(dir, name);
+      let canonical;
+      try {
+        canonical = await realpath(candidate);
+      } catch {
+        continue;
+      }
+      if (!isAbsolute(canonical)) continue;
+      const untrusted = isUntrustedInstallPath(canonical, opts.forbiddenRoots);
+      if (untrusted) {
+        rejections.push({
+          status: "system-runtime-untrusted-path",
+          message: `${candidate} resolves into ${untrusted}, which the session or the workspace can write`
+        });
+        continue;
+      }
+      let info;
+      try {
+        info = await stat(canonical);
+      } catch {
+        continue;
+      }
+      if (!info.isFile() || (info.mode & 73) === 0) {
+        rejections.push({
+          status: "system-runtime-not-installed",
+          message: `${candidate} is not an executable file`
+        });
+        continue;
+      }
+      if ((info.mode & 18) !== 0) {
+        rejections.push({
+          status: "system-runtime-untrusted-path",
+          message: `${candidate} is group- or world-writable, so its identity cannot be held between verification and launch`
+        });
+        continue;
+      }
+      if (platform !== "win32" && info.uid !== 0) {
+        rejections.push({
+          status: "system-runtime-untrusted-path",
+          message: `${candidate} is owned by uid ${info.uid} rather than a system owner, so the supervised agent \u2014 which runs as that user \u2014 could replace it between verification and launch`
+        });
+        continue;
+      }
+      const untrustedAncestor = await firstUntrustedAncestor(
+        canonical,
+        platform
+      );
+      if (untrustedAncestor !== null) {
+        rejections.push({
+          status: "system-runtime-untrusted-path",
+          message: `${candidate} lives under ${untrustedAncestor}, which is writable by a non-system owner. Replacing the executable there needs only directory permissions, so its verified identity cannot be held between verification and launch`
+        });
+        continue;
+      }
+      if (policy.vendorIdentityPolicy.requirePlatformProvenance) {
+        rejections.push({
+          status: "system-runtime-identity-mismatch",
+          message: `${manifest.harnessId} requires platform code-signing/package provenance, and this Inspector has no verifier for ${platform} yet, so the candidate at ${candidate} cannot be accepted`
+        });
+        continue;
+      }
+      const result = await probe(
+        canonical,
+        policy.vendorIdentityPolicy.probeArgs
+      );
+      const line = result.stdout.trim().split("\n")[0] ?? "";
+      if (result.exitCode !== 0 || !new RegExp(policy.vendorIdentityPolicy.stdoutPattern).test(line)) {
+        rejections.push({
+          status: "system-runtime-identity-mismatch",
+          message: `${candidate} did not identify itself as ${manifest.harnessId} (probe output ${JSON.stringify(line.slice(0, 120))})`
+        });
+        continue;
+      }
+      if (!isSupportedVersionRange(policy.executableVersionRange)) {
+        rejections.push({
+          status: "system-runtime-identity-mismatch",
+          message: `the ${manifest.harnessId} manifest declares version range ${JSON.stringify(policy.executableVersionRange)}, which is not one of the shapes this Inspector evaluates (">=x.y.z")`
+        });
+        continue;
+      }
+      const version = extractVersion(line);
+      if (version === null || !satisfiesMinimumRange(version, policy.executableVersionRange)) {
+        rejections.push({
+          status: "system-runtime-identity-mismatch",
+          message: `${candidate} reports version ${version ?? "(unparseable)"}, which is outside the manifest range ${policy.executableVersionRange}`
+        });
+        continue;
+      }
+      const content = await readFile2(canonical);
+      const digest = `sha256:${createHash("sha256").update(content).digest("hex")}`;
+      accepted.push({
+        runtimeId: runtimeIdOf([
+          "system-install",
+          manifest.harnessId,
+          manifest.adapterVersion,
+          platform,
+          canonical,
+          digest,
+          String(info.ino)
+        ]),
+        source: "system-install",
+        harnessId: manifest.harnessId,
+        platform,
+        adapterVersion: manifest.adapterVersion,
+        rootPath: canonical,
+        launcherPath: canonical,
+        digest,
+        vendorPackages: {},
+        vendorVersionLine: line
+      });
+    }
+  }
+  if (accepted.length === 0) {
+    return {
+      ok: false,
+      // Report the FIRST real rejection's own status, not a blanket one.
+      status: rejections[0]?.status ?? "system-runtime-not-installed",
+      message: `no acceptable ${manifest.harnessId} installation was found in ${searchPaths.join(", ")}.` + (rejections.length ? ` Rejected: ${rejections.map((r) => r.message).join("; ")}.` : "") + ` Inspector never installs or upgrades a harness during a session.`
+    };
+  }
+  if (accepted.length > 1) {
+    const distinct = new Set(accepted.map((r) => r.rootPath));
+    if (distinct.size > 1) {
+      return {
+        ok: false,
+        status: "system-runtime-ambiguous",
+        message: `more than one ${manifest.harnessId} installation is acceptable (${[...distinct].join(
+          ", "
+        )}). Remove or disambiguate them: consent must name exactly one runtime.`
+      };
+    }
+  }
+  return { ok: true, runtime: accepted[0] };
+}
+async function detectSnapshotDrift(snapshot) {
+  const recorded = new Map(snapshot.entries.map((e) => [e.path, e]));
+  let seen = 0;
+  const walk = async (dir) => {
+    const entries = await readdir2(dir, { withFileTypes: true });
+    for (const entry of entries) {
+      const full = join(dir, entry.name);
+      const rel = relative(snapshot.root, full).split(sep).join("/");
+      if (entry.isSymbolicLink()) return `a symlink appeared at ${rel}`;
+      if (entry.isDirectory()) {
+        const nested = await walk(full);
+        if (nested !== null) return nested;
+        continue;
+      }
+      if (!entry.isFile()) return `a non-regular file appeared at ${rel}`;
+      const expected = recorded.get(rel);
+      if (expected === void 0) return `an unexpected file appeared at ${rel}`;
+      seen += 1;
+      const info = await stat(full);
+      if (info.size !== expected.size || info.mtimeMs !== expected.mtimeMs || info.ctimeMs !== expected.ctimeMs || Number(info.ino) !== expected.ino || info.mode !== expected.mode) {
+        return `${rel} was modified`;
+      }
+      if (isRehashedOnRevalidate(rel)) {
+        const content = await readFile2(full);
+        const fileDigest = createHash("sha256").update(content).digest("hex");
+        if (fileDigest !== snapshot.executableDigests[rel]) {
+          return `${rel} was rewritten in place`;
+        }
+      }
+    }
+    return null;
+  };
+  const reason = await walk(snapshot.root);
+  if (reason !== null) return reason;
+  if (seen !== snapshot.entries.length) {
+    return `${snapshot.entries.length - seen} file(s) went missing`;
+  }
+  return null;
+}
+async function revalidateRuntime(runtime) {
+  try {
+    if (runtime.source === "managed-bundle") {
+      const snapshot = verifiedRuntimeCache.get(
+        verificationCacheKey(runtime.rootPath, runtime.digest)
+      );
+      if (snapshot === void 0) {
+        const verification = await verifyRuntime(
+          runtime.rootPath,
+          runtime.digest
+        );
+        if (!verification.ok) {
+          return {
+            ok: false,
+            message: verification.reason === "digest-mismatch" ? `the ${runtime.harnessId} runtime bundle changed after consent was granted (expected ${runtime.digest}, found ${verification.digest})` : `the ${runtime.harnessId} runtime could not be re-verified: ${verification.message}`
+          };
+        }
+        return { ok: true };
+      }
+      const drift = await detectSnapshotDrift(snapshot);
+      if (drift === null) return { ok: true };
+      verifiedRuntimeCache.delete(
+        verificationCacheKey(runtime.rootPath, runtime.digest)
+      );
+      const reverified = await verifyRuntime(runtime.rootPath, runtime.digest);
+      if (reverified.ok) return { ok: true };
+      return {
+        ok: false,
+        message: reverified.reason === "digest-mismatch" ? `the ${runtime.harnessId} runtime bundle changed after consent was granted (${drift}; expected ${runtime.digest}, found ${reverified.digest})` : `the ${runtime.harnessId} runtime could not be re-verified: ${reverified.message}`
+      };
+    }
+    const content = await readFile2(runtime.launcherPath);
+    const digest = `sha256:${createHash("sha256").update(content).digest("hex")}`;
+    if (digest !== runtime.digest) {
+      return {
+        ok: false,
+        message: `the ${runtime.harnessId} executable at ${runtime.launcherPath} was replaced after consent was granted`
+      };
+    }
+    return { ok: true };
+  } catch (error) {
+    return {
+      ok: false,
+      message: `the ${runtime.harnessId} runtime could not be re-verified: ${error instanceof Error ? error.message : String(error)}`
+    };
+  }
+}
+
+// server/utils/harness/local/runtime-install.ts
+var MAX_ARCHIVE_BYTES = 1500 * 1024 * 1024;
+var MAX_EXTRACTED_BYTES = 2 * 1024 * 1024 * 1024;
+var MAX_MANIFEST_BYTES = 1024 * 1024;
+function runtimeInstallRoot() {
+  const override = process.env.MCPJAM_RUNTIME_ROOT;
+  if (override && override.trim().length > 0) return override.trim();
+  return join2(homedir(), ".mcpjam", "harness-local", "runtime");
+}
+function packVersionRoot(packVersion, target = localPackTarget()) {
+  return join2(targetInstallRoot(target), packVersion);
+}
+function targetInstallRoot(target) {
+  return join2(runtimeInstallRoot(), target ?? packPlatformKey());
+}
+function expectedPackFor(harnessId, target) {
+  const override = developmentPackExpectation();
+  if (override !== null) return override;
+  const record = PACK_RECORDS[harnessId]?.[target];
+  if (record === void 0) return null;
+  return { packVersion: record.packVersion, treeDigest: record.treeDigest };
+}
+function developmentPackExpectation() {
+  const source = process.env.MCPJAM_LOCAL_HARNESS_PACK_SOURCE;
+  const expected = process.env.MCPJAM_LOCAL_HARNESS_EXPECTED_PACK;
+  if (!source || !expected) return null;
+  const separator = expected.indexOf(":");
+  if (separator <= 0) return null;
+  const packVersion = expected.slice(0, separator).trim();
+  const treeDigest = expected.slice(separator + 1).trim();
+  if (packVersion.length === 0) return null;
+  if (!/^sha256:[0-9a-f]{64}$/.test(treeDigest)) return null;
+  return { packVersion, treeDigest };
+}
+function packSourceFor(packVersion, platformKey) {
+  const override = process.env.MCPJAM_LOCAL_HARNESS_PACK_SOURCE;
+  if (override && override.trim().length > 0) {
+    const value = override.trim();
+    return /^https?:\/\//.test(value) ? { kind: "url", location: value } : { kind: "file", location: value.replace(/^file:\/\//, "") };
+  }
+  return {
+    kind: "url",
+    location: `https://github.com/MCPJam/inspector/releases/download/v${packVersion}/local-harness-pack-${platformKey}-${packVersion}.tar.gz`
+  };
+}
+function packPlatformKey(platform = process.platform, arch = process.arch) {
+  return `${platform}-${arch}`;
+}
+async function readRuntimeInstallStatus(args) {
+  const platform = currentLocalPlatform(args.platform ?? process.platform);
+  if (platform === null) {
+    return {
+      state: "unsupported-platform",
+      message: `${args.platform ?? process.platform} has no local harness runtime`
+    };
+  }
+  const target = localPackTarget(args.platform, args.arch);
+  const expected = target === null ? null : expectedPackFor(args.harnessId, target);
+  if (expected === null) {
+    return {
+      state: "unsupported-platform",
+      message: `no ${args.harnessId} runtime pack has been built for ${packPlatformKey(args.platform, args.arch)}`
+    };
+  }
+  const inFlight = active.get(expected.packVersion);
+  if (inFlight !== void 0) return inFlight.status;
+  const root = packVersionRoot(expected.packVersion, target);
+  try {
+    const marker = JSON.parse(
+      await readFile3(join2(root, INSTALL_MARKER), "utf8")
+    );
+    if (marker.treeDigest !== expected.treeDigest) {
+      return {
+        state: "corrupt",
+        packVersion: expected.packVersion,
+        message: "the installed runtime pack does not match the digest this Inspector expects; reinstall it"
+      };
+    }
+    await stat2(join2(root, args.harnessId));
+    return {
+      state: "ready",
+      packVersion: expected.packVersion,
+      runtimeRoot: root,
+      digest: expected.treeDigest
+    };
+  } catch {
+    return { state: "absent", packVersion: expected.packVersion };
+  }
+}
+var INSTALL_MARKER = ".mcpjam-pack-installed.json";
+var active = /* @__PURE__ */ new Map();
+async function installRuntimePack(options) {
+  const platform = currentLocalPlatform(options.platform ?? process.platform);
+  if (platform === null) {
+    return {
+      state: "unsupported-platform",
+      message: `${options.platform ?? process.platform} has no local harness runtime`
+    };
+  }
+  const target = localPackTarget(options.platform, options.arch);
+  const expected = target === null ? null : expectedPackFor(options.harnessId, target);
+  if (expected === null) {
+    return {
+      state: "unsupported-platform",
+      message: `no ${options.harnessId} runtime pack has been built for ${packPlatformKey(options.platform, options.arch)}`
+    };
+  }
+  const existing = active.get(expected.packVersion);
+  if (existing !== void 0) return existing.promise;
+  const record = {
+    status: { state: "downloading", packVersion: expected.packVersion, percent: 0 },
+    promise: Promise.resolve({
+      state: "absent",
+      packVersion: expected.packVersion
+    })
+  };
+  active.set(expected.packVersion, record);
+  const setStatus = (status) => {
+    record.status = status;
+    options.onProgress?.(status);
+  };
+  record.promise = (async () => {
+    try {
+      return await performInstall({
+        ...options,
+        platform,
+        expected,
+        setStatus
+      });
+    } catch (error) {
+      const message = error instanceof Error ? error.message : String(error);
+      logger.warn("[local-harness] runtime pack install failed", { message });
+      return {
+        state: "corrupt",
+        packVersion: expected.packVersion,
+        message
+      };
+    } finally {
+      active.delete(expected.packVersion);
+    }
+  })();
+  return record.promise;
+}
+async function performInstall(args) {
+  const { expected, setStatus } = args;
+  const platformKey = packPlatformKey(args.platform, args.arch);
+  const target = localPackTarget(args.platform, args.arch);
+  const versionRoot = packVersionRoot(expected.packVersion, target);
+  const installRoot = targetInstallRoot(target);
+  await mkdir(installRoot, { recursive: true, mode: 448 });
+  const staging = join2(installRoot, `.mcpjam-tmp-${randomUUID()}`);
+  await mkdir(staging, { recursive: true, mode: 448 });
+  try {
+    const source = packSourceFor(expected.packVersion, platformKey);
+    const archivePath = join2(staging, "pack.tar.gz");
+    setStatus({ state: "downloading", packVersion: expected.packVersion, percent: 0 });
+    const archiveSha = await fetchArchive({
+      source,
+      destination: archivePath,
+      onPercent: (percent) => setStatus({
+        state: "downloading",
+        packVersion: expected.packVersion,
+        percent
+      }),
+      ...args.signal ? { signal: args.signal } : {}
+    });
+    setStatus({ state: "verifying", packVersion: expected.packVersion });
+    const manifest = await loadAndVerifyManifest({
+      source,
+      packVersion: expected.packVersion,
+      platformKey,
+      staging
+    });
+    if (manifest !== null && manifest.archive?.sha256 !== void 0) {
+      if (manifest.archive.sha256 !== archiveSha) {
+        throw new Error(
+          `the downloaded runtime pack archive does not match its signed manifest (expected ${manifest.archive.sha256}, got ${archiveSha})`
+        );
+      }
+    }
+    const extractRoot = join2(staging, "extracted");
+    await mkdir(extractRoot, { recursive: true, mode: 448 });
+    await extractTar({
+      file: archivePath,
+      cwd: extractRoot,
+      // No links of any kind survive extraction, and nothing may be written
+      // outside `cwd`. The digest would refuse a symlink later; refusing it
+      // here means it never touches the disk.
+      filter: (path, entry) => {
+        const type = entry.type;
+        if (type !== "File" && type !== "Directory") return false;
+        return !path.split("/").includes("..");
+      },
+      preservePaths: false,
+      strict: true
+    });
+    const packRoot = join2(extractRoot, args.harnessId);
+    const info = await stat2(packRoot).catch(() => null);
+    if (info === null || !info.isDirectory()) {
+      throw new Error(
+        `the runtime pack archive has no ${args.harnessId} directory at its root`
+      );
+    }
+    await assertExtractedSize(packRoot);
+    const digest = await computeTreeDigest(packRoot);
+    if (manifest !== null && digest !== manifest.treeDigest) {
+      throw new Error(
+        `the extracted runtime pack does not match its signed manifest (expected ${manifest.treeDigest}, got ${digest})`
+      );
+    }
+    if (digest !== expected.treeDigest) {
+      throw new Error(
+        `the runtime pack does not match the digest this Inspector was built with (expected ${expected.treeDigest}, got ${digest})`
+      );
+    }
+    if (args.platform === "darwin") await clearQuarantine(extractRoot);
+    await writeFile(
+      join2(extractRoot, INSTALL_MARKER),
+      `${JSON.stringify(
+        {
+          packVersion: expected.packVersion,
+          harnessId: args.harnessId,
+          platform: platformKey,
+          treeDigest: digest,
+          installedAt: (/* @__PURE__ */ new Date()).toISOString()
+        },
+        null,
+        2
+      )}
+`,
+      { mode: 384 }
+    );
+    await rm(versionRoot, { recursive: true, force: true });
+    await rename(extractRoot, versionRoot);
+    clearRuntimeVerificationCache();
+    await sweepOtherVersions(installRoot, expected.packVersion);
+    logger.info("[local-harness] runtime pack installed", {
+      packVersion: expected.packVersion,
+      platform: platformKey
+    });
+    return {
+      state: "ready",
+      packVersion: expected.packVersion,
+      runtimeRoot: versionRoot,
+      digest
+    };
+  } finally {
+    await rm(staging, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function assertExtractedSize(root) {
+  let bytes = 0;
+  const walk = async (dir) => {
+    for (const entry of await readdir3(dir, { withFileTypes: true })) {
+      const full = join2(dir, entry.name);
+      if (entry.isDirectory()) {
+        await walk(full);
+        continue;
+      }
+      bytes += (await stat2(full)).size;
+      if (bytes > MAX_EXTRACTED_BYTES) {
+        throw new Error("the extracted runtime pack exceeds its size ceiling");
+      }
+    }
+  };
+  await walk(root);
+}
+async function sweepOtherVersions(installRoot, keepVersion) {
+  let entries;
+  try {
+    entries = await readdir3(installRoot);
+  } catch {
+    return;
+  }
+  for (const entry of entries) {
+    if (entry === keepVersion) continue;
+    const path = join2(installRoot, entry);
+    if (entry.startsWith(".mcpjam-tmp-")) {
+      await rm(path, { recursive: true, force: true }).catch(() => {
+      });
+      continue;
+    }
+    if (!/^[\w.-]+$/.test(entry)) continue;
+    const owned = await readFile3(join2(path, INSTALL_MARKER), "utf8").then(
+      () => true,
+      () => false
+    );
+    if (!owned) continue;
+    await rm(path, { recursive: true, force: true }).catch(() => {
+    });
+  }
+}
+async function clearQuarantine(root) {
+  const { execFile: execFile3 } = await import("child_process");
+  await new Promise((resolvePromise) => {
+    execFile3(
+      "/usr/bin/xattr",
+      ["-r", "-d", "com.apple.quarantine", root],
+      { timeout: 6e4 },
+      () => resolvePromise()
+    );
+  });
+}
+async function loadAndVerifyManifest(args) {
+  const stem = `local-harness-pack-${args.platformKey}-${args.packVersion}`;
+  const manifestName = `${stem}.manifest.json`;
+  const signatureName = `${manifestName}.sig`;
+  let manifestBytes;
+  let signature;
+  try {
+    if (args.source.kind === "file") {
+      const dir = args.source.location.endsWith(".tar.gz") ? args.source.location.slice(0, -basename(args.source.location).length) : args.source.location;
+      manifestBytes = await readFile3(join2(dir, manifestName));
+      signature = await readFile3(join2(dir, signatureName), "utf8");
+    } else {
+      const base = args.source.location.slice(
+        0,
+        args.source.location.lastIndexOf("/") + 1
+      );
+      manifestBytes = Buffer.from(
+        await (await fetchOrThrow(base + manifestName)).arrayBuffer()
+      );
+      signature = await (await fetchOrThrow(base + signatureName)).text();
+    }
+  } catch (error) {
+    if (args.source.kind === "file") {
+      logger.warn(
+        "[local-harness] local pack source has no signed manifest; installing on the digest alone",
+        { message: error instanceof Error ? error.message : String(error) }
+      );
+      return null;
+    }
+    throw new Error(
+      `the runtime pack has no signed manifest alongside it, so it cannot be shown to have come from MCPJam`
+    );
+  }
+  if (manifestBytes.length > MAX_MANIFEST_BYTES) {
+    throw new Error("the runtime pack manifest is implausibly large");
+  }
+  const verified = verifyPackManifestSignature(manifestBytes, signature);
+  if (!verified.ok) {
+    if (args.source.kind === "file") {
+      logger.warn(
+        "[local-harness] local pack manifest signature not verified; installing on the digest alone",
+        { reason: verified.reason }
+      );
+      return null;
+    }
+    throw new Error(verified.message);
+  }
+  const manifest = JSON.parse(manifestBytes.toString("utf8"));
+  if (manifest.packVersion !== args.packVersion) {
+    throw new Error(
+      `the signed manifest is for pack version ${manifest.packVersion}, not ${args.packVersion}`
+    );
+  }
+  if (manifest.platform !== args.platformKey) {
+    throw new Error(
+      `the signed manifest is for ${manifest.platform}, not ${args.platformKey}`
+    );
+  }
+  return manifest;
+}
+async function fetchOrThrow(url) {
+  const response = await fetch(url);
+  if (!response.ok) {
+    throw new Error(`${url} responded ${response.status}`);
+  }
+  return response;
+}
+async function fetchArchive(args) {
+  const hash = createHash2("sha256");
+  let received = 0;
+  let total = 0;
+  const track = new TransformStream({
+    transform(chunk, controller) {
+      hash.update(chunk);
+      received += chunk.byteLength;
+      if (received > MAX_ARCHIVE_BYTES) {
+        throw new Error("the runtime pack archive exceeds its size ceiling");
+      }
+      if (total > 0) {
+        args.onPercent(Math.min(99, Math.floor(received / total * 100)));
+      }
+      controller.enqueue(chunk);
+    }
+  });
+  if (args.source.kind === "file") {
+    const path = args.source.location;
+    const info = await stat2(path);
+    total = info.size;
+    if (total > MAX_ARCHIVE_BYTES) {
+      throw new Error("the runtime pack archive exceeds its size ceiling");
+    }
+    await pipeline(
+      createReadStream(path),
+      async function* (chunks) {
+        for await (const chunk of chunks) {
+          const buffer = chunk;
+          hash.update(buffer);
+          received += buffer.byteLength;
+          args.onPercent(Math.min(99, Math.floor(received / total * 100)));
+          yield buffer;
+        }
+      },
+      createWriteStream(args.destination, { mode: 384 })
+    );
+    return hash.digest("hex");
+  }
+  const response = await fetch(args.source.location, {
+    ...args.signal ? { signal: args.signal } : {}
+  });
+  if (!response.ok || response.body === null) {
+    throw new Error(
+      `the runtime pack could not be downloaded: ${args.source.location} responded ${response.status}`
+    );
+  }
+  const declared = Number(response.headers.get("content-length") ?? "0");
+  if (declared > MAX_ARCHIVE_BYTES) {
+    throw new Error("the runtime pack archive exceeds its size ceiling");
+  }
+  total = declared;
+  await pipeline(
+    Readable.fromWeb(
+      response.body.pipeThrough(track)
+    ),
+    createWriteStream(args.destination, { mode: 384 })
+  );
+  args.onPercent(100);
+  return hash.digest("hex");
+}
+function reportLocalHarnessRuntimeStatusInBackground() {
+  void (async () => {
+    try {
+      const status = await readRuntimeInstallStatus({
+        harnessId: "claude-code"
+      });
+      if (status.state === "ready") {
+        logger.info("[local-harness] runtime pack present", {
+          packVersion: status.packVersion
+        });
+        return;
+      }
+      logger.debug("[local-harness] no runtime pack installed", {
+        state: status.state,
+        expected: EXPECTED_PACK_VERSION || "(none built)"
+      });
+    } catch {
+    }
+  })();
+}
+
+export {
+  resolveEnvironment,
+  resolveAppVersion,
+  resolveRelease,
+  markOriginCaptureHandled,
+  ensureStampable,
+  isOriginCaptureHandled,
+  captureOriginErrorToSentry,
+  logger,
+  PACK_TREE_DIGESTS,
+  LOCAL_HARNESS_POLICY_VERSION,
+  LOCAL_ISOLATION_POLICY_VERSION,
+  currentLocalPlatform,
+  probeProcess,
+  readProcessBirthIdentity,
+  supportsOwnershipProof,
+  listGroupMembers,
+  terminateOwnedProcess,
+  probeProcessGroup,
+  readProcessGroupId,
+  terminateOwnedProcessGroup,
+  resolveManagedBundle,
+  resolveSystemInstall,
+  revalidateRuntime,
+  runtimeInstallRoot,
+  readRuntimeInstallStatus,
+  installRuntimePack,
+  reportLocalHarnessRuntimeStatusInBackground
+};
+//# sourceMappingURL=chunk-7TOT3ZWN.js.map