pushary 1.8.0

package/dist/chunk-VQKRG3AC.js

@@ -0,0 +1,339 @@
+import {
+  detectClaudeVersion
+} from "./chunk-SIFVFP6T.js";
+import {
+  ensureCodexTrustsPusharyHooks
+} from "./chunk-RHR6NARM.js";
+import {
+  addClaudeMcpServer,
+  addPusharyHooks,
+  addPusharyToolPermissions
+} from "./chunk-AXPCESYO.js";
+import {
+  claudeUnprovenHolds,
+  claudeWired,
+  codexUnprovenHolds,
+  codexWired,
+  geminiWired
+} from "./chunk-6J2JC2RT.js";
+import {
+  CLAUDE_HOOK_BINARY,
+  CLAUDE_HOOK_EVENTS,
+  GEMINI_HOOK_BINARY,
+  addGeminiHooks,
+  addGeminiMcpServer,
+  formatVersion,
+  hasGeminiHooks,
+  needsReregistration,
+  registrationSignatures,
+  supportedClaudeEvents
+} from "./chunk-3EVPNIBE.js";
+import {
+  CODEX_HOOK_BINARY,
+  addCodexHookTrust,
+  addCodexHooks,
+  addCodexMcpServer,
+  claudeRegistrationReceipt,
+  codexConfigToml,
+  codexHookPositions,
+  codexHooksJson,
+  codexRegistrationHolder,
+  codexVacatedIndexes,
+  dropVacatedCodexHookTrust,
+  guardBinary,
+  hasCodexHooks,
+  namesOurBinary,
+  registeredCommands,
+  registrationHolderOf,
+  resolveGlobalBinary,
+  vscodePluginMcp
+} from "./chunk-A2A2YTMG.js";
+import {
+  readJsonSafe,
+  writeFileAtomic,
+  writeJsonAtomic
+} from "./chunk-T7E75EKA.js";
+
+// src/reapply.ts
+import { dirname, join } from "path";
+import { homedir } from "os";
+import { readFileSync, statSync } from "fs";
+import { parse as parseTOML, stringify as stringifyTOML } from "smol-toml";
+
+// src/reregister.ts
+var asRecord = (value) => typeof value === "object" && value !== null && !Array.isArray(value) ? value : null;
+var CLAUDE_CLI_BINARIES = new Set(CLAUDE_HOOK_EVENTS.map((hook) => hook.binary));
+var registrationHolder = (settings) => registrationHolderOf(settings, CLAUDE_CLI_BINARIES);
+var registeredPusharyEvents = (settings) => new Set(
+  registeredCommands(settings).filter(({ command }) => namesOurBinary(command, CLAUDE_CLI_BINARIES)).map(({ event }) => event)
+);
+var reregisterVerdict = ({ settings, stored, version }) => {
+  const holder = registrationHolder(settings);
+  if (holder === "none") return { kind: "not_wired" };
+  if (holder === "app") return { kind: "app_owned" };
+  const unproven = claudeUnprovenHolds(settings);
+  if (unproven.length === 0 && !needsReregistration(stored, version)) return { kind: "current" };
+  const supported = new Set(supportedClaudeEvents(version).map((hook) => hook.event));
+  const present = registeredPusharyEvents(settings);
+  const missing = [...supported].filter((event) => !present.has(event));
+  const extra = [...present].filter((event) => !supported.has(event));
+  const repairable = unproven.filter((event) => supported.has(event));
+  return missing.length > 0 || extra.length > 0 || repairable.length > 0 ? { kind: "stale", version, missing, extra, unproven: repairable } : { kind: "record_only", version };
+};
+var receiptFor = (version, now = /* @__PURE__ */ new Date()) => ({
+  signatures: registrationSignatures(supportedClaudeEvents(version), version),
+  version: version ? formatVersion(version) : null,
+  recordedAt: now.toISOString()
+});
+var storedSignatures = (raw) => {
+  const signatures = asRecord(asRecord(raw)?.signatures);
+  if (!signatures) return void 0;
+  const entries = Object.entries(signatures).filter(
+    (pair) => typeof pair[1] === "string"
+  );
+  return entries.length > 0 ? Object.fromEntries(entries) : void 0;
+};
+
+// src/reapply.ts
+var CLAUDE_SETTINGS = join(homedir(), ".claude", "settings.json");
+var CLAUDE_JSON = join(homedir(), ".claude.json");
+var readJson = (filePath) => {
+  const result = readJsonSafe(filePath);
+  if (result.kind === "ok") return result.value;
+  if (result.kind === "missing") return {};
+  return null;
+};
+var writeJson = (filePath, data) => writeJsonAtomic(filePath, data);
+var hasPusharyClaudeHooks = (settings) => JSON.stringify(settings.hooks ?? {}).includes(CLAUDE_HOOK_BINARY);
+var hasPusharyMcp = (claudeJson) => !!claudeJson.mcpServers?.pushary;
+var PRIVATE_TO_OWNER = 384;
+var modeToPreserve = (filePath) => {
+  try {
+    return statSync(filePath).mode & 511;
+  } catch {
+    return PRIVATE_TO_OWNER;
+  }
+};
+var wouldWriteBareNames = (resolve, probe) => resolve(probe) === void 0;
+var reapplyClaudeSettings = (apiKey, paths = {}) => {
+  const settingsPath = paths.settingsPath ?? CLAUDE_SETTINGS;
+  const claudeJsonPath = paths.claudeJsonPath ?? CLAUDE_JSON;
+  const settings = readJson(settingsPath);
+  const claudeJson = readJson(claudeJsonPath);
+  const configured = settings != null && hasPusharyClaudeHooks(settings) || claudeJson != null && hasPusharyMcp(claudeJson);
+  if (!configured) return { configured: false, reapplied: false, hooks: false, mcp: false };
+  const settingsWritable = settings != null;
+  const claudeJsonWritable = claudeJson != null;
+  let hooks = false;
+  let mcp = false;
+  let failed = false;
+  try {
+    if (!settingsWritable) throw new Error("settings.json could not be parsed");
+    const s = settings;
+    addPusharyToolPermissions(s);
+    const binary = (paths.resolveBinary ?? resolveGlobalBinary)(CLAUDE_HOOK_BINARY);
+    addPusharyHooks(s, binary ? dirname(binary) : void 0, (paths.detectVersion ?? detectClaudeVersion)());
+    writeJson(settingsPath, s);
+    hooks = true;
+  } catch {
+    failed = true;
+  }
+  if (apiKey) {
+    try {
+      if (!claudeJsonWritable) throw new Error(".claude.json could not be parsed");
+      const cj = claudeJson;
+      addClaudeMcpServer(cj, apiKey);
+      writeJson(claudeJsonPath, cj);
+      mcp = true;
+    } catch {
+      failed = true;
+    }
+  }
+  return { configured: true, reapplied: hooks || mcp, hooks, mcp, failed };
+};
+var reapplyClaudeForVersion = (apiKey, paths = {}) => {
+  const idle = { verdict: "current", rewrote: false, missing: [] };
+  try {
+    const settingsPath = paths.settingsPath ?? CLAUDE_SETTINGS;
+    const receiptPath = paths.receiptPath ?? claudeRegistrationReceipt();
+    const version = (paths.detectVersion ?? detectClaudeVersion)();
+    const receipt = readJsonSafe(receiptPath);
+    const verdict = reregisterVerdict({
+      settings: readJson(settingsPath),
+      stored: storedSignatures(receipt.kind === "ok" ? receipt.value : void 0),
+      version
+    });
+    if (verdict.kind === "not_wired" || verdict.kind === "app_owned" || verdict.kind === "current") {
+      return { verdict: verdict.kind, rewrote: false, missing: [] };
+    }
+    const resolveBinary = paths.resolveBinary ?? resolveGlobalBinary;
+    if (verdict.kind === "stale" && wouldWriteBareNames(resolveBinary, CLAUDE_HOOK_BINARY)) {
+      return { verdict: "stale", rewrote: false, missing: verdict.missing };
+    }
+    const rewrote = verdict.kind === "stale" ? reapplyClaudeSettings(apiKey, { ...paths, settingsPath }).hooks : false;
+    if (verdict.kind === "stale" && !rewrote) return { verdict: "stale", rewrote: false, missing: verdict.missing };
+    writeJsonAtomic(receiptPath, receiptFor(version));
+    return {
+      verdict: verdict.kind,
+      rewrote,
+      missing: verdict.kind === "stale" ? verdict.missing : []
+    };
+  } catch {
+    return idle;
+  }
+};
+var readToml = (filePath) => {
+  try {
+    const raw = readFileSync(filePath, "utf-8");
+    return raw.trim() === "" ? {} : parseTOML(raw);
+  } catch {
+    return null;
+  }
+};
+var inspectConfiguredManagedProviders = (paths = {}) => {
+  const providers = [];
+  const claudeSettings = readJson(paths.claudeSettingsPath ?? CLAUDE_SETTINGS);
+  const claudeJson = readJson(paths.claudeJsonPath ?? CLAUDE_JSON);
+  if (claudeWired({ claudeJson, settings: claudeSettings, skillExists: false })) {
+    providers.push("claude");
+  }
+  const codexConfig = readToml(paths.codexConfigPath ?? codexConfigToml());
+  const codexHooks = readJson(paths.codexHooksPath ?? codexHooksJson());
+  if (codexWired({ config: codexConfig, hooks: codexHooks, skillExists: false })) {
+    providers.push("codex");
+  }
+  const gemini = readJson(paths.geminiSettingsPath ?? join(homedir(), ".gemini", "settings.json"));
+  if (geminiWired({ settings: gemini })) {
+    providers.push("gemini");
+  }
+  return providers;
+};
+var reapplyCodexSettings = (apiKey, paths = {}) => {
+  const configPath = paths.configPath ?? codexConfigToml();
+  const hooksPath = paths.hooksPath ?? codexHooksJson();
+  const config = readToml(configPath);
+  const hooksConfig = readJson(hooksPath);
+  const configured = config != null && !!config.mcp_servers?.pushary || hooksConfig != null && hasCodexHooks(hooksConfig);
+  if (!configured) return { configured: false, reapplied: false, hooks: false, mcp: false };
+  const command = guardBinary((paths.resolveBinary ?? resolveGlobalBinary)(CODEX_HOOK_BINARY) ?? CODEX_HOOK_BINARY);
+  let hooks = false;
+  let mcp = false;
+  let failed = hooksConfig === null || config === null;
+  const vacated = codexVacatedIndexes(hooksConfig ?? void 0);
+  if (hooksConfig != null) {
+    try {
+      addCodexHooks(hooksConfig, command);
+      writeJson(hooksPath, hooksConfig);
+      hooks = true;
+    } catch {
+      failed = true;
+    }
+  }
+  if (config != null) {
+    try {
+      if (hooks) {
+        dropVacatedCodexHookTrust(config, hooksPath, vacated);
+        addCodexHookTrust(config, hooksPath, command, codexHookPositions(hooksConfig ?? void 0));
+      }
+      if (apiKey) {
+        addCodexMcpServer(config, apiKey);
+      }
+      if (hooks || apiKey) {
+        writeFileAtomic(configPath, stringifyTOML(config), modeToPreserve(configPath), "utf-8");
+        mcp = Boolean(apiKey);
+      }
+    } catch {
+      failed = true;
+      hooks = false;
+    }
+  }
+  if (config === null) hooks = false;
+  return { configured: true, reapplied: hooks || mcp, hooks, mcp, failed };
+};
+var repairCodexHolds = (paths = {}) => {
+  const idle = { configured: false, reapplied: false, hooks: false, mcp: false };
+  try {
+    const hooksPath = paths.hooksPath ?? codexHooksJson();
+    const hooksConfig = readJson(hooksPath);
+    if (!hooksConfig || codexRegistrationHolder(hooksConfig) !== "cli") return idle;
+    if (codexUnprovenHolds(hooksConfig).length === 0) return idle;
+    if (wouldWriteBareNames(paths.resolveBinary ?? resolveGlobalBinary, CODEX_HOOK_BINARY)) return idle;
+    return reapplyCodexSettings(void 0, paths);
+  } catch {
+    return idle;
+  }
+};
+var reapplyGeminiSettings = (apiKey, paths = {}) => {
+  const settingsPath = paths.settingsPath ?? join(homedir(), ".gemini", "settings.json");
+  const settings = readJson(settingsPath);
+  if (settings == null) return { configured: false, reapplied: false, hooks: false, mcp: false };
+  const configured = hasGeminiHooks(settings) || !!settings.mcpServers?.pushary;
+  if (!configured) return { configured: false, reapplied: false, hooks: false, mcp: false };
+  let hooks = false;
+  let mcp = false;
+  try {
+    addGeminiHooks(settings, guardBinary(resolveGlobalBinary(GEMINI_HOOK_BINARY) ?? GEMINI_HOOK_BINARY));
+    if (apiKey) {
+      addGeminiMcpServer(settings, apiKey);
+    }
+    writeJson(settingsPath, settings);
+    hooks = true;
+    mcp = Boolean(apiKey);
+  } catch {
+    return { configured: true, reapplied: false, hooks: false, mcp: false, failed: true };
+  }
+  return { configured: true, reapplied: hooks || mcp, hooks, mcp };
+};
+var reapplyPluginMcp = (mcpPath, apiKey) => {
+  const mcpConfig = readJson(mcpPath);
+  if (mcpConfig == null) return { configured: false, reapplied: false, hooks: false, mcp: false };
+  const servers = mcpConfig.mcpServers;
+  if (!servers?.pushary) return { configured: false, reapplied: false, hooks: false, mcp: false };
+  if (!apiKey) return { configured: true, reapplied: false, hooks: false, mcp: false };
+  try {
+    addClaudeMcpServer(mcpConfig, apiKey);
+    writeJson(mcpPath, mcpConfig);
+    return { configured: true, reapplied: true, hooks: false, mcp: true };
+  } catch {
+    return { configured: true, reapplied: false, hooks: false, mcp: false, failed: true };
+  }
+};
+var reapplyCursorPlugin = (apiKey, paths = {}) => reapplyPluginMcp(
+  paths.pluginMcpPath ?? join(homedir(), ".cursor", "plugins", "local", "pushary", "mcp.json"),
+  apiKey
+);
+var reapplyVsCodePlugin = (apiKey, paths = {}) => reapplyPluginMcp(paths.pluginMcpPath ?? vscodePluginMcp(), apiKey);
+var reapplyAllAgents = (apiKey) => {
+  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) }
+  ];
+  const done = [];
+  for (const runner of runners) {
+    try {
+      const result = runner.run();
+      if (result.configured) done.push({ id: runner.id, label: runner.label, result });
+    } catch {
+      done.push({ id: runner.id, label: runner.label, result: { configured: false, reapplied: false, hooks: false, mcp: false, failed: true } });
+    }
+  }
+  return done;
+};
+var isRewrittenCodex = (agent) => agent.id === "codex" && agent.result.hooks;
+var ensureCodexTrustAfterReapply = async (agents, options = {}) => agents.some(isRewrittenCodex) ? ensureCodexTrustsPusharyHooks(options) : null;
+
+export {
+  reapplyClaudeSettings,
+  reapplyClaudeForVersion,
+  inspectConfiguredManagedProviders,
+  reapplyCodexSettings,
+  repairCodexHolds,
+  reapplyGeminiSettings,
+  reapplyCursorPlugin,
+  reapplyVsCodePlugin,
+  reapplyAllAgents,
+  ensureCodexTrustAfterReapply
+};