@pushary/agent-hooks 0.99.0 → 1.0.0

package/dist/{chunk-NSFNEDCT.js → chunk-HGEI7SVM.js}

@@ -6,16 +6,16 @@ import {
 } from "./chunk-YKLCWWEI.js";
 import {
   hookOwnerOf
-} from "./chunk-RALVI7OF.js";
+} from "./chunk-2SL5X7UB.js";
 import {
   ensureDaemonRunning
-} from "./chunk-CRFLU455.js";
+} from "./chunk-MSOFZYI3.js";
 import {
   buildTranscriptRecords,
   decodePublicKey,
   generateSessionKey,
   wrapSessionKey
-} from "./chunk-XPPXOKIG.js";
+} from "./chunk-7ZDFVWRR.js";
 import {
   fetchTranscriptRecipients,
   uploadTranscriptRecords
@@ -23,14 +23,14 @@ import {
 import {
   transcriptEnvironmentPreference,
   transcriptsEnabled
-} from "./chunk-ID5FDKDZ.js";
+} from "./chunk-IBU7UU3R.js";
 import {
   codexHome,
   pusharyDir
-} from "./chunk-JBJBVERL.js";
+} from "./chunk-LTPQKBJH.js";
 import {
   readTranscriptPreference
-} from "./chunk-4PBCNVI3.js";
+} from "./chunk-DOYARIYB.js";
 import {
   writeJsonAtomic
 } from "./chunk-4LL6LG5X.js";

package/dist/chunk-HS2KEAFD.js

@@ -0,0 +1,224 @@
+import {
+  addClaudeMcpServer,
+  addPusharyToolPermissions,
+  isPusharyHook,
+  removeClaudeMcpServers
+} from "./chunk-MGI6MLFU.js";
+import {
+  CLAUDE_HOOK_EVENTS,
+  addGeminiMcpServer,
+  removeGeminiMcpServer
+} from "./chunk-2PS3DTHQ.js";
+import {
+  CLAUDE_CODE_AGENT,
+  parseApplyPatchFiles
+} from "./chunk-MDV7ZRAT.js";
+import {
+  guardBinary,
+  holdBudgetOf,
+  registerHookEntry
+} from "./chunk-LTPQKBJH.js";
+import {
+  PHONE_ANSWERED_TOOLS,
+  hookCompatibleProfile,
+  toToolLookup,
+  withHookHoldBudget
+} from "./chunk-TTBRBWAK.js";
+
+// src/compatible-config.ts
+import { homedir } from "os";
+import { isAbsolute, join, resolve } from "path";
+var AGENT_FLAG = "--agent";
+var agentArgument = (profile) => `${AGENT_FLAG}=${profile.agentType}`;
+var profileFromArgv = (argv) => {
+  const prefix = `${AGENT_FLAG}=`;
+  const named = argv.find((argument) => argument.startsWith(prefix));
+  return named ? hookCompatibleProfile(named.slice(prefix.length)) : void 0;
+};
+var activeIdentity = (argv) => {
+  const profile = profileFromArgv(argv);
+  return profile ? { type: profile.agentType, label: profile.label } : CLAUDE_CODE_AGENT;
+};
+var activeHookSource = (argv) => profileFromArgv(argv)?.source ?? "claude";
+var PATCH_INPUT_KEYS = ["command", "patch", "input"];
+var patchedFiles = (toolInput) => [...new Set(PATCH_INPUT_KEYS.flatMap((key) => parseApplyPatchFiles(toolInput[key])))];
+var lookupFor = (profile, input) => {
+  const absolute = (path) => input.cwd && !isAbsolute(path) ? resolve(input.cwd, path) : path;
+  const toolInput = input.tool_input ?? {};
+  const lookup = toToolLookup(profile, input.tool_name ?? "", toolInput, absolute);
+  if (!lookup.pathless) return lookup;
+  const files = patchedFiles(toolInput);
+  return files.length === 1 ? { ...lookup, input: { ...lookup.input, file_path: absolute(files[0]) }, pathless: false } : lookup;
+};
+var normalizeToolCall = (profile, input) => {
+  if (!profile || !input.tool_name) return input;
+  const lookup = lookupFor(profile, input);
+  return { ...input, tool_name: lookup.tool, tool_input: lookup.input };
+};
+var unreadablePathTool = (profile, input) => {
+  if (!profile || !input.tool_name) return void 0;
+  return lookupFor(profile, input).pathless ? input.tool_name : void 0;
+};
+var underHome = (segments, home = homedir()) => join(home, ...segments);
+var compatibleConfigFile = (profile, home) => underHome(profile.configFile, home);
+var compatibleMcpFile = (profile, home) => profile.mcp ? underHome(profile.mcp.file, home) : null;
+var compatibleInstructionsFile = (profile, home) => profile.instructions ? underHome(profile.instructions.file, home) : null;
+var asRecord = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var ensureRecord = (target, key) => {
+  const existing = asRecord(target[key]);
+  if (existing) return existing;
+  const created = {};
+  target[key] = created;
+  return created;
+};
+var descend = (config, keyPath) => keyPath.reduce(ensureRecord, config);
+var findMap = (config, keyPath) => keyPath.reduce((node, key) => node && asRecord(node[key]), config);
+var pruneEmptyMap = (config, keyPath) => {
+  if (keyPath.length === 0) return false;
+  const parent = findMap(config, keyPath.slice(0, -1));
+  const key = keyPath[keyPath.length - 1];
+  const map = asRecord(parent?.[key]);
+  if (!parent || !map || Object.keys(map).length > 0) return false;
+  delete parent[key];
+  return true;
+};
+var aliasesFor = (profile, canonical) => Object.entries(profile.toolAliases).flatMap(([agentName, target]) => target === canonical ? [agentName] : []);
+var carriesPhoneAnswer = (profile, canonical) => profile.wire === "legacy_decision" && PHONE_ANSWERED_TOOLS.has(canonical);
+var translateMatcher = (profile, matcher) => {
+  const spellings = matcher.split("|").filter((canonical) => !carriesPhoneAnswer(profile, canonical)).flatMap((canonical) => [canonical, ...aliasesFor(profile, canonical)]);
+  return [.../* @__PURE__ */ new Set([...spellings, ...profile.extraMatchers])].join("|");
+};
+var TOOL_MATCHED_EVENTS = /* @__PURE__ */ new Set(["PreToolUse", "PostToolUse"]);
+var withoutMatcher = ({ matcher, ...hook }) => hook;
+var compatibleHookEvents = (profile) => CLAUDE_HOOK_EVENTS.filter((hook) => profile.events.includes(hook.event)).map((hook) => {
+  if (!hook.matcher) return hook;
+  if (!TOOL_MATCHED_EVENTS.has(hook.event)) return withoutMatcher(hook);
+  return { ...hook, matcher: translateMatcher(profile, hook.matcher) };
+});
+var WRITTEN = { ok: true };
+var ROOT_KEY = "(root)";
+var dotted = (segments) => segments.join(".") || ROOT_KEY;
+var hooksShapeConflict = (config, profile) => {
+  if (!asRecord(config)) return ROOT_KEY;
+  const walked = [];
+  let node = config;
+  for (const key of profile.hooksKeyPath) {
+    if (node[key] === void 0) return void 0;
+    const nested = asRecord(node[key]);
+    if (!nested) return dotted([...walked, key]);
+    walked.push(key);
+    node = nested;
+  }
+  const clash = CLAUDE_HOOK_EVENTS.find(({ event }) => node[event] !== void 0 && !Array.isArray(node[event]));
+  return clash ? dotted([...walked, clash.event]) : void 0;
+};
+var permissionsShapeConflict = (config) => {
+  if (!asRecord(config)) return ROOT_KEY;
+  if (config.permissions === void 0) return void 0;
+  const permissions = asRecord(config.permissions);
+  if (!permissions) return "permissions";
+  return permissions.allow !== void 0 && !Array.isArray(permissions.allow) ? "permissions.allow" : void 0;
+};
+var addCompatibleToolPermissions = (config) => {
+  const conflictAt = permissionsShapeConflict(config);
+  if (conflictAt) return { ok: false, conflictAt };
+  addPusharyToolPermissions(config);
+  return WRITTEN;
+};
+var entryFor = (profile, definition, resolve2) => ({
+  ...definition.matcher ? { matcher: definition.matcher } : {},
+  hooks: [{
+    type: "command",
+    command: withHookHoldBudget(
+      `${resolve2(definition.binary)} ${agentArgument(profile)}`,
+      holdBudgetOf(definition)
+    ),
+    timeout: definition.timeout
+  }]
+});
+var addCompatibleHooks = (config, profile, binDir) => {
+  const conflictAt = hooksShapeConflict(config, profile);
+  if (conflictAt) return { ok: false, conflictAt };
+  const resolve2 = (name) => guardBinary(binDir ? join(binDir, name) : name);
+  const hooks = descend(config, profile.hooksKeyPath);
+  const supported = new Map(compatibleHookEvents(profile).map((hook) => [hook.event, hook]));
+  for (const known of CLAUDE_HOOK_EVENTS) {
+    const current = Array.isArray(hooks[known.event]) ? hooks[known.event] : [];
+    const definition = supported.get(known.event);
+    if (definition) {
+      hooks[known.event] = registerHookEntry(current, isPusharyHook, entryFor(profile, definition, resolve2));
+      continue;
+    }
+    const others = current.filter((item) => !isPusharyHook(item));
+    if (others.length > 0) hooks[known.event] = others;
+    else delete hooks[known.event];
+  }
+  return WRITTEN;
+};
+var removeCompatibleHooks = (config, profile, scope) => {
+  const hooks = findMap(config, profile.hooksKeyPath);
+  if (!hooks) return false;
+  let changed = false;
+  for (const { event } of CLAUDE_HOOK_EVENTS) {
+    const entries = hooks[event];
+    if (!Array.isArray(entries)) continue;
+    const kept = entries.filter((entry) => !isPusharyHook(entry, scope));
+    if (kept.length === entries.length) continue;
+    if (kept.length === 0) delete hooks[event];
+    else hooks[event] = kept;
+    changed = true;
+  }
+  const pruned = pruneEmptyMap(config, profile.hooksKeyPath);
+  return changed || pruned;
+};
+var hasCompatibleHooks = (config, profile) => {
+  const hooks = findMap(config, profile.hooksKeyPath);
+  if (!hooks) return false;
+  return compatibleHookEvents(profile).some(({ event }) => {
+    const entries = hooks[event];
+    return Array.isArray(entries) && entries.some((entry) => isPusharyHook(entry));
+  });
+};
+var missingCompatibleHookEvents = (config, profile) => {
+  const hooks = findMap(config, profile.hooksKeyPath);
+  return compatibleHookEvents(profile).filter(({ event }) => {
+    const entries = hooks?.[event];
+    return !Array.isArray(entries) || !entries.some((entry) => isPusharyHook(entry));
+  }).map(({ event }) => event);
+};
+var compatiblePermissionRuleFile = (profile, home) => profile.permissionRuleFile ? underHome(profile.permissionRuleFile, home) : null;
+var addCompatibleMcpServer = (config, profile, apiKey) => {
+  if (!profile.mcp) return;
+  if (profile.mcp.shape === "gemini_http") {
+    addGeminiMcpServer(config, apiKey);
+    return;
+  }
+  addClaudeMcpServer(config, apiKey);
+  if (!profile.mcp.trusted) return;
+  const server = asRecord(asRecord(config.mcpServers)?.pushary);
+  if (server) server.trust = true;
+};
+var removeCompatibleMcpServer = (config, profile) => {
+  if (!profile.mcp) return false;
+  return profile.mcp.shape === "gemini_http" ? removeGeminiMcpServer(config) : removeClaudeMcpServers(config);
+};
+
+export {
+  profileFromArgv,
+  activeIdentity,
+  activeHookSource,
+  normalizeToolCall,
+  unreadablePathTool,
+  compatibleConfigFile,
+  compatibleMcpFile,
+  compatibleInstructionsFile,
+  compatibleHookEvents,
+  addCompatibleToolPermissions,
+  addCompatibleHooks,
+  removeCompatibleHooks,
+  hasCompatibleHooks,
+  missingCompatibleHookEvents,
+  compatiblePermissionRuleFile,
+  addCompatibleMcpServer,
+  removeCompatibleMcpServer
+};

package/dist/{chunk-T3JZZUAR.js → chunk-I3TWY7GH.js}

@@ -1,40 +1,40 @@
+import {
+  activeIdentity
+} from "./chunk-HS2KEAFD.js";
 import {
   blockedActionFingerprint,
   defersToNativeMode,
   forgetBlockedActionHint,
   hasBlockedActionHint,
   recordBlockedActionHint
-} from "./chunk-6KLCP7VF.js";
+} from "./chunk-3C4ERARU.js";
 import {
   isGatingMoment,
   recordKeylessMoment
-} from "./chunk-XOOWC62T.js";
+} from "./chunk-DUOG74E7.js";
 import {
   denyReasonFrom,
   isDeferAnswer
 } from "./chunk-YHG74UFF.js";
 import {
-  CLAUDE_CODE_AGENT,
   DEFAULT_SESSION,
+  UNNAMED_ACTION,
+  deriveAction,
+  deriveActionBody,
+  deriveBlocker,
+  deriveToolTarget,
+  describeToolCall,
   fetchModeState,
   getPolicy,
+  permissionDeniedAction,
   readLastPrompt,
   readLastUserPrompt,
   repoKeyFor,
   reportEvent,
+  scopePathFor,
   settleQuestionsForToolUse,
   throttlePass
-} from "./chunk-64WARXGV.js";
-import {
-  UNNAMED_ACTION,
-  deriveAction,
-  deriveActionBody,
-  deriveBlocker,
-  deriveToolTarget,
-  describeToolCall,
-  permissionDeniedAction,
-  scopePathFor
-} from "./chunk-A76GNRIK.js";
+} from "./chunk-MDV7ZRAT.js";
 import {
   DECISION_STOP_REASON,
   askUser,
@@ -49,7 +49,7 @@ import {
 } from "./chunk-LGXUGYUH.js";
 import {
   getMachineId
-} from "./chunk-562UJ2DA.js";
+} from "./chunk-7WMFPYR5.js";
 import {
   getApiKey,
   getBaseUrl
@@ -73,7 +73,7 @@ import {
   parseAgentQuestions,
   resolveGate,
   stoppedOutput
-} from "./chunk-OUAE3GKO.js";
+} from "./chunk-TTBRBWAK.js";
 
 // src/decision-episode.ts
 var EPISODE_PATH = "/api/agent/decision-episode";
@@ -102,6 +102,8 @@ import { basename, join } from "path";
 import { tmpdir } from "os";
 import { existsSync, writeFileSync } from "fs";
 var START_MS = Date.now();
+var ACTIVE_AGENT = activeIdentity(process.argv);
+var agentNameIn = (projectName) => `${ACTIVE_AGENT.label} - ${projectName}`;
 var allow = (reason) => claudePreToolUseOutput("allow", reason);
 var deny = (reason) => claudePreToolUseOutput("deny", reason);
 var allowWithInput = (updatedInput) => claudePreToolUseOutput("allow", void 0, updatedInput);
@@ -122,7 +124,7 @@ var handlePushOnly = async (apiKey, description, projectName, timeoutSeconds, ti
       question: `Allow ${description || UNNAMED_ACTION}?`,
       type: "confirm",
       context: `Agent wants to run this in ${projectName}`,
-      agentName: `Claude Code - ${projectName}`,
+      agentName: agentNameIn(projectName),
       sessionId,
       machineId,
       toolName,
@@ -167,7 +169,7 @@ var handlePushFirst = async (apiKey, description, projectName, pushFirstSeconds,
       question: `Allow ${description || UNNAMED_ACTION}?`,
       type: "confirm",
       context: `Agent wants to run this in ${projectName}`,
-      agentName: `Claude Code - ${projectName}`,
+      agentName: agentNameIn(projectName),
       sessionId,
       machineId,
       toolName,
@@ -195,7 +197,7 @@ var handleNotifyOnly = async (apiKey, description, projectName, sessionId, machi
     await sendNotification(apiKey, {
       title: "Agent needs approval",
       body: description,
-      agentName: `Claude Code - ${projectName}`,
+      agentName: agentNameIn(projectName),
       sessionId,
       machineId
     });
@@ -203,7 +205,6 @@ var handleNotifyOnly = async (apiKey, description, projectName, sessionId, machi
   }
   return ask();
 };
-var CLAUDE_AGENT_TYPE = "claude_code";
 var emitDecisionEpisode = (apiKey, input, toolPolicy, machineId, toolTarget, decision, result) => {
   const verdict = result?.hookSpecificOutput?.permissionDecision;
   const outcome = verdict === "allow" ? "approve" : verdict === "deny" ? "deny" : null;
@@ -215,7 +216,7 @@ var emitDecisionEpisode = (apiKey, input, toolPolicy, machineId, toolTarget, dec
     commandOrPath,
     intent: decision.intent,
     toolTarget,
-    agentType: CLAUDE_AGENT_TYPE,
+    agentType: ACTIVE_AGENT.type,
     matchedPattern: toolPolicy.tool,
     policyMode: toolPolicy.mode,
     timeoutSeconds: toolPolicy.timeoutSeconds,
@@ -327,7 +328,7 @@ var askAsOneCard = async (apiKey, input, parsed, projectName, deadline) => {
       options: [...only.labels],
       questions: parsed.map(withoutLabels),
       context: questionContext(only, 0, 1, projectName),
-      agentName: `Claude Code - ${projectName}`,
+      agentName: agentNameIn(projectName),
       sessionId: input.session_id,
       machineId: getMachineId(),
       toolName: "AskUserQuestion",
@@ -357,7 +358,7 @@ var askQuestionByQuestion = async (apiKey, input, parsed, projectName, deadline)
         options: [...question.labels],
         questions: [withoutLabels(question)],
         context: questionContext(question, index, parsed.length, projectName),
-        agentName: `Claude Code - ${projectName}`,
+        agentName: agentNameIn(projectName),
         sessionId: input.session_id,
         machineId: getMachineId(),
         toolName: "AskUserQuestion",
@@ -409,7 +410,7 @@ var handleExitPlanMode = async (apiKey, input) => {
       type: "select",
       options: [PLAN_APPROVE, PLAN_KEEP_PLANNING],
       context: `Your agent finished planning in ${projectName} and is waiting to start.`,
-      agentName: `Claude Code - ${projectName}`,
+      agentName: agentNameIn(projectName),
       sessionId: input.session_id,
       machineId: getMachineId(),
       toolName: "ExitPlanMode",
@@ -511,7 +512,7 @@ var handlePreToolUse = async (input) => {
   }
   try {
     const modeState = await fetchModeState(apiKey, input.session_id);
-    const policy = await getPolicy(apiKey, modeState.policyVersion, "claude_code", true, input.session_id);
+    const policy = await getPolicy(apiKey, modeState.policyVersion, ACTIVE_AGENT.type, true, input.session_id);
     const verdict = resolveGate(claudeGateInput(modeState, policy, input));
     if (verdict.kind === "kill") return halted(verdict.reason);
     if (verdict.kind === "deny") return deny(verdict.reason);
@@ -563,7 +564,7 @@ var handlePermissionRequest = async (input) => {
   }
   try {
     const modeState = await fetchModeState(apiKey, input.session_id);
-    const policy = await getPolicy(apiKey, modeState.policyVersion, "claude_code", true, input.session_id);
+    const policy = await getPolicy(apiKey, modeState.policyVersion, ACTIVE_AGENT.type, true, input.session_id);
     const verdict = resolveGate(claudeGateInput(modeState, policy, input));
     switch (verdict.kind) {
       case "kill":
@@ -588,8 +589,8 @@ var reportPermissionDenied = (input) => reportEvent({
   event: "permission_denied",
   occurredAt: (/* @__PURE__ */ new Date()).toISOString(),
   toolUseId: input.tool_use_id,
-  agentType: CLAUDE_CODE_AGENT.type,
-  agentName: `${CLAUDE_CODE_AGENT.label} - ${basename(input.cwd ?? process.cwd())}`,
+  agentType: ACTIVE_AGENT.type,
+  agentName: agentNameIn(basename(input.cwd ?? process.cwd())),
   action: permissionDeniedAction(input.tool_name),
   sessionId: input.session_id
   // Side report, not a command carrier. Without timeoutMs this takes the phone's
@@ -609,7 +610,7 @@ var notifyPermissionDenied = async (apiKey, input) => {
   await sendNotification(apiKey, {
     title: `Auto mode blocked ${input.tool_name}`,
     body: `Your agent was denied ${input.tool_name} in ${projectName}.`,
-    agentName: `Claude Code - ${projectName}`,
+    agentName: agentNameIn(projectName),
     sessionId: input.session_id
   }, 4e3).catch(() => void 0);
 };

package/dist/{chunk-ID5FDKDZ.js → chunk-IBU7UU3R.js}

@@ -1,6 +1,6 @@
 import {
   readTranscriptPreference
-} from "./chunk-4PBCNVI3.js";
+} from "./chunk-DOYARIYB.js";
 
 // src/transcript-setting.ts
 var transcriptEnvironmentPreference = () => {

package/dist/{chunk-O3LZQEQP.js → chunk-IWZG2Y4Z.js}

@@ -1,6 +1,6 @@
 import {
   registerTranscript
-} from "./chunk-NSFNEDCT.js";
+} from "./chunk-HGEI7SVM.js";
 
 // src/admission.ts
 import { readFileSync } from "fs";

package/dist/{chunk-WGV3VY7O.js → chunk-IYA3NCZG.js}

@@ -2,10 +2,10 @@ import {
   resolveBinary,
   resolveGlobalPackageVersion,
   resolvePackageVersionFromBinary
-} from "./chunk-JBJBVERL.js";
+} from "./chunk-LTPQKBJH.js";
 import {
   MANAGED_PROVIDERS
-} from "./chunk-OUAE3GKO.js";
+} from "./chunk-TTBRBWAK.js";
 
 // src/live-capabilities.ts
 var CLAUDE_BRIDGE_CAPABILITY = "claude-bridge";

package/dist/{chunk-JBJBVERL.js → chunk-LTPQKBJH.js}

@@ -2,7 +2,7 @@ import {
   HOOK_BUDGETS,
   HOOK_LOCATOR_BINARY,
   withHookHoldBudget
-} from "./chunk-OUAE3GKO.js";
+} from "./chunk-TTBRBWAK.js";
 
 // src/npm.ts
 import { execFileSync, execSync } from "child_process";