@pushary/agent-hooks 0.89.9 → 0.89.10

package/dist/chunk-UDBJHQMG.js

@@ -0,0 +1,240 @@
+import {
+  resolvePathBinary
+} from "./chunk-X4ZUUFKV.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_CONFIG_SCRIPT = String.raw`
+import json, os, sys
+from hermes_cli.config import load_config, save_config
+
+mode, receipt_path = sys.argv[1], sys.argv[2]
+c = load_config()
+
+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 = c.get("security") if isinstance(c.get("security"), dict) else {}
+    approval_before = snap(s, "approval")
+    ap = s.get("approval") if isinstance(s.get("approval"), dict) else {}
+    plugins_before = snap(c, "plugins")
+    p = c.get("plugins") if isinstance(c.get("plugins"), dict) else {}
+    agent_before = snap(c, "agent")
+    a = c.get("agent") if isinstance(c.get("agent"), dict) else {}
+    enabled = p.get("enabled") if isinstance(p.get("enabled"), list) else []
+    disabled = a.get("disabled_toolsets") if isinstance(a.get("disabled_toolsets"), list) else []
+    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" in enabled,
+        "agent": agent_before,
+        "disabled": snap(a, "disabled_toolsets"),
+        "clarify_disabled": "clarify" 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"
+    ap["transport_fallback"] = "builtin"
+    s["approval"] = ap
+    c["security"] = s
+    p["enabled"] = enabled if "pushary" in enabled else enabled + ["pushary"]
+    c["plugins"] = p
+    a["disabled_toolsets"] = disabled if "clarify" in disabled else disabled + ["clarify"]
+    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 = c.get("security") if isinstance(c.get("security"), dict) else {}
+    ap = s.get("approval") if isinstance(s.get("approval"), dict) else {}
+    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"
+            or not receipt["fallback"].get("present")
+            or receipt["fallback"].get("value") != "builtin")
+        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"])
+        restore(ap, "transport", receipt["transport"], "pushary")
+        restore(ap, "transport_fallback", receipt["fallback"], "builtin")
+    else:
+        if ap.get("transport") == "pushary": ap.pop("transport", None)
+        if ap.get("transport_fallback") == "builtin": ap.pop("transport_fallback", None)
+    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 = c.get("plugins") if isinstance(c.get("plugins"), dict) else {}
+    if receipt:
+        restore_list_member(p, "enabled", receipt["enabled"], "pushary", receipt["pushary_enabled"])
+        restore_container(c, "plugins", receipt["plugins"], p, plugins_changed)
+    else:
+        enabled = p.get("enabled") if isinstance(p.get("enabled"), list) else []
+        enabled = [item for item in enabled if item != "pushary"]
+        if enabled: p["enabled"] = enabled
+        else: p.pop("enabled", None)
+        if p: c["plugins"] = p
+        else: c.pop("plugins", None)
+
+    a = c.get("agent") if isinstance(c.get("agent"), dict) else {}
+    if receipt:
+        restore_list_member(a, "disabled_toolsets", receipt["disabled"], "clarify", receipt["clarify_disabled"])
+        restore_container(c, "agent", receipt["agent"], a, agent_changed)
+    else:
+        disabled = a.get("disabled_toolsets") if isinstance(a.get("disabled_toolsets"), list) else []
+        disabled = [item for item in disabled if item != "clarify"]
+        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")
+
+save_config(c)
+`;
+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 runHermesPythonScript = (python, script, ...args) => {
+  const path = join(tmpdir(), `pushary-hermes-${process.pid}-${Date.now()}.py`);
+  try {
+    writeFileSync(path, script, { encoding: "utf-8", mode: 384 });
+    execFileSync(python, [path, ...args], { env: { ...process.env }, stdio: "pipe", timeout: 15e3 });
+    return true;
+  } catch {
+    return false;
+  } finally {
+    try {
+      rmSync(path, { force: true });
+    } catch {
+    }
+  }
+};
+
+export {
+  isHermesConfigReceipt,
+  HERMES_CONFIG_SCRIPT,
+  resolveHermesPython,
+  runHermesPythonScript
+};

package/dist/{chunk-GKAKAOKC.js → chunk-UXHMWF4H.js}

@@ -82,13 +82,14 @@ var commandDirFor = (sessionId, namespace = "") => join(
   createHash("sha256").update(namespace).digest("hex").slice(0, 16),
   sanitize(sessionId)
 );
-var commandFile = (sessionId, namespace = "") => join(commandDirFor(sessionId, namespace), "command.json");
-var readPendingCommand = (sessionId, namespace = "") => {
+var legacyCommandFile = (sessionId, namespace = "") => join(commandDirFor(sessionId, namespace), "command.json");
+var commandFile = (sessionId, id, namespace = "") => join(commandDirFor(sessionId, namespace), `${createHash("sha256").update(id).digest("hex")}.json`);
+var readCommandFile = (file) => {
   try {
-    const value = JSON.parse(readFileSync(commandFile(sessionId, namespace), "utf-8"));
+    const value = JSON.parse(readFileSync(file, "utf-8"));
     if (typeof value.id !== "string" || typeof value.text !== "string" || typeof value.expiresAtMs !== "number") return null;
     if (value.expiresAtMs <= Date.now()) {
-      unlinkSync(commandFile(sessionId, namespace));
+      unlinkSync(file);
       return null;
     }
     return {
@@ -100,23 +101,68 @@ var readPendingCommand = (sessionId, namespace = "") => {
     return null;
   }
 };
+var readPendingCommandById = (sessionId, id, namespace = "") => {
+  const current = readCommandFile(commandFile(sessionId, id, namespace));
+  if (current?.id === id) return current;
+  const legacy = readCommandFile(legacyCommandFile(sessionId, namespace));
+  return legacy?.id === id ? legacy : null;
+};
+var pruneExpiredCommands = (dir) => {
+  let files;
+  try {
+    files = readdirSync(dir).filter((file) => file.endsWith(".json"));
+  } catch {
+    return [];
+  }
+  return files.flatMap((file) => {
+    const command = readCommandFile(join(dir, file));
+    return command ? [command] : [];
+  });
+};
+var pruneExpiredCommandStore = () => {
+  let namespaces;
+  try {
+    namespaces = readdirSync(COMMAND_DIR, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  for (const namespace of namespaces.filter((entry) => entry.isDirectory())) {
+    const namespaceDir = join(COMMAND_DIR, namespace.name);
+    let sessions;
+    try {
+      sessions = readdirSync(namespaceDir, { withFileTypes: true });
+    } catch {
+      continue;
+    }
+    for (const session of sessions.filter((entry) => entry.isDirectory())) {
+      pruneExpiredCommands(join(namespaceDir, session.name));
+    }
+  }
+};
+var readPendingCommand = (sessionId, namespace = "") => {
+  const commands = pruneExpiredCommands(commandDirFor(sessionId, namespace));
+  return commands.find((command) => !command.delivered && !command.failed) ?? commands[0] ?? null;
+};
 var savePendingCommand = (sessionId, command, namespace = "") => {
   const dir = commandDirFor(sessionId, namespace);
   try {
     mkdirSync(dir, { recursive: true, mode: 448 });
-    writeFileSync(commandFile(sessionId, namespace), JSON.stringify(command), { encoding: "utf-8", mode: 384, flag: "wx" });
+    pruneExpiredCommandStore();
+    if (readPendingCommandById(sessionId, command.id, namespace)) return false;
+    writeFileSync(commandFile(sessionId, command.id, namespace), JSON.stringify(command), { encoding: "utf-8", mode: 384, flag: "wx" });
     return true;
   } catch {
     return false;
   }
 };
 var updatePendingCommand = (sessionId, id, update, namespace = "") => {
-  const command = readPendingCommand(sessionId, namespace);
-  if (!command || command.id !== id) return false;
-  const file = commandFile(sessionId, namespace);
+  const command = readPendingCommandById(sessionId, id, namespace);
+  if (!command) return false;
+  const currentFile = commandFile(sessionId, id, namespace);
+  const file = existsSync(currentFile) ? currentFile : legacyCommandFile(sessionId, namespace);
   const temporary = `${file}.${process.pid}.tmp`;
   try {
-    writeFileSync(temporary, JSON.stringify({ ...command, ...update }), { encoding: "utf-8", mode: 384 });
+    writeFileSync(temporary, JSON.stringify({ ...command, ...update, text: "" }), { encoding: "utf-8", mode: 384 });
     renameSync(temporary, file);
     return true;
   } catch {
@@ -130,9 +176,15 @@ var updatePendingCommand = (sessionId, id, update, namespace = "") => {
 var markPendingCommandDelivered = (sessionId, id, namespace = "") => updatePendingCommand(sessionId, id, { delivered: true, failed: void 0 }, namespace);
 var markPendingCommandFailed = (sessionId, id, namespace = "") => updatePendingCommand(sessionId, id, { delivered: false, failed: true }, namespace);
 var removePendingCommand = (sessionId, id, namespace = "") => {
-  if (readPendingCommand(sessionId, namespace)?.id !== id) return;
+  if (!readPendingCommandById(sessionId, id, namespace)) return;
+  try {
+    unlinkSync(commandFile(sessionId, id, namespace));
+  } catch {
+  }
   try {
-    unlinkSync(commandFile(sessionId, namespace));
+    if (readCommandFile(legacyCommandFile(sessionId, namespace))?.id === id) {
+      unlinkSync(legacyCommandFile(sessionId, namespace));
+    }
   } catch {
   }
 };
@@ -181,6 +233,7 @@ export {
   cancelQuestion,
   sendNotification,
   DEFAULT_SESSION,
+  readPendingCommandById,
   readPendingCommand,
   savePendingCommand,
   markPendingCommandDelivered,

package/dist/{chunk-PZA7G4CN.js → chunk-X4ZUUFKV.js}

@@ -105,6 +105,7 @@ export {
   npmErrorMessage,
   execNpm,
   resolveGlobalBinary,
+  resolvePathBinary,
   resolveBinary,
   resolvePackageVersionFromBinary,
   resolveGlobalPackageVersion,

package/dist/{chunk-L4C2JXJS.js → chunk-X6RXX2NF.js}

@@ -1080,6 +1080,9 @@ var shouldDeferToNativeMode = (permissionMode, toolName, options = {}) => {
   if (permissionMode === "bypassPermissions") return options.deferBypass === true;
   return false;
 };
+var ASKED_IN_EVERY_MODE_TOOLS = ["AskUserQuestion", "ExitPlanMode"];
+var ASKED_IN_EVERY_MODE = new Set(ASKED_IN_EVERY_MODE_TOOLS);
+var isAskedInEveryMode = (toolName) => ASKED_IN_EVERY_MODE.has(toolName);
 var resolveGate = (input) => {
   const { modeState, config, toolName, toolInputs, cwd, repoKey, sessionId } = input;
   if (modeState.kill) return { kind: "kill", reason: KILL_REASON };
@@ -1088,6 +1091,7 @@ var resolveGate = (input) => {
   const autoApproves = verdict === "allow";
   const autoDenies = verdict === "deny";
   if (autoDenies) return { kind: "deny", policy, reason: `Denied by policy for ${policy.tool}` };
+  if (isAskedInEveryMode(toolName)) return { kind: "gate", policy };
   if (isModeStateDegraded(modeState)) {
     if (autoApproves) {
       return survivesDegraded(config, toolName, toolInputs, cwd, repoKey, sessionId) ? { kind: "allow", policy, source: "allowlist" } : { kind: "defer", policy };
@@ -1359,6 +1363,7 @@ export {
   resolvePolicy,
   KILL_REASON,
   shouldDeferToNativeMode,
+  ASKED_IN_EVERY_MODE_TOOLS,
   resolveGate,
   modeStateFromResponse,
   claudePreToolUseOutput,

package/dist/src/index.js

@@ -1,8 +1,9 @@
 import {
   handlePreToolUse
-} from "../chunk-EJT2ER6G.js";
-import "../chunk-ATBKJNWS.js";
-import "../chunk-VZKXBFUA.js";
+} from "../chunk-GSSFSVAQ.js";
+import "../chunk-6EKQZA6R.js";
+import "../chunk-NCVIWGVA.js";
+import "../chunk-3HFK3UXM.js";
 import "../chunk-YHG74UFF.js";
 import {
   fetchModeOverride,
@@ -12,18 +13,18 @@ import {
   handlePostToolUse,
   handleStop,
   reportEvent
-} from "../chunk-4XZCDSNG.js";
+} from "../chunk-GTZLL7F4.js";
 import {
   askUser,
   cancelQuestion,
   waitForAnswer
-} from "../chunk-GKAKAOKC.js";
-import "../chunk-KOPUTJQC.js";
-import "../chunk-DKDDLF5P.js";
-import "../chunk-GMI5QZLG.js";
+} from "../chunk-UXHMWF4H.js";
+import "../chunk-TG3T3M4K.js";
+import "../chunk-DKWM5T3P.js";
+import "../chunk-QA72MKIT.js";
 import "../chunk-BSZYIAZL.js";
 import "../chunk-SAF6HGAA.js";
-import "../chunk-OFRNZWC4.js";
+import "../chunk-IUWRVTQK.js";
 import "../chunk-7QLSKOSU.js";
 import "../chunk-KZERVKTD.js";
 import "../chunk-XX2V4QS5.js";
@@ -33,7 +34,7 @@ import {
 } from "../chunk-2UMNXADU.js";
 import {
   resolvePolicy
-} from "../chunk-L4C2JXJS.js";
+} from "../chunk-X6RXX2NF.js";
 export {
   askUser,
   cancelQuestion,

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushary/agent-hooks",
-  "version": "0.89.9",
+  "version": "0.89.10",
   "description": "Permission hooks for AI coding agents: route tool approvals through Pushary push notifications",
   "keywords": [
     "pushary",