@pushary/agent-hooks 1.9.50 → 1.9.52

package/dist/chunk-XUW2DRAQ.js

@@ -0,0 +1,427 @@
+import {
+  CLI_PACKAGE_NAMES,
+  OWNERSHIP_PROBE_COMMAND,
+  classifyGlobalFolder,
+  classifyGlobalInstall,
+  cmdShimTarget,
+  decideCommandOwner,
+  globalInstallTarget,
+  globalPackageFolder,
+  globalRootFor,
+  isReleaseVersion,
+  ownPackageName
+} from "./chunk-QTOLNRET.js";
+
+// src/npm.ts
+import { promisify } from "util";
+import { exec, execFile, execFileSync, execSync } from "child_process";
+import { existsSync, readFileSync, readlinkSync, realpathSync } from "fs";
+import { dirname, isAbsolute, join, relative, resolve } from "path";
+var latestReleaseUrl = (packageName) => `https://registry.npmjs.org/${packageName}/latest`;
+var REGISTRY_TIMEOUT_MS = 5e3;
+var LATEST_TAG = "latest";
+var cleanNpmEnv = () => {
+  const env = {};
+  for (const [key, value] of Object.entries(process.env)) {
+    if (key.toLowerCase().startsWith("npm_config_workspace")) continue;
+    env[key] = value;
+  }
+  return env;
+};
+var NPM_ERROR_METADATA = /^(code|syscall|path|dest|errno)\s/i;
+var npmErrorMessage = (err) => {
+  const e = err;
+  const text = [e?.stderr, e?.stdout].map((part) => part ? part.toString() : "").join("\n");
+  const line = text.split("\n").map((l) => l.replace(/^npm error\s*/i, "").trim()).find((l) => l && !l.startsWith("A complete log") && !NPM_ERROR_METADATA.test(l));
+  return line || e?.message || String(err);
+};
+var execNpm = (args, options = {}) => {
+  return execSync(`npm ${args}`, {
+    timeout: 12e4,
+    stdio: "pipe",
+    ...options,
+    env: { ...cleanNpmEnv(), ...options.env ?? {} }
+  });
+};
+var GLOBAL_PREFIX_TIMEOUT_MS = 5e3;
+var readGlobalPrefix = () => {
+  try {
+    const prefix = execNpm("prefix -g --no-workspaces", { timeout: GLOBAL_PREFIX_TIMEOUT_MS }).toString().trim();
+    return prefix === "" ? void 0 : prefix;
+  } catch {
+    return void 0;
+  }
+};
+var resolveGlobalBinary = (name) => {
+  const prefix = readGlobalPrefix();
+  if (prefix === void 0) return void 0;
+  return resolveGlobalBinaryAt(name, prefix);
+};
+var resolveGlobalBinaryAt = (name, prefix, platform = process.platform) => {
+  const candidates = platform === "win32" ? [join(prefix, `${name}.cmd`), join(prefix, name)] : [join(prefix, "bin", name)];
+  return candidates.find(existsSync);
+};
+var resolvePathBinary = (name, platform = process.platform) => {
+  try {
+    return execFileSync(platform === "win32" ? "where" : "which", [name], {
+      encoding: "utf8",
+      stdio: "pipe",
+      timeout: 5e3
+    }).split(/\r?\n/, 1)[0]?.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+};
+var runFileAsync = promisify(execFile);
+var runShellAsync = promisify(exec);
+var DISCOVERY_TIMEOUT_MS = 5e3;
+var refuseDiscoveryAfterStop = (signal) => signal?.throwIfAborted();
+var runNpmDiscovery = (command, signal) => {
+  refuseDiscoveryAfterStop(signal);
+  const options = { env: cleanNpmEnv(), timeout: DISCOVERY_TIMEOUT_MS, signal };
+  return process.platform === "win32" ? runShellAsync(`npm ${command}`, options) : runFileAsync("npm", command.split(" "), options);
+};
+var readGlobalPrefixAsync = async (signal) => {
+  try {
+    const { stdout } = await runNpmDiscovery("prefix -g --no-workspaces", signal);
+    return stdout.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+};
+var resolvePathBinaryAsync = async (name, signal, platform = process.platform) => {
+  try {
+    refuseDiscoveryAfterStop(signal);
+    const { stdout } = await runFileAsync(platform === "win32" ? "where" : "which", [name], {
+      timeout: DISCOVERY_TIMEOUT_MS,
+      signal
+    });
+    return stdout.split(/\r?\n/, 1)[0]?.trim() || void 0;
+  } catch {
+    return void 0;
+  }
+};
+var NPM_MISSING_MESSAGE = "npm is not on PATH, and the hooks run from a global npm install.";
+var NPM_LOOKUP = process.platform === "win32" ? "where npm" : "command -v npm";
+var npmIsOnPath = () => {
+  try {
+    execSync(NPM_LOOKUP, { env: cleanNpmEnv(), stdio: "ignore", timeout: 5e3 });
+    return true;
+  } catch {
+    return false;
+  }
+};
+var GLOBAL_LIST_TIMEOUT_MS = 3e4;
+var globalPackageState = (name) => {
+  try {
+    const listing = JSON.parse(execNpm("list -g --depth=0 --json --no-workspaces", { timeout: GLOBAL_LIST_TIMEOUT_MS }).toString());
+    const dependencies = typeof listing === "object" && listing !== null && "dependencies" in listing ? listing.dependencies : void 0;
+    return typeof dependencies === "object" && dependencies !== null && name in dependencies ? "installed" : "absent";
+  } catch {
+    return "unknown";
+  }
+};
+var NpmMissingError = class extends Error {
+  constructor() {
+    super(NPM_MISSING_MESSAGE);
+    this.name = "NpmMissingError";
+  }
+};
+var npmPermissionFailureKind = (code, platform) => code === "EPERM" && platform === "win32" ? "file-in-use" : "global-prefix";
+var NpmPermissionError = class extends Error {
+  kind;
+  constructor(detail, kind) {
+    super(detail);
+    this.name = "NpmPermissionError";
+    this.kind = kind;
+  }
+};
+var NpmInstallError = class extends Error {
+  constructor(detail) {
+    super(detail);
+    this.name = "NpmInstallError";
+  }
+};
+var NPM_PERMISSION_CODE = /\b(EACCES|EPERM)\b/;
+var ERROR_TEXT_FIELDS = ["code", "stderr", "stdout", "message"];
+var errorTextOf = (err) => {
+  if (typeof err !== "object" || err === null) return [String(err)];
+  return ERROR_TEXT_FIELDS.flatMap((field) => {
+    const value = Reflect.get(err, field);
+    return typeof value === "string" || Buffer.isBuffer(value) ? [value.toString()] : [];
+  });
+};
+var isNpmPermissionCode = (value) => value === "EACCES" || value === "EPERM";
+var npmPermissionCodeOf = (err) => {
+  for (const text of errorTextOf(err)) {
+    const code = NPM_PERMISSION_CODE.exec(text)?.[1];
+    if (isNpmPermissionCode(code)) return code;
+  }
+  return null;
+};
+var npmInstallFailure = (err, platform = process.platform) => {
+  const code = npmPermissionCodeOf(err);
+  return code === null ? new NpmInstallError(npmErrorMessage(err)) : new NpmPermissionError(npmErrorMessage(err), npmPermissionFailureKind(code, platform));
+};
+var resolveBinary = (name) => resolveGlobalBinary(name) ?? resolvePathBinary(name);
+var resolvePackageVersionFromBinary = (binary, packageName) => {
+  try {
+    let dir = dirname(realpathSync(binary));
+    const packagePath = packageName.split("/");
+    for (let depth = 0; depth < 8; depth++) {
+      for (const manifest of [
+        join(dir, "package.json"),
+        join(dir, "node_modules", ...packagePath, "package.json")
+      ]) {
+        try {
+          const value = JSON.parse(readFileSync(manifest, "utf8"));
+          if (value.name === packageName && typeof value.version === "string") return value.version;
+        } catch {
+        }
+      }
+      const parent = dirname(dir);
+      if (parent === dir) break;
+      dir = parent;
+    }
+  } catch {
+  }
+  return void 0;
+};
+var globalPackageVersionIn = (output, name) => {
+  const result = JSON.parse(output);
+  if (typeof result !== "object" || result === null || !("dependencies" in result)) return void 0;
+  const dependencies = result.dependencies;
+  if (typeof dependencies !== "object" || dependencies === null || !(name in dependencies)) return void 0;
+  const entry = Reflect.get(dependencies, name);
+  if (typeof entry !== "object" || entry === null || !("version" in entry)) return void 0;
+  return typeof entry.version === "string" ? entry.version : void 0;
+};
+var resolveGlobalPackageVersion = (name) => {
+  try {
+    return globalPackageVersionIn(execNpm("list -g --depth=0 --json --no-workspaces", { timeout: DISCOVERY_TIMEOUT_MS }).toString(), name);
+  } catch {
+    return void 0;
+  }
+};
+var resolveGlobalPackageVersionAsync = async (name, signal) => {
+  try {
+    const { stdout } = await runNpmDiscovery("list -g --depth=0 --json --no-workspaces", signal);
+    return globalPackageVersionIn(stdout, name);
+  } catch {
+    return void 0;
+  }
+};
+var localImportsPresent = (entry, packageDir, seen = /* @__PURE__ */ new Set()) => {
+  if (seen.has(entry)) return true;
+  seen.add(entry);
+  try {
+    const source = readFileSync(entry, "utf8");
+    for (const match of source.matchAll(/\b(?:import|export)\s+(?:[^"'()]*?\s+from\s+)?["'](\.{1,2}\/[^"']+)["']|\bimport\s*\(\s*["'](\.{1,2}\/[^"']+)["']/g)) {
+      const dependency = resolve(dirname(entry), match[1] ?? match[2]);
+      const localPath = relative(packageDir, dependency);
+      if (localPath.startsWith("..") || isAbsolute(localPath) || !existsSync(dependency)) return false;
+      if (/\.[cm]?js$/.test(dependency) && !localImportsPresent(dependency, packageDir, seen)) return false;
+    }
+    return true;
+  } catch {
+    return false;
+  }
+};
+var packageBinsPresent = (packageDir, prefix, platform = process.platform, requiredFiles = []) => {
+  try {
+    const manifest = JSON.parse(readFileSync(join(packageDir, "package.json"), "utf8"));
+    if (!manifest.bin || typeof manifest.bin !== "object" || Array.isArray(manifest.bin)) return false;
+    const bins = Object.entries(manifest.bin);
+    if (bins.length === 0) return false;
+    if (!requiredFiles.every((path) => existsSync(join(packageDir, path)))) return false;
+    const seen = /* @__PURE__ */ new Set();
+    return bins.every(([name, target]) => {
+      if (typeof target !== "string") return false;
+      const shims = platform === "win32" ? [join(prefix, `${name}.cmd`), join(prefix, name)] : [join(prefix, "bin", name)];
+      const entry = join(packageDir, target);
+      return existsSync(entry) && shims.some(existsSync) && localImportsPresent(entry, packageDir, seen);
+    });
+  } catch {
+    return false;
+  }
+};
+var AGENT_HOOKS_RUNTIME_FILES = [
+  "data/SKILL.md",
+  "data/cursor-plugin/.cursor-plugin/plugin.json",
+  "data/cursor-plugin/hooks/hooks.json",
+  "data/cursor-plugin/mcp.json",
+  "data/cursor-plugin/scripts/pushary-gate.mjs",
+  "data/cursor-plugin/scripts/redaction.mjs",
+  "data/vscode-plugin/.claude-plugin/plugin.json",
+  "data/vscode-plugin/hooks/hooks.json",
+  "data/vscode-plugin/.mcp.json",
+  "data/vscode-plugin/scripts/pushary-gate.mjs",
+  "data/vscode-plugin/scripts/redaction.mjs"
+];
+var globalPackageBinsPresent = (name, prefix, platform) => packageBinsPresent(globalPackageFolder(globalRootFor(prefix, platform), name, platform), prefix, platform, AGENT_HOOKS_RUNTIME_FILES);
+var errorCode = (error) => typeof error === "object" && error !== null && "code" in error ? error.code : void 0;
+var realpathOrUndefined = (path) => {
+  try {
+    return realpathSync(path);
+  } catch {
+    return void 0;
+  }
+};
+var definedPaths = (paths) => paths.filter((path) => path !== void 0);
+var readPosixCommandLink = (prefix) => {
+  const command = join(prefix, "bin", OWNERSHIP_PROBE_COMMAND);
+  try {
+    const target = resolve(dirname(command), readlinkSync(command));
+    return { kind: "resolved", targets: definedPaths([target, realpathOrUndefined(command)]) };
+  } catch (error) {
+    if (errorCode(error) === "ENOENT") return { kind: "absent" };
+    const real = realpathOrUndefined(command);
+    return real === void 0 ? { kind: "unreadable" } : { kind: "resolved", targets: [real] };
+  }
+};
+var readWindowsCommandLink = (prefix) => {
+  const shim = join(prefix, `${OWNERSHIP_PROBE_COMMAND}.cmd`);
+  try {
+    const target = cmdShimTarget(prefix, readFileSync(shim, "utf8"));
+    return target === void 0 ? { kind: "unreadable" } : { kind: "resolved", targets: [target] };
+  } catch (error) {
+    return errorCode(error) === "ENOENT" ? { kind: "absent" } : { kind: "unreadable" };
+  }
+};
+var readCommandLink = (prefix, platform) => platform === "win32" ? readWindowsCommandLink(prefix) : readPosixCommandLink(prefix);
+var readFolderManifest = (folder) => {
+  try {
+    return { kind: "read", manifest: JSON.parse(readFileSync(join(folder, "package.json"), "utf8")) };
+  } catch {
+    return { kind: "unreadable" };
+  }
+};
+var readGlobalFolder = (root, name, platform = process.platform) => classifyGlobalFolder(name, readFolderManifest(globalPackageFolder(root, name, platform)));
+var installedIfOurs = (folder) => folder.kind === "ours" ? [folder.installed] : [];
+var readInstalledCliPackages = (root, platform = process.platform) => CLI_PACKAGE_NAMES.flatMap((name) => installedIfOurs(readGlobalFolder(root, name, platform)));
+var globalRootsFor = (prefix, platform) => {
+  const root = globalRootFor(prefix, platform);
+  return definedPaths([root, realpathOrUndefined(root)]);
+};
+var readCommandOwner = (prefix, platform = process.platform) => decideCommandOwner({
+  platform,
+  globalRoots: globalRootsFor(prefix, platform),
+  link: readCommandLink(prefix, platform),
+  installed: readInstalledCliPackages(globalRootFor(prefix, platform), platform).map((installed) => installed.name)
+});
+var NPM_UNAVAILABLE_OWNER = { kind: "unknown", reason: "npm_unavailable" };
+var readGlobalCliInstallAt = (prefix, platform = process.platform) => classifyGlobalInstall(readInstalledCliPackages(globalRootFor(prefix, platform), platform), readCommandOwner(prefix, platform));
+var readGlobalCliInstall = (platform = process.platform) => {
+  const prefix = readGlobalPrefix();
+  return prefix === void 0 ? { kind: "unavailable" } : readGlobalCliInstallAt(prefix, platform);
+};
+var resolveGlobalBinDir = (probe) => {
+  if (process.platform === "win32") return void 0;
+  const resolved = resolveGlobalBinary(probe);
+  return resolved ? resolved.slice(0, resolved.length - probe.length - 1) : void 0;
+};
+var quoteIfNeeded = (path) => /\s/.test(path) ? `"${path}"` : path;
+var fetchLatestPublishedVersion = async (request) => {
+  try {
+    const response = await (request.fetchImpl ?? fetch)(latestReleaseUrl(request.packageName), {
+      signal: AbortSignal.timeout(request.timeoutMs ?? REGISTRY_TIMEOUT_MS)
+    });
+    if (!response.ok) return void 0;
+    const body = await response.json();
+    const version = body && typeof body === "object" && "version" in body ? body.version : void 0;
+    return typeof version === "string" && isReleaseVersion(version) ? version : void 0;
+  } catch {
+    return void 0;
+  }
+};
+var POSIX_SHELL_WORD = /^[\w@%+=:,./-]+$/;
+var quoteForPosixShell = (value) => POSIX_SHELL_WORD.test(value) ? value : `'${value.replaceAll("'", `'\\''`)}'`;
+var installPackageGlobally = (request, runNpm = execNpm) => {
+  const prefixFlag = request.prefix === void 0 ? "" : ` --prefix ${quoteForPosixShell(request.prefix)}`;
+  const spec = quoteForPosixShell(`${request.packageName}@${request.version}`);
+  runNpm(`install -g --no-workspaces${prefixFlag} ${spec}`, { timeout: request.timeoutMs });
+};
+var needsGlobalInstall = (requested, installed, binaryPresent) => requested !== installed || !binaryPresent;
+var planGlobalInstall = (platform) => {
+  const prefix = readGlobalPrefix();
+  const owner = prefix === void 0 ? NPM_UNAVAILABLE_OWNER : readCommandOwner(prefix, platform);
+  return { prefix, packageName: globalInstallTarget(owner, ownPackageName()) };
+};
+var plannedGlobalPackage = () => planGlobalInstall(process.platform).packageName;
+var installedVersionOf = (prefix, name, platform) => {
+  const folder = readGlobalFolder(globalRootFor(prefix, platform), name, platform);
+  return folder.kind === "ours" ? folder.installed.version : void 0;
+};
+var asCachedResult = (result) => result === "installed" ? "cached" : result;
+var installState;
+var installGlobally = (options) => {
+  if (installState) {
+    return installState.then(asCachedResult);
+  }
+  const started = (async () => {
+    if (!npmIsOnPath()) throw new NpmMissingError();
+    const { withUpgradeLock } = await import("./global-upgrade-AZN3BPI3.js");
+    const { installWithUpgradeLock, ownsUpgradeLock } = await import("./upgrade-lock-AHISGKER.js");
+    const { autoUpdateLock } = await import("./paths-X4IPV2WJ.js");
+    let result = "skipped";
+    const install = async () => {
+      const platform = process.platform;
+      const { prefix, packageName } = planGlobalInstall(platform);
+      const pinned = process.env.PUSHARY_PIN_GLOBAL_VERSION !== "0";
+      if (pinned && prefix !== void 0 && !needsGlobalInstall(
+        options.version,
+        installedVersionOf(prefix, packageName, platform),
+        globalPackageBinsPresent(packageName, prefix, platform)
+      )) {
+        return;
+      }
+      const version = pinned && options.version && options.version !== "0.0.0" ? options.version : LATEST_TAG;
+      installWithUpgradeLock({ packageName, version, timeoutMs: options.timeoutMs ?? 12e4 }, options.lockPath);
+      result = "installed";
+    };
+    if (ownsUpgradeLock(options.lockPath ?? autoUpdateLock())) {
+      await install();
+    } else {
+      const lock = await withUpgradeLock(install, options);
+      if (lock.kind === "refused") throw new Error(lock.message);
+    }
+    return result;
+  })();
+  installState = started;
+  started.catch(() => {
+    if (installState === started) installState = void 0;
+  });
+  return started;
+};
+
+export {
+  LATEST_TAG,
+  cleanNpmEnv,
+  npmErrorMessage,
+  execNpm,
+  readGlobalPrefix,
+  resolveGlobalBinary,
+  resolveGlobalBinaryAt,
+  resolvePathBinary,
+  readGlobalPrefixAsync,
+  resolvePathBinaryAsync,
+  npmIsOnPath,
+  globalPackageState,
+  NpmMissingError,
+  NpmPermissionError,
+  NpmInstallError,
+  npmInstallFailure,
+  resolveBinary,
+  resolvePackageVersionFromBinary,
+  resolveGlobalPackageVersion,
+  resolveGlobalPackageVersionAsync,
+  readGlobalFolder,
+  readGlobalCliInstallAt,
+  readGlobalCliInstall,
+  resolveGlobalBinDir,
+  quoteIfNeeded,
+  fetchLatestPublishedVersion,
+  installPackageGlobally,
+  plannedGlobalPackage,
+  installGlobally
+};

package/dist/{chunk-UHVD7BSV.js → chunk-XZRLFBEA.js}

@@ -12,21 +12,21 @@ import {
   terminalColumns,
   useColor
 } from "./chunk-FO3MDD26.js";
-import {
-  reportedInstallSource
-} from "./chunk-KEAIIVW3.js";
 import {
   callMcpTool
-} from "./chunk-LZYJMSOY.js";
+} from "./chunk-P2546BBI.js";
+import {
+  reportedInstallSource
+} from "./chunk-4QQEUJL4.js";
 import {
   NPX_LATEST_COMMAND
-} from "./chunk-ZOKMGBPR.js";
+} from "./chunk-MC4VY5LK.js";
 import {
   NO_PAIRING_COMPUTER,
   PAIR_TTL_SECONDS,
   classifyConfirmResponse,
   isAnswerSource
-} from "./chunk-OR5F63C2.js";
+} from "./chunk-LF3TLC7B.js";
 
 // src/reach.ts
 var reachVerdict = (channels) => {