@pushary/agent-hooks 0.89.4 → 0.89.6

package/dist/bin/pushary-wait.js

@@ -14,8 +14,8 @@ import {
 } from "../chunk-GMXKITVA.js";
 import {
   exitOnHelpFlag
-} from "../chunk-KJ57OPCC.js";
-import "../chunk-GPNOHKFO.js";
+} from "../chunk-LURY4WNF.js";
+import "../chunk-3XTFX4CL.js";
 import "../chunk-DINDL2CF.js";
 import "../chunk-SAF6HGAA.js";
 import {

package/dist/bin/pushary.js

@@ -3,7 +3,7 @@ import {
   COMMANDS,
   isCommandName,
   renderHelp
-} from "../chunk-GPNOHKFO.js";
+} from "../chunk-3XTFX4CL.js";
 import {
   getPackageVersion
 } from "../chunk-DINDL2CF.js";

package/dist/{chunk-GPNOHKFO.js → chunk-3XTFX4CL.js}

@@ -132,6 +132,7 @@ var SETUP_OPTIONS = [
   ["--connect browser", "Approve in a browser tab instead. For a machine with no app"],
   ["--connect web", "Legacy browser subscribe page"],
   ["--connect none", "Skip the phone connect step, same as --skip-phone"],
+  ["--control auto|on|off", "Manage phone-start automatically (default), require it, or disable its background service"],
   ["--skip-phone", "Skip the phone connect step"],
   ["--verify roundtrip", "Send a real question and wait for you to answer it (default when a human is present)"],
   ["--verify push", "Only prove a notification was delivered. Automatic when nobody is at the terminal"],

package/dist/chunk-5TASNKRX.js

@@ -0,0 +1,210 @@
+import {
+  detectClaudeVersion
+} from "./chunk-475T3XIO.js";
+import {
+  claudeWired,
+  codexWired,
+  geminiWired
+} from "./chunk-OBI4YMCT.js";
+import {
+  GEMINI_HOOK_BINARY,
+  addClaudeMcpServer,
+  addGeminiHooks,
+  addGeminiMcpServer,
+  addPusharyHooks,
+  addPusharyToolPermissions,
+  hasGeminiHooks
+} from "./chunk-7TS2G4QG.js";
+import {
+  guardBinary
+} from "./chunk-AIGDBRIJ.js";
+import {
+  resolveGlobalBinDir,
+  resolveGlobalBinary
+} from "./chunk-PZA7G4CN.js";
+import {
+  CODEX_HOOK_BINARY,
+  addCodexHookTrust,
+  addCodexHooks,
+  addCodexMcpServer,
+  codexConfigToml,
+  codexHookPositions,
+  codexHooksJson,
+  hasCodexHooks,
+  vscodePluginMcp
+} from "./chunk-V37ZXMH3.js";
+import {
+  readJsonSafe
+} from "./chunk-6MTNS63X.js";
+
+// src/reapply.ts
+import { join, dirname } from "path";
+import { homedir } from "os";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "fs";
+import { parse as parseTOML, stringify as stringifyTOML } from "smol-toml";
+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) => {
+  const dir = dirname(filePath);
+  if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+  writeFileSync(filePath, JSON.stringify(data, null, 2) + "\n", "utf-8");
+};
+var hasPusharyClaudeHooks = (settings) => JSON.stringify(settings.hooks ?? {}).includes("pushary-hook");
+var hasPusharyMcp = (claudeJson) => !!claudeJson.mcpServers?.pushary;
+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;
+  try {
+    if (!settingsWritable) throw new Error("settings.json could not be parsed");
+    const s = settings;
+    addPusharyToolPermissions(s);
+    addPusharyHooks(s, resolveGlobalBinDir("pushary-hook"), detectClaudeVersion());
+    writeJson(settingsPath, s);
+    hooks = true;
+  } catch {
+  }
+  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 {
+    }
+  }
+  return { configured: true, reapplied: hooks || mcp, hooks, mcp };
+};
+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(resolveGlobalBinary(CODEX_HOOK_BINARY) ?? CODEX_HOOK_BINARY);
+  let hooks = false;
+  let mcp = false;
+  if (hooksConfig != null) {
+    try {
+      addCodexHooks(hooksConfig, command);
+      writeJson(hooksPath, hooksConfig);
+      hooks = true;
+    } catch {
+    }
+  }
+  if (config != null) {
+    try {
+      if (hooks) addCodexHookTrust(config, hooksPath, command, codexHookPositions(hooksConfig ?? void 0));
+      if (apiKey) {
+        addCodexMcpServer(config, apiKey);
+        mcp = true;
+      }
+      if (hooks || apiKey) writeFileSync(configPath, stringifyTOML(config), "utf-8");
+    } catch {
+    }
+  }
+  return { configured: true, reapplied: hooks || mcp, hooks, mcp };
+};
+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));
+    hooks = true;
+    if (apiKey) {
+      addGeminiMcpServer(settings, apiKey);
+      mcp = true;
+    }
+    writeJson(settingsPath, settings);
+  } catch {
+  }
+  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 };
+  }
+};
+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 {
+    }
+  }
+  return done;
+};
+
+export {
+  inspectConfiguredManagedProviders,
+  reapplyAllAgents
+};

package/dist/{chunk-W6NPWHBJ.js → chunk-L3YUHEB6.js}

@@ -121,7 +121,12 @@ var writeKey = (apiKey, options = {}) => {
   }
   writeJsonAtomic(
     configPath,
-    { ...current, apiKey, installSource: resolveInstallSourceFor(current) },
+    {
+      ...current,
+      apiKey,
+      installSource: resolveInstallSourceFor(current),
+      ...options.controlMode ? { controlMode: options.controlMode } : {}
+    },
     KEY_FILE_MODE
   );
   restrictFile(configPath);
@@ -177,6 +182,12 @@ var readConfigKey = (configPath) => {
   return key || null;
 };
 var readConfigFileKey = () => readConfigKey(configFilePath());
+var readControlMode = () => {
+  const result = readJsonSafe(configFilePath());
+  if (result.kind !== "ok") return null;
+  const value = result.value.controlMode;
+  return value === "auto" || value === "on" || value === "off" ? value : null;
+};
 var readKeySource = () => {
   const configPath = configFilePath();
   const envKey = process.env.PUSHARY_API_KEY?.trim() || null;
@@ -194,5 +205,6 @@ export {
   writeKey,
   clearKey,
   readConfigFileKey,
+  readControlMode,
   readKeySource
 };

package/dist/{chunk-KJ57OPCC.js → chunk-LURY4WNF.js}

@@ -1,6 +1,6 @@
 import {
   renderCommandHelp
-} from "./chunk-GPNOHKFO.js";
+} from "./chunk-3XTFX4CL.js";
 import {
   getPackageVersion
 } from "./chunk-DINDL2CF.js";

package/dist/chunk-NKHEHEUM.js

@@ -0,0 +1,56 @@
+import {
+  resolveBinary,
+  resolveGlobalPackageVersion,
+  resolvePackageVersionFromBinary
+} from "./chunk-PZA7G4CN.js";
+
+// src/live-capabilities.ts
+var CLAUDE_BRIDGE_CAPABILITY = "claude-bridge";
+var CLAUDE_RESUME_CAPABILITY = "claude-resume";
+var CODEX_BRIDGE_CAPABILITY = "codex-bridge";
+var CODEX_RESUME_CAPABILITY = "codex-resume";
+var GEMINI_BRIDGE_CAPABILITY = "gemini-bridge";
+var GEMINI_RESUME_CAPABILITY = "gemini-resume";
+var GEMINI_BRIDGE_MIN_VERSION = [0, 40, 0];
+var version = (raw) => {
+  const match = raw?.match(/^(\d+)\.(\d+)\.(\d+)/);
+  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
+};
+var geminiLiveCapabilities = (rawVersion) => {
+  const installed = version(rawVersion);
+  if (!installed) return [];
+  for (let index = 0; index < GEMINI_BRIDGE_MIN_VERSION.length; index++) {
+    if (installed[index] > GEMINI_BRIDGE_MIN_VERSION[index]) break;
+    if (installed[index] < GEMINI_BRIDGE_MIN_VERSION[index]) return [];
+  }
+  return [GEMINI_BRIDGE_CAPABILITY, GEMINI_RESUME_CAPABILITY];
+};
+var providerLiveCapabilities = (probe) => [
+  ...probe.claude ? [CLAUDE_BRIDGE_CAPABILITY, CLAUDE_RESUME_CAPABILITY] : [],
+  ...probe.codex ? [CODEX_BRIDGE_CAPABILITY, CODEX_RESUME_CAPABILITY] : [],
+  ...geminiLiveCapabilities(probe.geminiVersion)
+];
+var hasSpawnProvider = (capabilities) => capabilities.some(
+  (capability) => capability === CLAUDE_BRIDGE_CAPABILITY || capability === CODEX_BRIDGE_CAPABILITY || capability === GEMINI_BRIDGE_CAPABILITY
+);
+var resolveControlPolicy = (input) => {
+  if (input.mode === "off") return "disabled";
+  if (input.mode === null && !input.servicePresent) return "preserve-absent";
+  if (input.providerAvailable && input.managerAvailable) return "enabled";
+  return input.servicePresent ? "legacy" : "unsupported";
+};
+var detectProviderLiveCapabilities = (providers = ["claude", "codex", "gemini"]) => {
+  const enabled = new Set(providers);
+  const geminiBin = enabled.has("gemini") ? resolveBinary("gemini") : void 0;
+  return providerLiveCapabilities({
+    claude: enabled.has("claude") && resolveBinary("claude") !== void 0,
+    codex: enabled.has("codex") && resolveBinary("codex") !== void 0,
+    geminiVersion: geminiBin ? resolvePackageVersionFromBinary(geminiBin, "@google/gemini-cli") ?? resolveGlobalPackageVersion("@google/gemini-cli") : void 0
+  });
+};
+
+export {
+  hasSpawnProvider,
+  resolveControlPolicy,
+  detectProviderLiveCapabilities
+};

package/dist/{chunk-NLMSSKES.js → chunk-NQNCSPEH.js}

@@ -30,6 +30,31 @@ import { createHash, randomUUID } from "crypto";
 import { homedir } from "os";
 import { execFileSync } from "child_process";
 var daemonNeedsHandoff = (status) => status.kind === "version-mismatch" || status.kind === "configuration-mismatch" || status.kind === "unresponsive" && status.processAlive === true;
+var daemonServiceManagerAvailable = (options = {}) => {
+  const platform = options.platform ?? process.platform;
+  const run = options.run ?? ((command, args) => {
+    execFileSync(command, [...args], { stdio: "ignore", windowsHide: true });
+  });
+  try {
+    if (platform === "darwin") {
+      const uid = options.uid ?? process.getuid?.();
+      if (uid === void 0) return false;
+      run("launchctl", ["print", `gui/${uid}`]);
+      return true;
+    }
+    if (platform === "linux") {
+      run("systemctl", ["--user", "show-environment"]);
+      return true;
+    }
+    if (platform === "win32") {
+      run("sc.exe", ["query", "Schedule"]);
+      return true;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+};
 var statePath = (dir) => join(dir, "daemon-state.json");
 var lockPath = (dir) => join(dir, "daemon.lock");
 var targetPath = (dir) => join(dir, "daemon-target.json");
@@ -78,7 +103,8 @@ var buildDaemonService = (input) => {
       ],
       start: [{ command: "launchctl", args: ["kickstart", "-k", target] }],
       stop: [{ command: "launchctl", args: ["kill", "SIGTERM", target], ignoreFailure: true }],
-      uninstall: [{ command: "launchctl", args: ["bootout", domain, definitionPath], ignoreFailure: true }]
+      uninstall: [{ command: "launchctl", args: ["bootout", domain, definitionPath], ignoreFailure: true }],
+      registrationProbe: { command: "launchctl", args: ["print", target] }
     };
   }
   if (input.platform === "linux") {
@@ -111,6 +137,7 @@ WantedBy=default.target
       uninstall: [
         { command: "systemctl", args: ["--user", "disable", "--now", unit], ignoreFailure: true }
       ],
+      registrationProbe: { command: "systemctl", args: ["--user", "is-enabled", unit] },
       reloadAfterUninstall: { command: "systemctl", args: ["--user", "daemon-reload"] }
     };
   }
@@ -148,7 +175,8 @@ WantedBy=default.target
       ],
       start: [{ command: "schtasks.exe", args: ["/Run", "/TN", taskName] }],
       stop: [{ command: "schtasks.exe", args: ["/End", "/TN", taskName], ignoreFailure: true }],
-      uninstall: [{ command: "schtasks.exe", args: ["/Delete", "/TN", taskName, "/F"], ignoreFailure: true }]
+      uninstall: [{ command: "schtasks.exe", args: ["/Delete", "/TN", taskName, "/F"], ignoreFailure: true }],
+      registrationProbe: { command: "schtasks.exe", args: ["/Query", "/TN", taskName] }
     };
   }
   return null;
@@ -179,12 +207,6 @@ var resolveDaemonServiceDefinition = (options = {}) => {
       }
     }
   }
-  const argvEntry = options.argvEntry ?? process.argv[1];
-  if (!daemonEntry && argvEntry) {
-    const path = platform === "win32" ? win32Path : { dirname, join };
-    const candidate = path.join(path.dirname(argvEntry), "pushary-daemon.js");
-    if (exists(candidate)) daemonEntry = candidate;
-  }
   if (!daemonEntry || !exists(daemonEntry)) return null;
   const homeDir = options.homeDir ?? homedir();
   return buildDaemonService({
@@ -212,6 +234,13 @@ var applyDaemonService = (action, definition, options = {}) => {
       }
     }
     if (action === "uninstall") {
+      let registered = false;
+      try {
+        run(definition.registrationProbe.command, definition.registrationProbe.args);
+        registered = true;
+      } catch {
+      }
+      if (registered) throw new Error("Native background service remains registered");
       safeUnlink(definition.definitionPath);
       const reload = definition.reloadAfterUninstall;
       if (reload) run(reload.command, reload.args);
@@ -236,7 +265,7 @@ var parseDaemonAction = (argv) => {
   return DAEMON_ACTIONS.has(action) ? action : null;
 };
 var manageDaemonService = (action, options = {}) => {
-  const definition = action === "uninstall" ? buildDaemonService({
+  const definition = action === "uninstall" || action === "stop" ? buildDaemonService({
     platform: options.platform ?? process.platform,
     homeDir: options.homeDir ?? homedir(),
     stateDir: options.stateDir ?? pusharyDir(),
@@ -251,8 +280,23 @@ var manageDaemonService = (action, options = {}) => {
       detail: "Could not find the globally installed daemon entry. Run Pushary setup again."
     };
   }
+  if (action === "uninstall" && !daemonServiceManagerAvailable(options)) {
+    return { kind: "failed", detail: "Native background-service manager is unavailable" };
+  }
   return applyDaemonService(action, definition, { run: options.run });
 };
+var hasDaemonServiceDefinition = (options = {}) => {
+  const definition = buildDaemonService({
+    platform: options.platform ?? process.platform,
+    homeDir: options.homeDir ?? homedir(),
+    stateDir: options.stateDir ?? pusharyDir(),
+    execPath: options.execPath ?? process.execPath,
+    daemonEntry: options.daemonEntry ?? process.execPath,
+    pathEnv: options.pathEnv ?? process.env.PATH ?? "",
+    uid: options.uid ?? process.getuid?.()
+  });
+  return definition !== null && existsSync(definition.definitionPath);
+};
 var spawnDetachedDaemon = (plan, options = {}) => {
   const spawnImpl = options.spawnImpl ?? spawnClaude;
   const child = spawnImpl(plan.command, plan.args, {
@@ -515,6 +559,21 @@ var stopDaemonRunning = async (options = {}) => {
   safeUnlink(lockPath(dir));
   return { kind: "stopped" };
 };
+var deactivateDaemonService = async (action, options) => {
+  const platform = options.platform ?? process.platform;
+  const supported = ["darwin", "linux", "win32"].includes(platform);
+  const managerAvailable = supported && daemonServiceManagerAvailable(options);
+  const definitionPresent = supported && hasDaemonServiceDefinition(options);
+  const service = definitionPresent && !managerAvailable ? { kind: "failed", detail: "Native background-service manager is unavailable" } : managerAvailable ? manageDaemonService(action, options) : { kind: "ok" };
+  const stopped = await stopDaemonRunning(options);
+  const failures = [
+    service.kind === "ok" ? null : service.detail,
+    stopped.kind === "unavailable" ? stopped.detail : null
+  ].filter((detail) => detail !== null);
+  return failures.length > 0 ? { kind: "failed", detail: failures.join("; ") } : { kind: "ok" };
+};
+var stopDaemonService = async (options = {}) => deactivateDaemonService("stop", options);
+var disableDaemonService = async (options = {}) => deactivateDaemonService("uninstall", options);
 var replaceDaemonService = async (options = {}) => {
   const stopped = await stopDaemonRunning(options);
   return stopped.kind === "unavailable" ? stopped : manageDaemonService("install", options);
@@ -576,13 +635,17 @@ var ensureDaemonRunning = async (options = {}) => {
 };
 
 export {
+  daemonServiceManagerAvailable,
   DAEMON_LEASE_RENEW_INTERVAL_MS,
   parseDaemonAction,
   manageDaemonService,
+  hasDaemonServiceDefinition,
   readDaemonStatus,
   acquireDaemonLease,
   requestDaemonHandoff,
   stopDaemonRunning,
+  stopDaemonService,
+  disableDaemonService,
   replaceDaemonService,
   ensureDaemonRunning
 };

package/dist/{chunk-7IJYOBHL.js → chunk-WQGMUIDW.js}

@@ -1,6 +1,6 @@
 import {
   readConfigFileKey
-} from "./chunk-W6NPWHBJ.js";
+} from "./chunk-L3YUHEB6.js";
 
 // src/bell/fleet.ts
 import { closeSync, constants, futimesSync, lstatSync, mkdirSync, openSync, readdirSync, unlinkSync } from "fs";

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@pushary/agent-hooks",
-  "version": "0.89.4",
+  "version": "0.89.6",
   "description": "Permission hooks for AI coding agents: route tool approvals through Pushary push notifications",
   "keywords": [
     "pushary",

package/dist/chunk-FWUEYXSD.js

@@ -1,29 +0,0 @@
-// src/live-capabilities.ts
-var CLAUDE_BRIDGE_CAPABILITY = "claude-bridge";
-var CLAUDE_RESUME_CAPABILITY = "claude-resume";
-var CODEX_BRIDGE_CAPABILITY = "codex-bridge";
-var CODEX_RESUME_CAPABILITY = "codex-resume";
-var GEMINI_BRIDGE_CAPABILITY = "gemini-bridge";
-var GEMINI_RESUME_CAPABILITY = "gemini-resume";
-var GEMINI_BRIDGE_MIN_VERSION = [0, 40, 0];
-var version = (raw) => {
-  const match = raw?.match(/^(\d+)\.(\d+)\.(\d+)/);
-  return match ? [Number(match[1]), Number(match[2]), Number(match[3])] : null;
-};
-var geminiLiveCapabilities = (rawVersion) => {
-  const installed = version(rawVersion);
-  if (!installed) return [];
-  for (let index = 0; index < GEMINI_BRIDGE_MIN_VERSION.length; index++) {
-    if (installed[index] > GEMINI_BRIDGE_MIN_VERSION[index]) break;
-    if (installed[index] < GEMINI_BRIDGE_MIN_VERSION[index]) return [];
-  }
-  return [GEMINI_BRIDGE_CAPABILITY, GEMINI_RESUME_CAPABILITY];
-};
-
-export {
-  CLAUDE_BRIDGE_CAPABILITY,
-  CLAUDE_RESUME_CAPABILITY,
-  CODEX_BRIDGE_CAPABILITY,
-  CODEX_RESUME_CAPABILITY,
-  geminiLiveCapabilities
-};