@pushary/agent-hooks 1.9.7 → 1.9.8

package/dist/{chunk-MZPXVH4A.js → chunk-KHNFLYJO.js}

@@ -1,34 +1,200 @@
-import {
-  addClaudeMcpServer,
-  addPusharyToolPermissions,
-  isPusharyHook,
-  removeClaudeMcpServers
-} from "./chunk-ANEAA37E.js";
 import {
   CLAUDE_HOOK_EVENTS,
   addGeminiMcpServer,
-  removeGeminiMcpServer
-} from "./chunk-JCWZ23MJ.js";
+  removeGeminiMcpServer,
+  supportedClaudeEvents
+} from "./chunk-3I6IVOZV.js";
 import {
   CLAUDE_CODE_AGENT,
   parseApplyPatchFiles
-} from "./chunk-QFEM7R6T.js";
+} from "./chunk-KRCR2CRQ.js";
 import {
   guardBinary,
   holdBudgetOf,
+  isProtectedByScope,
   registerHookEntry
-} from "./chunk-ZUTU43FT.js";
+} from "./chunk-ZBHUHJG6.js";
 import {
+  HOOK_LOCATOR_BINARY,
   PHONE_ANSWERED_TOOLS,
   hookCompatibleProfile,
   hookCompatibleProfileBySource,
   toToolLookup,
   withHookHoldBudget
-} from "./chunk-QR6VE5ME.js";
+} from "./chunk-I5IJRMNV.js";
+
+// src/claude-config.ts
+import { join } from "path";
+import { isDeepStrictEqual } from "util";
+var PUSHARY_MCP_URL = "https://pushary.com/api/mcp/mcp";
+var PUSHARY_PERMISSION_RULE = "mcp__pushary__*";
+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 isPusharyPermission = (rule) => typeof rule === "string" && (rule.includes("pushary") || rule.includes("MCP(pushary"));
+var HOOK_BINARIES = /* @__PURE__ */ new Set([
+  ...CLAUDE_HOOK_EVENTS.map((hook) => hook.binary),
+  HOOK_LOCATOR_BINARY
+]);
+var namesPusharyBinary = (command) => command.split(/[\s/\\"']+/).some((segment) => HOOK_BINARIES.has(segment.replace(/\.(cmd|exe)$/i, "")));
+var isPusharyHook = (entry2, scope) => {
+  const hooks = asRecord(entry2)?.hooks;
+  if (!Array.isArray(hooks)) return false;
+  return hooks.some((hook) => {
+    const command = String(asRecord(hook)?.command ?? "");
+    if (isProtectedByScope(command, scope)) return false;
+    return namesPusharyBinary(command);
+  });
+};
+var pusharyMcpServer = (apiKey) => ({
+  type: "http",
+  url: PUSHARY_MCP_URL,
+  headers: { Authorization: `Bearer ${apiKey}` }
+});
+var addClaudeMcpServer = (config, apiKey) => {
+  const mcpServers = ensureRecord(config, "mcpServers");
+  mcpServers.pushary = pusharyMcpServer(apiKey);
+};
+var isClaudeMcpSnapshot = (value) => {
+  if (!value || typeof value !== "object" || Array.isArray(value)) return false;
+  const snapshot = value;
+  return typeof snapshot.hadMcpServers === "boolean" && typeof snapshot.mcpServersWasRecord === "boolean" && (!snapshot.hadMcpServers || snapshot.mcpServersWasRecord || Object.hasOwn(snapshot, "mcpServers")) && typeof snapshot.hadPushary === "boolean" && (!snapshot.hadPushary || Object.hasOwn(snapshot, "pushary")) && (!Object.hasOwn(snapshot, "installedPushary") || asRecord(snapshot.installedPushary)?.type === "http" && asRecord(snapshot.installedPushary)?.url === PUSHARY_MCP_URL);
+};
+var captureClaudeMcpServer = (config, apiKey) => {
+  const mcpServers = asRecord(config.mcpServers);
+  const hadMcpServers = Object.hasOwn(config, "mcpServers");
+  return {
+    hadMcpServers,
+    mcpServersWasRecord: Boolean(mcpServers),
+    ...hadMcpServers && !mcpServers ? { mcpServers: structuredClone(config.mcpServers) } : {},
+    hadPushary: Boolean(mcpServers && Object.hasOwn(mcpServers, "pushary")),
+    ...mcpServers && Object.hasOwn(mcpServers, "pushary") ? { pushary: structuredClone(mcpServers.pushary) } : {},
+    ...apiKey ? { installedPushary: pusharyMcpServer(apiKey) } : {}
+  };
+};
+var updateClaudeMcpSnapshot = (snapshot, apiKey) => ({
+  ...snapshot,
+  installedPushary: pusharyMcpServer(apiKey)
+});
+var restoreClaudeMcpServer = (config, snapshot) => {
+  const mcpServers = asRecord(config.mcpServers);
+  const current = asRecord(mcpServers?.pushary);
+  if (Object.hasOwn(snapshot, "installedPushary")) {
+    if (!isDeepStrictEqual(mcpServers?.pushary, snapshot.installedPushary)) return false;
+  } else if (current?.type !== "http" || current.url !== PUSHARY_MCP_URL) {
+    return false;
+  }
+  if (!snapshot.mcpServersWasRecord) {
+    if (Object.keys(mcpServers).length === 1) {
+      if (snapshot.hadMcpServers) config.mcpServers = structuredClone(snapshot.mcpServers);
+      else delete config.mcpServers;
+    } else {
+      delete mcpServers.pushary;
+    }
+  } else if (snapshot.hadPushary) {
+    mcpServers.pushary = structuredClone(snapshot.pushary);
+  } else {
+    delete mcpServers.pushary;
+    if (!snapshot.hadMcpServers && Object.keys(mcpServers).length === 0) delete config.mcpServers;
+  }
+  return true;
+};
+var removeClaudeMcpServers = (config) => {
+  let changed = false;
+  const removeFrom = (target) => {
+    const mcpServers = asRecord(target.mcpServers);
+    if (!mcpServers?.pushary) return;
+    delete mcpServers.pushary;
+    if (Object.keys(mcpServers).length === 0) delete target.mcpServers;
+    changed = true;
+  };
+  removeFrom(config);
+  const projects = asRecord(config.projects);
+  if (projects) {
+    for (const project of Object.values(projects)) {
+      const projectConfig = asRecord(project);
+      if (projectConfig) removeFrom(projectConfig);
+    }
+  }
+  return changed;
+};
+var removePusharyToolPermissions = (settings) => {
+  const permissions = asRecord(settings.permissions);
+  if (!permissions || !Array.isArray(permissions.allow)) return false;
+  const filtered = permissions.allow.filter((rule) => !isPusharyPermission(rule));
+  if (filtered.length === permissions.allow.length) return false;
+  if (filtered.length === 0) delete permissions.allow;
+  else permissions.allow = filtered;
+  if (Object.keys(permissions).length === 0) delete settings.permissions;
+  return true;
+};
+var addPusharyToolPermissions = (settings) => {
+  const permissions = ensureRecord(settings, "permissions");
+  const allow = Array.isArray(permissions.allow) ? permissions.allow : [];
+  const filtered = allow.filter((rule) => !isPusharyPermission(rule));
+  if (!filtered.includes(PUSHARY_PERMISSION_RULE)) {
+    filtered.push(PUSHARY_PERMISSION_RULE);
+  }
+  permissions.allow = filtered;
+};
+var addPusharyHooks = (settings, binDir, version = null) => {
+  const resolve2 = (name) => guardBinary(binDir ? join(binDir, name) : name);
+  const hooks = ensureRecord(settings, "hooks");
+  const supported = new Map(supportedClaudeEvents(version).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, entry(definition, resolve2));
+      continue;
+    }
+    const others = current.filter((item) => !isPusharyHook(item));
+    if (others.length > 0) {
+      hooks[known.event] = others;
+    } else {
+      delete hooks[known.event];
+    }
+  }
+};
+var entry = (definition, resolve2) => ({
+  ...definition.matcher ? { matcher: definition.matcher } : {},
+  hooks: [{
+    type: "command",
+    command: withHookHoldBudget(resolve2(definition.binary), holdBudgetOf(definition)),
+    timeout: definition.timeout
+  }]
+});
+var removePusharySettings = (settings, scope) => {
+  let changed = scope?.keepMcpServer === true ? false : removeClaudeMcpServers(settings);
+  if (scope?.keepMcpServer !== true && removePusharyToolPermissions(settings)) changed = true;
+  const hooks = asRecord(settings.hooks);
+  if (hooks) {
+    for (const { event: key } of CLAUDE_HOOK_EVENTS) {
+      const entries = hooks[key];
+      if (!Array.isArray(entries)) continue;
+      const filtered = entries.filter((entry2) => !isPusharyHook(entry2, scope));
+      if (filtered.length !== entries.length) {
+        if (filtered.length === 0) {
+          delete hooks[key];
+        } else {
+          hooks[key] = filtered;
+        }
+        changed = true;
+      }
+    }
+    if (Object.keys(hooks).length === 0) delete settings.hooks;
+  }
+  return changed;
+};
 
 // src/compatible-config.ts
 import { homedir } from "os";
-import { isAbsolute, join, resolve } from "path";
+import { isAbsolute, join as join2, resolve } from "path";
 var AGENT_FLAG = "--agent";
 var SOURCE_FLAG = "--source";
 var agentArgument = (profile) => `${AGENT_FLAG}=${profile.agentType}`;
@@ -74,25 +240,25 @@ var normalizeToolCall = (profile, input) => {
   const lookup = lookupFor(profile, input);
   return { ...input, tool_name: lookup.tool, tool_input: lookup.input };
 };
-var underHome = (segments, home = homedir()) => join(home, ...segments);
+var underHome = (segments, home = homedir()) => join2(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]);
+var asRecord2 = (value) => value && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var ensureRecord2 = (target, key) => {
+  const existing = asRecord2(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 descend = (config, keyPath) => keyPath.reduce(ensureRecord2, config);
+var findMap = (config, keyPath) => keyPath.reduce((node, key) => node && asRecord2(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]);
+  const map = asRecord2(parent?.[key]);
   if (!parent || !map || Object.keys(map).length > 0) return false;
   delete parent[key];
   return true;
@@ -114,12 +280,12 @@ 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;
+  if (!asRecord2(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]);
+    const nested = asRecord2(node[key]);
     if (!nested) return dotted([...walked, key]);
     walked.push(key);
     node = nested;
@@ -128,9 +294,9 @@ var hooksShapeConflict = (config, profile) => {
   return clash ? dotted([...walked, clash.event]) : void 0;
 };
 var permissionsShapeConflict = (config) => {
-  if (!asRecord(config)) return ROOT_KEY;
+  if (!asRecord2(config)) return ROOT_KEY;
   if (config.permissions === void 0) return void 0;
-  const permissions = asRecord(config.permissions);
+  const permissions = asRecord2(config.permissions);
   if (!permissions) return "permissions";
   return permissions.allow !== void 0 && !Array.isArray(permissions.allow) ? "permissions.allow" : void 0;
 };
@@ -154,7 +320,7 @@ var entryFor = (profile, definition, resolve2) => ({
 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 resolve2 = (name) => guardBinary(binDir ? join2(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) {
@@ -177,7 +343,7 @@ var removeCompatibleHooks = (config, profile, scope) => {
   for (const { event } of CLAUDE_HOOK_EVENTS) {
     const entries = hooks[event];
     if (!Array.isArray(entries)) continue;
-    const kept = entries.filter((entry) => !isPusharyHook(entry, scope));
+    const kept = entries.filter((entry2) => !isPusharyHook(entry2, scope));
     if (kept.length === entries.length) continue;
     if (kept.length === 0) delete hooks[event];
     else hooks[event] = kept;
@@ -191,14 +357,14 @@ var hasCompatibleHooks = (config, profile) => {
   if (!hooks) return false;
   return compatibleHookEvents(profile).some(({ event }) => {
     const entries = hooks[event];
-    return Array.isArray(entries) && entries.some((entry) => isPusharyHook(entry));
+    return Array.isArray(entries) && entries.some((entry2) => isPusharyHook(entry2));
   });
 };
 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));
+    return !Array.isArray(entries) || !entries.some((entry2) => isPusharyHook(entry2));
   }).map(({ event }) => event);
 };
 var compatiblePermissionRuleFile = (profile, home) => profile.permissionRuleFile ? underHome(profile.permissionRuleFile, home) : null;
@@ -210,7 +376,7 @@ var addCompatibleMcpServer = (config, profile, apiKey) => {
   }
   addClaudeMcpServer(config, apiKey);
   if (!profile.mcp.trusted) return;
-  const server = asRecord(asRecord(config.mcpServers)?.pushary);
+  const server = asRecord2(asRecord2(config.mcpServers)?.pushary);
   if (server) server.trust = true;
 };
 var removeCompatibleMcpServer = (config, profile) => {
@@ -219,6 +385,16 @@ var removeCompatibleMcpServer = (config, profile) => {
 };
 
 export {
+  addClaudeMcpServer,
+  isClaudeMcpSnapshot,
+  captureClaudeMcpServer,
+  updateClaudeMcpSnapshot,
+  restoreClaudeMcpServer,
+  removeClaudeMcpServers,
+  removePusharyToolPermissions,
+  addPusharyToolPermissions,
+  addPusharyHooks,
+  removePusharySettings,
   profileFromArgv,
   activeIdentity,
   activeHookSource,

package/dist/{chunk-QFEM7R6T.js → chunk-KRCR2CRQ.js}

@@ -14,36 +14,36 @@ import {
   IDLE_PROMPT_NOTIFICATION,
   NOTIFICATION_PUSH_TYPES,
   POSTTOOLUSE_MIRROR_ONLY_TOOLS
-} from "./chunk-6DJTDHBI.js";
+} from "./chunk-CD47ZFFZ.js";
 import {
   cancelQuestion,
   isPolicyConfig,
   sendNotification,
   waitForAnswer
-} from "./chunk-D6S5EKXA.js";
+} from "./chunk-2VZAALEJ.js";
 import {
   clientErrorKindOf,
   reportClientError
-} from "./chunk-AVNKVF7N.js";
+} from "./chunk-DKMD6AWR.js";
 import {
   withRetry
-} from "./chunk-L76HTPU6.js";
+} from "./chunk-MKTJEXZ3.js";
 import {
   getMachineId
-} from "./chunk-KYO45G5L.js";
+} from "./chunk-DUZVXBBU.js";
 import {
   reportedInstallSource
-} from "./chunk-4D2AYNSE.js";
+} from "./chunk-FQ2GORVG.js";
 import {
   canonicalJson
-} from "./chunk-ZUTU43FT.js";
+} from "./chunk-ZBHUHJG6.js";
 import {
   writeFileAtomic
 } from "./chunk-T7E75EKA.js";
 import {
   getApiKey,
   getBaseUrl
-} from "./chunk-Z6HPS67T.js";
+} from "./chunk-5QUPKDI5.js";
 import {
   ACTION_BODY_MAX,
   AGENT_LABELS_BY_TYPE,
@@ -70,7 +70,7 @@ import {
   resolvePolicy,
   toToolLookup,
   truncateLine
-} from "./chunk-QR6VE5ME.js";
+} from "./chunk-I5IJRMNV.js";
 
 // src/policy.ts
 import { createHash } from "crypto";

package/dist/{chunk-VXRXFU6Q.js → chunk-LKLVTG3V.js}

@@ -4,14 +4,14 @@ import {
 } from "./chunk-XHKBHWLX.js";
 import {
   readControlMode
-} from "./chunk-ADSQDYYG.js";
+} from "./chunk-N4QSPI3B.js";
 import {
   getMachineId
-} from "./chunk-KYO45G5L.js";
+} from "./chunk-DUZVXBBU.js";
 import {
   pusharyDir,
   resolveGlobalBinary
-} from "./chunk-ZUTU43FT.js";
+} from "./chunk-ZBHUHJG6.js";
 import {
   readJsonSafe,
   writeFileAtomic,
@@ -20,14 +20,14 @@ import {
 } from "./chunk-T7E75EKA.js";
 import {
   getApiKey
-} from "./chunk-Z6HPS67T.js";
+} from "./chunk-5QUPKDI5.js";
 import {
   CLI_PACKAGE_NAMES,
   cmdShimTarget,
   getPackageVersion,
   globalPackageFolder,
   globalRootFor
-} from "./chunk-QR6VE5ME.js";
+} from "./chunk-I5IJRMNV.js";
 
 // src/daemon-lifecycle.ts
 import { dirname, join, win32 as win32Path } from "path";
@@ -720,8 +720,9 @@ var stopDaemonRunning = async (options = {}) => {
   safeUnlink(lockPath(dir));
   return { kind: "stopped" };
 };
+var DAEMON_LOGIN_REASONS = ["key_rejected", "plan_inactive", "key_missing", "mac_signed_out"];
 var needsLoginPath = (dir) => join(dir, "daemon-needs-login.json");
-var isLoginReason = (value) => value === "key_rejected" || value === "plan_inactive";
+var isLoginReason = (value) => DAEMON_LOGIN_REASONS.includes(value);
 var parseDaemonNeedsLogin = (value) => {
   if (typeof value !== "object" || value === null) return null;
   const record = value;
@@ -751,7 +752,13 @@ var clearDaemonNeedsLogin = (options = {}) => {
   safeUnlink(path);
   return true;
 };
-var describeDaemonLoginBlock = (record) => record.reason === "key_rejected" ? `this machine's key was rejected at ${record.at}; run \`pushary login\` to sign in again` : `this workspace had no active plan at ${record.at}; pick one at pushary.com/dashboard/settings?tab=billing, then run \`pushary login\``;
+var DAEMON_LOGIN_BLOCK_DESCRIPTIONS = {
+  key_rejected: (at) => `this machine's key was rejected at ${at}; run \`pushary login\` to sign in again`,
+  plan_inactive: (at) => `this workspace had no active plan at ${at}; pick one at pushary.com/dashboard/settings?tab=billing, then run \`pushary login\``,
+  key_missing: (at) => `this machine had no key at ${at}; run \`pushary login\` to sign in again`,
+  mac_signed_out: (at) => `the key this machine shared with the Pushary Mac app was signed out on this Mac at ${at}; run \`pushary login\` to sign in again`
+};
+var describeDaemonLoginBlock = (record) => DAEMON_LOGIN_BLOCK_DESCRIPTIONS[record.reason](record.at);
 var recoverDaemonAfterLogin = (options = {}) => {
   const cleared = clearDaemonNeedsLogin(options);
   if (!cleared || readControlMode(join(options.dir ?? pusharyDir(), "config.json")) === "off" || !hasDaemonServiceDefinition(options)) {

package/dist/{chunk-KFKL3FHS.js → chunk-LWOO567I.js}

@@ -1,6 +1,6 @@
 import {
   pusharyFetch
-} from "./chunk-JXISQ7DT.js";
+} from "./chunk-TCQ43LSG.js";
 import {
   NetworkError
 } from "./chunk-7QLSKOSU.js";
@@ -9,11 +9,11 @@ import {
 } from "./chunk-KZERVKTD.js";
 import {
   getBaseUrl
-} from "./chunk-Z6HPS67T.js";
+} from "./chunk-5QUPKDI5.js";
 import {
   isValidApiKey,
   normalizeKeyScope
-} from "./chunk-QR6VE5ME.js";
+} from "./chunk-I5IJRMNV.js";
 
 // src/session.ts
 var samePusharyAccount = (left, right) => left.kind === "ok" && right.kind === "ok" && left.identity.workspaceId !== "" && left.identity.workspaceId === right.identity.workspaceId && left.identity.siteId === right.identity.siteId;
@@ -167,6 +167,7 @@ var describeKeyCheck = (check, baseUrl = getBaseUrl()) => {
 
 export {
   samePusharyAccount,
+  absoluteUrl,
   checkApiKey,
   keyCheckFromResponse,
   describeKeyCheck

package/dist/{chunk-HPRZJKRO.js → chunk-M6BZZFVQ.js}

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

package/dist/{chunk-X5NXPCIC.js → chunk-MFF3ONG5.js}

@@ -1,10 +1,10 @@
 import {
   guardedArgv
-} from "./chunk-ZUTU43FT.js";
+} from "./chunk-ZBHUHJG6.js";
 import {
   HOOK_BUDGETS,
   OPENCODE_APPROVAL_EVENT
-} from "./chunk-QR6VE5ME.js";
+} from "./chunk-I5IJRMNV.js";
 
 // src/opencode-plugin.ts
 var OPENCODE_PLUGIN_MARKER = "pushary-opencode-plugin w1";
@@ -301,6 +301,19 @@ var openCodePluginModule = () => ({
   }
 });
 var renderOpenCodePlugin = (module, argv) => module.source.replace(module.placeholder, JSON.stringify(argv));
+var COMMAND_LINE = /^const COMMAND = (.*)$/m;
+var isArgv = (value) => Array.isArray(value) && value.every((item) => typeof item === "string");
+var openCodePluginArgv = (contents) => {
+  if (!isOpenCodePluginOurs(contents)) return null;
+  const line = contents.match(COMMAND_LINE)?.[1];
+  if (line === void 0) return null;
+  try {
+    const parsed = JSON.parse(line);
+    return isArgv(parsed) ? parsed : null;
+  } catch {
+    return null;
+  }
+};
 var isOpenCodePluginOurs = (contents) => contents.includes(OPENCODE_PLUGIN_MARKER);
 
 // src/opencode-config.ts
@@ -366,6 +379,7 @@ export {
   OPENCODE_PLUGIN_PLACEHOLDER,
   OPENCODE_PLUGIN_SIBLING,
   OPENCODE_PLUGIN_SIBLING_CONTENTS,
+  openCodePluginArgv,
   isOpenCodePluginOurs,
   OPENCODE_HOOK_BINARY,
   openCodeHookArgv,

package/dist/{chunk-H7MMU64M.js → chunk-MGRFDGWU.js}

@@ -8,10 +8,10 @@ import {
   codexHooksJsonIn,
   isPusharyCodexCommand,
   resolvePathBinary
-} from "./chunk-ZUTU43FT.js";
+} from "./chunk-ZBHUHJG6.js";
 import {
   getPackageVersion
-} from "./chunk-QR6VE5ME.js";
+} from "./chunk-I5IJRMNV.js";
 
 // src/codex-app-server.ts
 import { existsSync, realpathSync } from "fs";

package/dist/{chunk-L76HTPU6.js → chunk-MKTJEXZ3.js}

@@ -1,12 +1,12 @@
 import {
   keyCheckFromResponse
-} from "./chunk-KFKL3FHS.js";
+} from "./chunk-LWOO567I.js";
 import {
   installNetworkDefaults
-} from "./chunk-JXISQ7DT.js";
+} from "./chunk-TCQ43LSG.js";
 import {
   getBaseUrl
-} from "./chunk-Z6HPS67T.js";
+} from "./chunk-5QUPKDI5.js";
 
 // src/retry.ts
 var isRetryable = (err) => {

package/dist/{chunk-NIBFSARF.js → chunk-MXHTGVFZ.js}

@@ -1,28 +1,36 @@
+import {
+  agentHookOwner,
+  macAppBridgeAvailable,
+  openCodePluginOwner
+} from "./chunk-3Z3A37WD.js";
 import {
   ensureCodexTrustsPusharyHooks
-} from "./chunk-H7MMU64M.js";
+} from "./chunk-MGRFDGWU.js";
 import {
   OPENCODE_HOOK_BINARY,
   installOpenCodePlugin,
   openCodeHookArgv,
   openCodePluginDir,
   openCodeWired
-} from "./chunk-X5NXPCIC.js";
+} from "./chunk-MFF3ONG5.js";
 import {
   addClaudeMcpServer,
   addPusharyHooks,
   addPusharyToolPermissions
-} from "./chunk-ANEAA37E.js";
+} from "./chunk-KHNFLYJO.js";
 import {
   detectClaudeVersion
 } from "./chunk-RIVNNBEK.js";
+import {
+  planHooks
+} from "./chunk-YIG2R3BJ.js";
 import {
   claudeUnprovenHolds,
   claudeWired,
   codexUnprovenHolds,
   codexWired,
   geminiWired
-} from "./chunk-4YO4T5FV.js";
+} from "./chunk-2QGYMY7A.js";
 import {
   CLAUDE_HOOK_BINARY,
   CLAUDE_HOOK_EVENTS,
@@ -33,7 +41,7 @@ import {
   needsReregistration,
   registrationSignatures,
   supportedClaudeEvents
-} from "./chunk-JCWZ23MJ.js";
+} from "./chunk-3I6IVOZV.js";
 import {
   formatVersion
 } from "./chunk-6ICPEJY5.js";
@@ -56,7 +64,7 @@ import {
   registrationHolderOf,
   resolveGlobalBinary,
   vscodePluginMcp
-} from "./chunk-ZUTU43FT.js";
+} from "./chunk-ZBHUHJG6.js";
 import {
   readJsonSafe,
   writeFileAtomic,
@@ -322,7 +330,18 @@ var reapplyOpenCodePlugin = (paths = {}) => {
     return { configured: true, reapplied: false, hooks: false, mcp: false, failed: true };
   }
 };
-var reapplyAllAgents = (apiKey) => {
+var SETUP_CHOICE_BY_REAPPLY_ID = {
+  claude: "claude_code",
+  codex: "codex",
+  gemini: "gemini_cli",
+  cursor: "cursor",
+  vscode: "vscode"
+};
+var reapplyHookOwner = (id, appAvailable) => id === "opencode" ? openCodePluginOwner(appAvailable) : agentHookOwner(SETUP_CHOICE_BY_REAPPLY_ID[id], appAvailable);
+var reapplyHolder = (id, appAvailable) => planHooks({ owner: reapplyHookOwner(id, appAvailable), takeOverHooks: false, nonInteractive: true }) === "keep" ? "app" : "cli";
+var KEPT_FOR_APP = { configured: true, reapplied: false, hooks: false, mcp: false };
+var FAILED_REAPPLY = { configured: false, reapplied: false, hooks: false, mcp: false, failed: true };
+var reapplyAllAgents = (apiKey, options = {}) => {
   const runners = [
     { id: "claude", label: "Claude Code", run: () => reapplyClaudeSettings(apiKey) },
     { id: "codex", label: "Codex", run: () => reapplyCodexSettings(apiKey) },
@@ -331,13 +350,18 @@ var reapplyAllAgents = (apiKey) => {
     { id: "vscode", label: "VS Code", run: () => reapplyVsCodePlugin(apiKey) },
     { id: "opencode", label: "OpenCode", run: () => reapplyOpenCodePlugin() }
   ];
+  const appAvailable = (options.appAvailable ?? macAppBridgeAvailable)();
   const done = [];
   for (const runner of runners) {
     try {
+      if (reapplyHolder(runner.id, appAvailable) === "app") {
+        done.push({ id: runner.id, label: runner.label, heldBy: "app", result: KEPT_FOR_APP });
+        continue;
+      }
       const result = runner.run();
-      if (result.configured) done.push({ id: runner.id, label: runner.label, result });
+      if (result.configured) done.push({ id: runner.id, label: runner.label, heldBy: "cli", result });
     } catch {
-      done.push({ id: runner.id, label: runner.label, result: { configured: false, reapplied: false, hooks: false, mcp: false, failed: true } });
+      done.push({ id: runner.id, label: runner.label, heldBy: "cli", result: FAILED_REAPPLY });
     }
   }
   return done;