@pushary/agent-hooks 1.9.6 → 1.9.8

package/dist/chunk-KFF7G225.js

@@ -0,0 +1,599 @@
+import {
+  openCodeConfigDirFrom
+} from "./chunk-MFF3ONG5.js";
+import {
+  codexHomeFrom,
+  resolvePathBinary
+} from "./chunk-ZBHUHJG6.js";
+import {
+  HOOK_COMPATIBLE_PROFILES
+} from "./chunk-I5IJRMNV.js";
+
+// src/hermes-config.ts
+import { execFileSync } from "child_process";
+import { existsSync, readFileSync, rmSync, writeFileSync } from "fs";
+import { homedir, tmpdir } from "os";
+import { join } from "path";
+var isRecord = (value) => Boolean(value) && typeof value === "object" && !Array.isArray(value);
+var isSnapshot = (value) => isRecord(value) && typeof value.present === "boolean" && Object.hasOwn(value, "value");
+var isHermesConfigReceipt = (value) => {
+  if (!isRecord(value)) return false;
+  return ["security", "approval", "transport", "fallback", "plugins", "enabled", "agent", "disabled"].every((key) => isSnapshot(value[key])) && typeof value.pushary_enabled === "boolean" && typeof value.clarify_disabled === "boolean";
+};
+var HERMES_PIP_PACKAGE = "hermes-plugin-pushary";
+var HERMES_PLUGIN_NAME = "pushary";
+var HERMES_CONFIG_SCRIPT = String.raw`
+import copy, importlib.util, json, os, sys
+from hermes_cli.config import load_config, save_config
+
+PUSHARY_TRANSPORT = "pushary"
+PUSHARY_FALLBACK = "builtin"
+PUSHARY_PLUGIN = "pushary"
+PUSHARY_PLUGIN_MODULE = "pushary_plugin"
+QUESTION_TOOLSET = "clarify"
+
+mode = sys.argv[1]
+receipt_path = sys.argv[2] if len(sys.argv) > 2 else None
+c = load_config()
+original = copy.deepcopy(c)
+
+def section(obj, key):
+    value = obj.get(key)
+    return value if isinstance(value, dict) else {}
+
+def members(obj, key):
+    value = obj.get(key)
+    return value if isinstance(value, list) else []
+
+if mode == "status":
+    print(json.dumps({
+        "plugin_installed": importlib.util.find_spec(PUSHARY_PLUGIN_MODULE) is not None,
+        "plugin_enabled": PUSHARY_PLUGIN in members(section(c, "plugins"), "enabled"),
+        "approvals_routed": section(section(c, "security"), "approval").get("transport") == PUSHARY_TRANSPORT,
+        "questions_routed": QUESTION_TOOLSET in members(section(c, "agent"), "disabled_toolsets"),
+    }))
+    sys.exit(0)
+
+def recorded(snapshot, value):
+    return bool(snapshot.get("present")) and snapshot.get("value") == value
+
+def pop_if(obj, key, value):
+    if obj.get(key) == value:
+        obj.pop(key, None)
+
+def snap(obj, key):
+    return {"present": key in obj, "value": obj.get(key)}
+
+restore_conflicts = []
+
+def restore(obj, key, before, ours):
+    if before.get("present") and before.get("value") == ours:
+        return
+    if before.get("present"):
+        if key in obj and obj.get(key) == before.get("value"):
+            return
+    elif key not in obj:
+        return
+    if obj.get(key) != ours:
+        restore_conflicts.append(key)
+        return
+    if before.get("present"):
+        obj[key] = before.get("value")
+    else:
+        obj.pop(key, None)
+
+def restore_container(obj, key, before, current, changed):
+    raw = obj.get(key)
+    if isinstance(before.get("value"), dict):
+        if not isinstance(raw, dict):
+            if changed:
+                restore_conflicts.append(key)
+            return
+        if current or before.get("present"):
+            obj[key] = current
+        else:
+            obj.pop(key, None)
+    elif isinstance(raw, dict) and current:
+        restore_conflicts.append(key)
+    else:
+        restore(obj, key, before, {})
+
+def restore_list_member(obj, key, before, ours, ours_before):
+    raw = obj.get(key)
+    if isinstance(before.get("value"), list):
+        if ours_before:
+            return
+        if not isinstance(raw, list):
+            restore_conflicts.append(key)
+            return
+        remaining = [item for item in raw if item != ours]
+        if remaining or before.get("present"):
+            obj[key] = remaining
+        else:
+            obj.pop(key, None)
+        return
+    if before.get("present") and raw == before.get("value"):
+        return
+    if not before.get("present") and key not in obj:
+        return
+    if not isinstance(raw, list):
+        restore_conflicts.append(key)
+        return
+    remaining = [item for item in raw if item != ours]
+    if remaining:
+        restore_conflicts.append(key)
+    else:
+        restore(obj, key, before, raw)
+
+def valid_snapshot(value):
+    return isinstance(value, dict) and isinstance(value.get("present"), bool) and "value" in value
+
+def valid_receipt(value):
+    snapshots = ["security", "approval", "transport", "fallback", "plugins", "enabled", "agent", "disabled"]
+    return (isinstance(value, dict)
+        and all(valid_snapshot(value.get(key)) for key in snapshots)
+        and isinstance(value.get("pushary_enabled"), bool)
+        and isinstance(value.get("clarify_disabled"), bool))
+
+if mode == "setup":
+    security_before = snap(c, "security")
+    s = section(c, "security")
+    approval_before = snap(s, "approval")
+    ap = section(s, "approval")
+    plugins_before = snap(c, "plugins")
+    p = section(c, "plugins")
+    agent_before = snap(c, "agent")
+    a = section(c, "agent")
+    enabled = members(p, "enabled")
+    disabled = members(a, "disabled_toolsets")
+    receipt = {
+        "security": security_before,
+        "approval": approval_before,
+        "transport": snap(ap, "transport"),
+        "fallback": snap(ap, "transport_fallback"),
+        "plugins": plugins_before,
+        "enabled": snap(p, "enabled"),
+        "pushary_enabled": PUSHARY_PLUGIN in enabled,
+        "agent": agent_before,
+        "disabled": snap(a, "disabled_toolsets"),
+        "clarify_disabled": QUESTION_TOOLSET in disabled,
+    }
+    if os.path.exists(receipt_path):
+        with open(receipt_path, encoding="utf-8") as handle:
+            existing_receipt = json.load(handle)
+        if not valid_receipt(existing_receipt):
+            raise ValueError("invalid Pushary Hermes setup receipt")
+    else:
+        os.makedirs(os.path.dirname(receipt_path), exist_ok=True)
+        temp = receipt_path + ".tmp"
+        with open(temp, "x", encoding="utf-8") as handle:
+            json.dump(receipt, handle)
+        os.chmod(temp, 0o600)
+        os.replace(temp, receipt_path)
+    ap["transport"] = PUSHARY_TRANSPORT
+    ap["transport_fallback"] = PUSHARY_FALLBACK
+    s["approval"] = ap
+    c["security"] = s
+    p["enabled"] = enabled if PUSHARY_PLUGIN in enabled else enabled + [PUSHARY_PLUGIN]
+    c["plugins"] = p
+    a["disabled_toolsets"] = disabled if QUESTION_TOOLSET in disabled else disabled + [QUESTION_TOOLSET]
+    c["agent"] = a
+else:
+    receipt_exists = os.path.exists(receipt_path)
+    try:
+        with open(receipt_path, encoding="utf-8") as handle:
+            receipt = json.load(handle)
+    except (OSError, ValueError):
+        if receipt_exists:
+            raise
+        receipt = None
+    s = section(c, "security")
+    ap = section(s, "approval")
+    if receipt:
+        if not valid_receipt(receipt):
+            raise ValueError("invalid Pushary Hermes setup receipt")
+        approval_changed = (not receipt["transport"].get("present")
+            or receipt["transport"].get("value") != PUSHARY_TRANSPORT
+            or not receipt["fallback"].get("present")
+            or receipt["fallback"].get("value") != PUSHARY_FALLBACK)
+        plugins_changed = not (isinstance(receipt["enabled"].get("value"), list)
+            and receipt["pushary_enabled"])
+        agent_changed = not (isinstance(receipt["disabled"].get("value"), list)
+            and receipt["clarify_disabled"])
+        transport_left_over = recorded(receipt["transport"], PUSHARY_TRANSPORT)
+        if transport_left_over:
+            pop_if(ap, "transport", PUSHARY_TRANSPORT)
+        else:
+            restore(ap, "transport", receipt["transport"], PUSHARY_TRANSPORT)
+        if transport_left_over and recorded(receipt["fallback"], PUSHARY_FALLBACK):
+            pop_if(ap, "transport_fallback", PUSHARY_FALLBACK)
+        else:
+            restore(ap, "transport_fallback", receipt["fallback"], PUSHARY_FALLBACK)
+    else:
+        pop_if(ap, "transport", PUSHARY_TRANSPORT)
+        pop_if(ap, "transport_fallback", PUSHARY_FALLBACK)
+    if receipt:
+        restore_container(s, "approval", receipt["approval"], ap, approval_changed)
+        restore_container(c, "security", receipt["security"], s, approval_changed)
+    else:
+        if ap: s["approval"] = ap
+        else: s.pop("approval", None)
+        if s: c["security"] = s
+        else: c.pop("security", None)
+
+    p = section(c, "plugins")
+    if receipt:
+        restore_list_member(p, "enabled", receipt["enabled"], PUSHARY_PLUGIN, False)
+        restore_container(c, "plugins", receipt["plugins"], p, plugins_changed)
+    else:
+        enabled = [item for item in members(p, "enabled") if item != PUSHARY_PLUGIN]
+        if enabled: p["enabled"] = enabled
+        else: p.pop("enabled", None)
+        if p: c["plugins"] = p
+        else: c.pop("plugins", None)
+
+    a = section(c, "agent")
+    if receipt:
+        clarify_was_users = receipt["clarify_disabled"] and not recorded(receipt["transport"], PUSHARY_TRANSPORT)
+        restore_list_member(a, "disabled_toolsets", receipt["disabled"], QUESTION_TOOLSET, clarify_was_users)
+        restore_container(c, "agent", receipt["agent"], a, agent_changed)
+    else:
+        disabled = [item for item in members(a, "disabled_toolsets") if item != QUESTION_TOOLSET]
+        if disabled: a["disabled_toolsets"] = disabled
+        else: a.pop("disabled_toolsets", None)
+        if a: c["agent"] = a
+        else: c.pop("agent", None)
+
+    if receipt and restore_conflicts:
+        raise ValueError("Hermes config changed after Pushary setup")
+
+changed = c != original
+if changed and mode != "clean-preview":
+    save_config(c)
+print(json.dumps({"changed": changed}))
+`;
+var resolveHermesPython = () => {
+  const launcher = resolvePathBinary("hermes");
+  if (launcher && process.platform !== "win32") {
+    try {
+      const shebang = readFileSync(launcher, "utf-8").split("\n", 1)[0];
+      const interpreter = shebang?.startsWith("#!") ? shebang.slice(2).trim().split(/\s+/)[0] : void 0;
+      if (interpreter && /python/i.test(interpreter) && existsSync(interpreter)) return interpreter;
+    } catch {
+    }
+  }
+  const root = join(homedir(), ".hermes", "hermes-agent", "venv");
+  const candidates = process.platform === "win32" ? [join(root, "Scripts", "python.exe"), join(root, "Scripts", "python3.exe")] : [join(root, "bin", "python3"), join(root, "bin", "python")];
+  return candidates.find(existsSync) ?? null;
+};
+var HERMES_SCRIPT_TIMEOUT_MS = 15e3;
+var runPythonScript = (python, script, args) => {
+  const path = join(tmpdir(), `pushary-hermes-${process.pid}-${Date.now()}.py`);
+  try {
+    writeFileSync(path, script, { encoding: "utf-8", mode: 384 });
+    return execFileSync(python, [path, ...args], {
+      env: { ...process.env },
+      encoding: "utf-8",
+      stdio: "pipe",
+      timeout: HERMES_SCRIPT_TIMEOUT_MS
+    });
+  } catch {
+    return null;
+  } finally {
+    try {
+      rmSync(path, { force: true });
+    } catch {
+    }
+  }
+};
+var lastReport = (stdout) => {
+  const line = stdout.trim().split("\n").at(-1) ?? "";
+  try {
+    return JSON.parse(line);
+  } catch {
+    return void 0;
+  }
+};
+var configRunFrom = (stdout) => {
+  const report = stdout === null ? void 0 : lastReport(stdout);
+  if (!isRecord(report) || typeof report.changed !== "boolean") return "failed";
+  return report.changed ? "changed" : "unchanged";
+};
+var runHermesConfigScript = (python, mode, receiptPath) => configRunFrom(runPythonScript(python, HERMES_CONFIG_SCRIPT, [mode, receiptPath]));
+var HERMES_STATUS_FIELDS = ["plugin_installed", "plugin_enabled", "approvals_routed", "questions_routed"];
+var isHermesStatusReport = (value) => isRecord(value) && HERMES_STATUS_FIELDS.every((field) => typeof value[field] === "boolean");
+var hermesWiredByPushary = (status, setupRecorded) => setupRecorded || status.pluginEnabled || status.approvalsRouted;
+var readHermesStatus = (python) => {
+  const stdout = runPythonScript(python, HERMES_CONFIG_SCRIPT, ["status"]);
+  const report = stdout === null ? void 0 : lastReport(stdout);
+  if (!isHermesStatusReport(report)) return null;
+  return {
+    pluginInstalled: report.plugin_installed,
+    pluginEnabled: report.plugin_enabled,
+    approvalsRouted: report.approvals_routed,
+    questionsRouted: report.questions_routed
+  };
+};
+
+// src/vscode-config.ts
+import { homedir as homedir2 } from "os";
+import { join as join2 } from "path";
+var PLUGIN_LOCATIONS_KEY = "chat.pluginLocations";
+var blankJsonComments = (text) => {
+  let out = "";
+  let i = 0;
+  let inString = false;
+  let escaped = false;
+  while (i < text.length) {
+    const ch = text[i];
+    if (inString) {
+      out += ch;
+      if (escaped) escaped = false;
+      else if (ch === "\\") escaped = true;
+      else if (ch === '"') inString = false;
+      i += 1;
+      continue;
+    }
+    if (ch === '"') {
+      inString = true;
+      out += ch;
+      i += 1;
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "/") {
+      while (i < text.length && text[i] !== "\n") {
+        out += " ";
+        i += 1;
+      }
+      continue;
+    }
+    if (ch === "/" && text[i + 1] === "*") {
+      const end = text.indexOf("*/", i + 2);
+      const stop = end === -1 ? text.length : end + 2;
+      while (i < stop) {
+        out += text[i] === "\n" ? "\n" : " ";
+        i += 1;
+      }
+      continue;
+    }
+    out += ch;
+    i += 1;
+  }
+  return out;
+};
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var parseJsonc = (text) => {
+  const blanked = blankJsonComments(text);
+  const withoutTrailingCommas = blanked.replace(/,(\s*[}\]])/g, "$1");
+  try {
+    return asRecord(JSON.parse(withoutTrailingCommas));
+  } catch {
+    return void 0;
+  }
+};
+var rootBraceIndex = (text) => blankJsonComments(text).indexOf("{");
+var detectIndent = (text) => {
+  const match = /\n([ \t]+)"/.exec(text);
+  return match?.[1] ?? "  ";
+};
+var freshDocument = (pluginDir, indent = "  ") => `${JSON.stringify({ [PLUGIN_LOCATIONS_KEY]: { [pluginDir]: true } }, null, indent)}
+`;
+var registerPluginLocation = (existing, pluginDir) => {
+  if (existing === null || existing.trim() === "") {
+    return { kind: "created", content: freshDocument(pluginDir) };
+  }
+  const indent = detectIndent(existing);
+  try {
+    const parsed2 = asRecord(JSON.parse(existing));
+    if (parsed2) {
+      const locations2 = asRecord(parsed2[PLUGIN_LOCATIONS_KEY]) ?? {};
+      if (locations2[pluginDir] === true) return { kind: "already" };
+      parsed2[PLUGIN_LOCATIONS_KEY] = { ...locations2, [pluginDir]: true };
+      return { kind: "merged", content: `${JSON.stringify(parsed2, null, indent)}
+` };
+    }
+  } catch {
+  }
+  const parsed = parseJsonc(existing);
+  if (!parsed) return { kind: "manual" };
+  const locations = asRecord(parsed[PLUGIN_LOCATIONS_KEY]);
+  if (locations?.[pluginDir] === true) return { kind: "already" };
+  if (parsed[PLUGIN_LOCATIONS_KEY] !== void 0) return { kind: "manual" };
+  const brace = rootBraceIndex(existing);
+  if (brace === -1) return { kind: "manual" };
+  const needsComma = Object.keys(parsed).length > 0;
+  const line = `
+${indent}${JSON.stringify(PLUGIN_LOCATIONS_KEY)}: { ${JSON.stringify(pluginDir)}: true }${needsComma ? "," : ""}`;
+  return {
+    kind: "inserted",
+    content: `${existing.slice(0, brace + 1)}${line}${existing.slice(brace + 1)}`
+  };
+};
+var unregisterPluginLocation = (existing, pluginDir) => {
+  if (existing === null || existing.trim() === "") return { kind: "absent" };
+  const indent = detectIndent(existing);
+  try {
+    const parsed2 = asRecord(JSON.parse(existing));
+    if (parsed2) {
+      const locations2 = asRecord(parsed2[PLUGIN_LOCATIONS_KEY]);
+      if (!locations2 || !(pluginDir in locations2)) return { kind: "absent" };
+      const remaining = { ...locations2 };
+      delete remaining[pluginDir];
+      if (Object.keys(remaining).length === 0) delete parsed2[PLUGIN_LOCATIONS_KEY];
+      else parsed2[PLUGIN_LOCATIONS_KEY] = remaining;
+      return { kind: "removed", content: `${JSON.stringify(parsed2, null, indent)}
+` };
+    }
+  } catch {
+  }
+  const parsed = parseJsonc(existing);
+  if (!parsed) return { kind: "manual" };
+  const locations = asRecord(parsed[PLUGIN_LOCATIONS_KEY]);
+  if (!locations || !(pluginDir in locations)) return { kind: "absent" };
+  const line = new RegExp(
+    `\\n[ \\t]*${escapeRegExp(JSON.stringify(PLUGIN_LOCATIONS_KEY))}\\s*:\\s*\\{\\s*${escapeRegExp(JSON.stringify(pluginDir))}\\s*:\\s*true\\s*\\},?`
+  );
+  if (!line.test(existing)) return { kind: "manual" };
+  return { kind: "removed", content: existing.replace(line, "") };
+};
+var escapeRegExp = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, "\\$&");
+var isPluginRegistered = (existing, pluginDir) => {
+  if (!existing) return false;
+  const parsed = parseJsonc(existing);
+  return asRecord(parsed?.[PLUGIN_LOCATIONS_KEY])?.[pluginDir] === true;
+};
+var pluginLocationSnippet = (pluginDir) => `"${PLUGIN_LOCATIONS_KEY}": {
+  ${JSON.stringify(pluginDir)}: true
+}`;
+var VSCODE_PRODUCTS = ["Code", "Code - Insiders"];
+var settingsRoot = (home, platform) => {
+  if (platform === "darwin") return join2(home, "Library", "Application Support");
+  if (platform === "win32") return process.env.APPDATA?.trim() || join2(home, "AppData", "Roaming");
+  return process.env.XDG_CONFIG_HOME?.trim() || join2(home, ".config");
+};
+var vscodeSettingsCandidates = (home = homedir2(), platform = process.platform) => {
+  const root = settingsRoot(home, platform);
+  return VSCODE_PRODUCTS.map((product) => join2(root, product, "User", "settings.json"));
+};
+var vscodeSettingsTargets = (exists, home, platform) => {
+  const candidates = vscodeSettingsCandidates(home, platform);
+  const present = candidates.filter((path) => exists(path));
+  return present.length > 0 ? present : candidates.slice(0, 1);
+};
+
+// src/setup/detect.ts
+import { execSync } from "child_process";
+import { existsSync as existsSync2 } from "fs";
+import { homedir as homedir3 } from "os";
+import { dirname, join as join3 } from "path";
+var whichCommand = () => process.platform === "win32" ? "where" : "which";
+var binaryOnPath = (binary) => {
+  try {
+    execSync(`${whichCommand()} ${binary}`, { stdio: "ignore", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var defaultDeps = { onPath: binaryOnPath, exists: existsSync2 };
+var detectAgent = (probe, deps = defaultDeps) => {
+  const checked = [];
+  if (probe.binary) {
+    checked.push(`${whichCommand()} ${probe.binary}`);
+    if (deps.onPath(probe.binary)) {
+      return { kind: "installed", evidence: `${probe.binary} on PATH`, strong: true };
+    }
+  }
+  for (const path of probe.paths) {
+    checked.push(path);
+    if (deps.exists(path)) return { kind: "installed", evidence: path, strong: true };
+  }
+  for (const marker of probe.configMarkers) {
+    checked.push(marker);
+    if (deps.exists(marker)) return { kind: "installed", evidence: marker, strong: false };
+  }
+  if (probe.binary === null && probe.paths.length === 0 && probe.configMarkers.length === 0) {
+    return { kind: "unknown" };
+  }
+  return { kind: "not-found", checked };
+};
+var agentProbes = (home = homedir3()) => ({
+  claude_code: {
+    binary: "claude",
+    // The native installer puts it here, outside a default non-login PATH.
+    paths: [join3(home, ".local", "bin", "claude")],
+    configMarkers: [join3(home, ".claude")]
+  },
+  codex: {
+    binary: "codex",
+    paths: [],
+    configMarkers: [codexHomeFrom(home)]
+  },
+  gemini_cli: {
+    binary: "gemini",
+    paths: [],
+    configMarkers: [join3(home, ".gemini")]
+  },
+  hermes: {
+    binary: "hermes",
+    paths: [],
+    configMarkers: [join3(home, ".hermes")]
+  },
+  cursor: {
+    // GUI editor. `cursor` on PATH only exists if the user ran "Install 'cursor'
+    // command in PATH" from the command palette, which most never do.
+    binary: "cursor",
+    paths: process.platform === "darwin" ? ["/Applications/Cursor.app"] : process.platform === "win32" ? [join3(process.env.LOCALAPPDATA ?? join3(home, "AppData", "Local"), "Programs", "cursor")] : ["/usr/share/cursor", join3(home, ".local", "share", "cursor")],
+    configMarkers: [join3(home, ".cursor")]
+  },
+  vscode: {
+    // Like Cursor, a GUI editor: `code` on PATH only exists if the user ran
+    // "Shell Command: Install 'code' command in PATH", which on macOS is opt-in.
+    binary: "code",
+    paths: process.platform === "darwin" ? ["/Applications/Visual Studio Code.app"] : process.platform === "win32" ? [join3(process.env.LOCALAPPDATA ?? join3(home, "AppData", "Local"), "Programs", "Microsoft VS Code")] : ["/usr/share/code", join3(home, ".local", "share", "code")],
+    // The settings directory rather than ~/.vscode, because the settings
+    // directory is what this installer actually writes to. Insiders counts:
+    // someone running only Insiders still has VS Code.
+    configMarkers: vscodeSettingsCandidates(home).map((path) => dirname(path))
+  },
+  opencode: {
+    binary: "opencode",
+    paths: [],
+    // Resolved rather than spelled: OpenCode honours OPENCODE_CONFIG_DIR and then
+    // XDG_CONFIG_HOME, and `~/.opencode` — the obvious guess — is a path it has
+    // never used.
+    configMarkers: [openCodeConfigDirFrom(home)]
+  },
+  fx: {
+    binary: null,
+    paths: [join3(home, ".fx", "settings.json"), join3(home, ".fx", "sessions"), join3(home, ".fx", "history.jsonl")],
+    configMarkers: []
+  },
+  ...compatibleProbes(),
+  // "Other" is a set of printed instructions for any MCP or HTTP client. There is
+  // nothing to detect, and it must never be auto-selected.
+  custom: { binary: null, paths: [], configMarkers: [] }
+});
+var compatibleProbes = () => HOOK_COMPATIBLE_PROFILES.reduce((probes, profile) => ({
+  ...probes,
+  [profile.agentType]: {
+    binary: profile.binary,
+    paths: [],
+    configMarkers: []
+  }
+}), {});
+var detectAllAgents = (deps = defaultDeps, home) => {
+  const probes = agentProbes(home);
+  return Object.keys(probes).map((agent) => ({
+    agent,
+    result: detectAgent(probes[agent], deps)
+  }));
+};
+var isDetected = (result) => result.kind === "installed";
+var shortenHome = (path, home = homedir3()) => home && path.startsWith(home) ? `~${path.slice(home.length)}` : path;
+var describeDetection = (result, home) => {
+  if (result.kind !== "installed") return null;
+  const evidence = shortenHome(result.evidence, home);
+  return result.strong ? evidence : `${evidence}, config only`;
+};
+
+export {
+  isHermesConfigReceipt,
+  HERMES_PIP_PACKAGE,
+  HERMES_PLUGIN_NAME,
+  resolveHermesPython,
+  runHermesConfigScript,
+  hermesWiredByPushary,
+  readHermesStatus,
+  registerPluginLocation,
+  unregisterPluginLocation,
+  isPluginRegistered,
+  pluginLocationSnippet,
+  vscodeSettingsTargets,
+  detectAgent,
+  agentProbes,
+  detectAllAgents,
+  isDetected,
+  shortenHome,
+  describeDetection
+};