@pushary/agent-hooks 1.9.50 → 1.9.53

package/dist/chunk-QTOLNRET.js

@@ -0,0 +1,169 @@
+// src/cli-package-name.ts
+var CANONICAL_PACKAGE = "pushary";
+var LEGACY_PACKAGE = "@pushary/agent-hooks";
+var CLI_PACKAGE_NAMES = [CANONICAL_PACKAGE, LEGACY_PACKAGE];
+var isCliPackageName = (value) => typeof value === "string" && CLI_PACKAGE_NAMES.some((name) => name === value);
+var cliPackagePathSegments = (name) => name.split("/");
+
+// src/global-package.ts
+import { posix, win32 } from "path";
+var OWNERSHIP_PROBE_COMMAND = "pushary-hook";
+var pathApiFor = (platform) => platform === "win32" ? win32 : posix;
+var POSIX_GLOBAL_ROOT_SEGMENTS = ["lib", "node_modules"];
+var UPGRADE_ENTRY_SEGMENTS = ["dist", "bin", "pushary-upgrade.js"];
+var globalRootFor = (prefix, platform) => platform === "win32" ? win32.join(prefix, "node_modules") : posix.join(prefix, ...POSIX_GLOBAL_ROOT_SEGMENTS);
+var globalPackageFolder = (root, name, platform) => pathApiFor(platform).join(root, ...cliPackagePathSegments(name));
+var globalUpgradeEntry = (prefix, name, platform) => pathApiFor(platform).join(globalPackageFolder(globalRootFor(prefix, platform), name, platform), ...UPGRADE_ENTRY_SEGMENTS);
+var isInsideFolder = (target, folder, platform) => {
+  const pathApi = pathApiFor(platform);
+  const relativePath = pathApi.relative(folder, target);
+  return relativePath !== "" && !relativePath.startsWith("..") && !pathApi.isAbsolute(relativePath);
+};
+var linkPointsInto = (evidence, targets, name) => evidence.globalRoots.some((root) => {
+  const folder = globalPackageFolder(root, name, evidence.platform);
+  return targets.some((target) => isInsideFolder(target, folder, evidence.platform));
+});
+var ownerFromInstalled = (installed, whenNone) => {
+  const [only, ...others] = installed;
+  if (only === void 0) return whenNone;
+  if (others.length > 0) return { kind: "unknown", reason: "both_installed" };
+  return { kind: "owned", name: only };
+};
+var decideCommandOwner = (evidence) => {
+  const { link } = evidence;
+  if (link.kind === "resolved") {
+    const name = CLI_PACKAGE_NAMES.find((candidate) => linkPointsInto(evidence, link.targets, candidate));
+    return name === void 0 ? { kind: "unknown", reason: "foreign_command" } : { kind: "owned", name };
+  }
+  const whenNone = link.kind === "absent" ? { kind: "none" } : { kind: "unknown", reason: "unreadable_command" };
+  return ownerFromInstalled(evidence.installed, whenNone);
+};
+var CMD_SHIM_TARGET = /"%(?:~dp0|dp0%)\\([^"]+?)"\s+%[*]/;
+var cmdShimTarget = (shimDir, contents) => {
+  const relativeTarget = CMD_SHIM_TARGET.exec(contents)?.[1];
+  return relativeTarget === void 0 ? void 0 : win32.resolve(shimDir, relativeTarget);
+};
+var launchedPackage = (ownName) => ownName ?? LEGACY_PACKAGE;
+var globalInstallTarget = (owner, ownName) => {
+  switch (owner.kind) {
+    case "owned":
+      return owner.name;
+    case "none":
+      return launchedPackage(ownName);
+    case "unknown":
+      return LEGACY_PACKAGE;
+  }
+};
+var isRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
+var declaresOwnershipProbe = (bin) => isRecord(bin) && typeof bin[OWNERSHIP_PROBE_COMMAND] === "string";
+var cliManifestName = (manifest) => {
+  if (!isRecord(manifest) || !isCliPackageName(manifest.name) || !declaresOwnershipProbe(manifest.bin)) return void 0;
+  return manifest.name;
+};
+var classifyGlobalFolder = (name, read) => {
+  if (read.kind === "unreadable") return { kind: "unseen" };
+  const { manifest } = read;
+  if (!isRecord(manifest) || cliManifestName(manifest) !== name) return { kind: "foreign" };
+  return { kind: "ours", installed: { name, version: typeof manifest.version === "string" ? manifest.version : void 0 } };
+};
+var classifyGlobalInstall = (installed, owner) => {
+  const [only, ...others] = installed;
+  if (only === void 0) return { kind: "absent" };
+  if (others.length === 0) return { kind: "single", installed: only };
+  return { kind: "both", installed, owner };
+};
+var isUninstallable = (evidence) => evidence.listing !== "absent" && evidence.folder !== "foreign";
+var globalPackagesToUninstall = (evidence) => evidence.filter(isUninstallable).map((entry) => entry.name);
+var commandsPackage = (install) => {
+  if (install.kind === "single") return install.installed;
+  if (install.kind !== "both" || install.owner.kind !== "owned") return void 0;
+  const ownerName = install.owner.name;
+  return install.installed.find((installed) => installed.name === ownerName);
+};
+
+// src/cli/version.ts
+import { readFileSync } from "fs";
+import { dirname, join, parse } from "path";
+import { fileURLToPath } from "url";
+var UNKNOWN_VERSION = "0.0.0";
+var cliManifestNameAt = (manifestPath) => {
+  try {
+    return cliManifestName(JSON.parse(readFileSync(manifestPath, "utf-8")));
+  } catch {
+    return void 0;
+  }
+};
+var findOwnPackage = (start) => {
+  const { root } = parse(start);
+  let dir = start;
+  while (true) {
+    const name = cliManifestNameAt(join(dir, "package.json"));
+    if (name !== void 0) return { root: dir, name };
+    if (dir === root) return void 0;
+    const parent = dirname(dir);
+    if (parent === dir) return void 0;
+    dir = parent;
+  }
+};
+var runningPackage = () => {
+  try {
+    return findOwnPackage(dirname(fileURLToPath(import.meta.url)));
+  } catch {
+    return void 0;
+  }
+};
+var getPackageVersion = () => {
+  const root = ownPackageRoot();
+  return (root === void 0 ? void 0 : packageVersionAt(root)) ?? UNKNOWN_VERSION;
+};
+var ownPackageRoot = () => runningPackage()?.root;
+var ownPackageName = () => runningPackage()?.name;
+var packageVersionAt = (packageRoot) => {
+  try {
+    const manifest = JSON.parse(readFileSync(join(packageRoot, "package.json"), "utf-8"));
+    const version = manifest && typeof manifest === "object" && "version" in manifest ? manifest.version : void 0;
+    return typeof version === "string" ? version : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var isNewerVersion = (candidate, current) => {
+  const a = candidate.split(".").map((part) => parseInt(part, 10) || 0);
+  const b = current.split(".").map((part) => parseInt(part, 10) || 0);
+  for (let i = 0; i < 3; i++) {
+    if ((a[i] ?? 0) > (b[i] ?? 0)) return true;
+    if ((a[i] ?? 0) < (b[i] ?? 0)) return false;
+  }
+  return false;
+};
+var RELEASE_VERSION = /^\d+\.\d+\.\d+$/;
+var isReleaseVersion = (value) => RELEASE_VERSION.test(value);
+var majorOf = (version) => parseInt(version.split(".")[0] ?? "", 10) || 0;
+var isSameMajorVersion = (candidate, current) => majorOf(candidate) === majorOf(current);
+
+export {
+  CANONICAL_PACKAGE,
+  LEGACY_PACKAGE,
+  CLI_PACKAGE_NAMES,
+  cliPackagePathSegments,
+  OWNERSHIP_PROBE_COMMAND,
+  POSIX_GLOBAL_ROOT_SEGMENTS,
+  globalRootFor,
+  globalPackageFolder,
+  globalUpgradeEntry,
+  decideCommandOwner,
+  cmdShimTarget,
+  launchedPackage,
+  globalInstallTarget,
+  classifyGlobalFolder,
+  classifyGlobalInstall,
+  globalPackagesToUninstall,
+  commandsPackage,
+  getPackageVersion,
+  ownPackageRoot,
+  ownPackageName,
+  packageVersionAt,
+  isNewerVersion,
+  isReleaseVersion,
+  isSameMajorVersion
+};

package/dist/{chunk-TYTIDEBW.js → chunk-RH6KR6EH.js}

@@ -1,9 +1,9 @@
 import {
   APPROVAL_SETTINGS_PATH
-} from "./chunk-5Q2FRMPC.js";
+} from "./chunk-JOWF4Y4P.js";
 import {
   readMacAppAgentKey
-} from "./chunk-K73CBZKW.js";
+} from "./chunk-MHQB62K5.js";
 import {
   findExportedKeyLines,
   isAdoptedMacAppKey,
@@ -13,13 +13,13 @@ import {
   readConfigFileKey,
   readKeySource,
   readMacAppKeyPrefix
-} from "./chunk-XH3F66VD.js";
+} from "./chunk-VYBH6D4X.js";
 import {
   absoluteUrl
-} from "./chunk-34RXPM5U.js";
+} from "./chunk-L5YTS2BP.js";
 import {
   isValidApiKey
-} from "./chunk-OR5F63C2.js";
+} from "./chunk-LF3TLC7B.js";
 
 // src/key-revocation.ts
 var SELF_REVOKE_PATH = "/api/v1/server/keys/self/revoke";

package/dist/{chunk-7RMSB4A2.js → chunk-RL7EOD6I.js}

@@ -1,23 +1,39 @@
 import {
   ensureCodexTrustsPusharyHooks
-} from "./chunk-KIO2MZQC.js";
+} from "./chunk-FCMWUYIE.js";
+import {
+  CODEX_INSTRUCTIONS_LABEL,
+  GEMINI_INSTRUCTIONS_LABEL,
+  OPENCODE_INSTRUCTIONS_LABEL,
+  fxIgnoresInstructionsFile,
+  fxInstructionsBody,
+  fxServerHolder,
+  macAppFxBridge,
+  refreshInstructionBlock,
+  renderAgentInstructions
+} from "./chunk-MTKV4RUQ.js";
 import {
   OPENCODE_HOOK_BINARY,
   agentHookOwner,
   installOpenCodePlugin,
   macAppBridgeAvailable,
   openCodeHookArgv,
+  openCodeInstructionsFile,
   openCodePluginDir,
   openCodeWired
-} from "./chunk-LLRYP5TR.js";
+} from "./chunk-K23WMLPY.js";
+import {
+  detectClaudeVersion
+} from "./chunk-RIVNNBEK.js";
 import {
   addClaudeMcpServer,
   addCompatibleHooks,
   addPusharyHooks,
   addPusharyToolPermissions,
   compatibleConfigFile,
+  compatibleInstructionsFile,
   hasCompatibleHooks
-} from "./chunk-Y74IJ2IO.js";
+} from "./chunk-N77BH7H2.js";
 import {
   claudeUnprovenHolds,
   claudeWired,
@@ -25,7 +41,7 @@ import {
   codexWired,
   geminiWired,
   planHooks
-} from "./chunk-WEY5ZHDB.js";
+} from "./chunk-Q7OXI6VS.js";
 import {
   CLAUDE_HOOK_BINARY,
   CLAUDE_HOOK_EVENTS,
@@ -36,10 +52,7 @@ import {
   needsReregistration,
   registrationSignatures,
   supportedClaudeEvents
-} from "./chunk-25SYEAW4.js";
-import {
-  detectClaudeVersion
-} from "./chunk-RIVNNBEK.js";
+} from "./chunk-6C4S3QYD.js";
 import {
   formatVersion
 } from "./chunk-6ICPEJY5.js";
@@ -49,21 +62,29 @@ import {
   addCodexHooks,
   addCodexMcpServer,
   claudeRegistrationReceipt,
+  codexAgentsMd,
   codexConfigToml,
   codexHookPositions,
   codexHooksJson,
   codexRegistrationHolder,
   codexVacatedIndexes,
   dropVacatedCodexHookTrust,
+  fxAgentsMd,
+  fxConfigDir,
+  fxMcpProfile,
+  geminiMd,
   guardBinary,
   hasCodexHooks,
   namesOurBinary,
+  pusharyDir,
   registeredCommands,
   registrationHolderOf,
-  resolveGlobalBinDir,
-  resolveGlobalBinary,
   vscodePluginMcp
-} from "./chunk-ZYYQJSIO.js";
+} from "./chunk-OML4YFBN.js";
+import {
+  resolveGlobalBinDir,
+  resolveGlobalBinary
+} from "./chunk-XUW2DRAQ.js";
 import {
   readJsonSafe,
   writeFileAtomic,
@@ -73,7 +94,7 @@ import {
   HOOK_COMPATIBLE_PROFILES,
   isCompatibleAgentType,
   isRecord
-} from "./chunk-OR5F63C2.js";
+} from "./chunk-LF3TLC7B.js";
 
 // src/reapply.ts
 import { dirname, join } from "path";
@@ -350,31 +371,71 @@ var reapplyCompatibleHooks = (profile, paths = {}) => {
     return CONFIGURED_BUT_FAILED;
   }
 };
+var CONFIGURED_AND_UNCHANGED = { configured: true, reapplied: false, hooks: false, mcp: false };
+var fxHolder = () => fxServerHolder(fxMcpProfile(), macAppFxBridge(pusharyDir()));
+var inspectFxWiring = () => fxHolder() === "cli" ? CONFIGURED_AND_UNCHANGED : NOT_CONFIGURED;
+var compatibleInstructionTarget = (profile) => {
+  const file = compatibleInstructionsFile(profile);
+  return file && profile.instructions ? { file, body: renderAgentInstructions(profile.instructions.label) } : null;
+};
+var fxInstructionTarget = () => fxIgnoresInstructionsFile(fxAgentsMd(), fxConfigDir()) ? null : { file: fxAgentsMd(), body: fxInstructionsBody() };
+var instructionTargetOrNull = (target) => {
+  try {
+    return target();
+  } catch {
+    return null;
+  }
+};
+var refreshAgentInstructions = (target) => {
+  const resolved = instructionTargetOrNull(target);
+  return resolved ? { file: resolved.file, outcome: refreshInstructionBlock(resolved.file, resolved.body) } : null;
+};
 var SETUP_CHOICE_BY_REAPPLY_ID = {
   claude: "claude_code",
   codex: "codex",
   gemini: "gemini_cli",
   cursor: "cursor",
   vscode: "vscode",
-  opencode: "opencode"
+  opencode: "opencode",
+  fx: "fx"
 };
 var setupChoiceOf = (id) => isCompatibleAgentType(id) ? id : SETUP_CHOICE_BY_REAPPLY_ID[id];
 var reapplyHookOwner = (id, appAvailable) => agentHookOwner(setupChoiceOf(id), appAvailable);
-var reapplyHolder = (id, appAvailable) => planHooks({ owner: reapplyHookOwner(id, appAvailable), takeOverHooks: false, nonInteractive: true }) === "keep" ? "app" : "cli";
+var hooksHeldByApp = (id, appAvailable) => planHooks({ owner: reapplyHookOwner(id, appAvailable), takeOverHooks: false, nonInteractive: true }) === "keep";
+var fxHeldByApp = (appAvailable) => appAvailable && fxHolder() === "app";
+var reapplyHolder = (id, appAvailable) => (id === "fx" ? fxHeldByApp(appAvailable) : hooksHeldByApp(id, appAvailable)) ? "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 noInstructionBlock = () => null;
 var reapplyAllAgents = (apiKey, options = {}) => {
   const runners = [
-    { id: "claude", label: "Claude Code", run: () => reapplyClaudeSettings(apiKey) },
-    { id: "codex", label: "Codex", run: () => reapplyCodexSettings(apiKey) },
-    { id: "gemini", label: "Gemini CLI", run: () => reapplyGeminiSettings(apiKey) },
-    { id: "cursor", label: "Cursor", run: () => reapplyCursorPlugin(apiKey) },
-    { id: "vscode", label: "VS Code", run: () => reapplyVsCodePlugin(apiKey) },
-    { id: "opencode", label: "OpenCode", run: () => reapplyOpenCodePlugin() },
+    { id: "claude", label: "Claude Code", run: () => reapplyClaudeSettings(apiKey), instructions: noInstructionBlock },
+    {
+      id: "codex",
+      label: "Codex",
+      run: () => reapplyCodexSettings(apiKey),
+      instructions: () => ({ file: codexAgentsMd(), body: renderAgentInstructions(CODEX_INSTRUCTIONS_LABEL) })
+    },
+    {
+      id: "gemini",
+      label: "Gemini CLI",
+      run: () => reapplyGeminiSettings(apiKey),
+      instructions: () => ({ file: geminiMd(), body: renderAgentInstructions(GEMINI_INSTRUCTIONS_LABEL) })
+    },
+    { id: "cursor", label: "Cursor", run: () => reapplyCursorPlugin(apiKey), instructions: noInstructionBlock },
+    { id: "vscode", label: "VS Code", run: () => reapplyVsCodePlugin(apiKey), instructions: noInstructionBlock },
+    {
+      id: "opencode",
+      label: "OpenCode",
+      run: () => reapplyOpenCodePlugin(),
+      instructions: () => ({ file: openCodeInstructionsFile(), body: renderAgentInstructions(OPENCODE_INSTRUCTIONS_LABEL) })
+    },
+    { id: "fx", label: "fx", run: inspectFxWiring, instructions: fxInstructionTarget },
     ...HOOK_COMPATIBLE_PROFILES.map((profile) => ({
       id: profile.agentType,
       label: profile.label,
-      run: () => reapplyCompatibleHooks(profile)
+      run: () => reapplyCompatibleHooks(profile),
+      instructions: () => compatibleInstructionTarget(profile)
     }))
   ];
   const appAvailable = (options.appAvailable ?? macAppBridgeAvailable)();
@@ -382,13 +443,15 @@ var reapplyAllAgents = (apiKey, options = {}) => {
   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 });
+        done.push({ id: runner.id, label: runner.label, heldBy: "app", result: KEPT_FOR_APP, instructions: null });
         continue;
       }
       const result = runner.run();
-      if (result.configured) done.push({ id: runner.id, label: runner.label, heldBy: "cli", result });
+      if (result.configured) {
+        done.push({ id: runner.id, label: runner.label, heldBy: "cli", result, instructions: refreshAgentInstructions(runner.instructions) });
+      }
     } catch {
-      done.push({ id: runner.id, label: runner.label, heldBy: "cli", result: FAILED_REAPPLY });
+      done.push({ id: runner.id, label: runner.label, heldBy: "cli", result: FAILED_REAPPLY, instructions: null });
     }
   }
   return done;

package/dist/{chunk-BOVSUH4N.js → chunk-S6RNS4UL.js}

@@ -3,10 +3,10 @@ import {
 } from "./chunk-KZERVKTD.js";
 import {
   renderCommandHelp
-} from "./chunk-ZOKMGBPR.js";
+} from "./chunk-MC4VY5LK.js";
 import {
   getPackageVersion
-} from "./chunk-OR5F63C2.js";
+} from "./chunk-QTOLNRET.js";
 
 // src/cli/usage.ts
 var exitOnHelpFlag = (command) => {