farming-code 2.2.29 → 2.2.32

package/backend/agent-extension-discovery.cjs

@@ -0,0 +1,452 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var agent_extension_discovery_exports = {};
+__export(agent_extension_discovery_exports, {
+  discoverAgentExtensions: () => discoverAgentExtensions
+});
+module.exports = __toCommonJS(agent_extension_discovery_exports);
+const fs = require("fs");
+const path = require("path");
+const MAX_FILE_BYTES = 1024 * 1024;
+const MAX_ITEMS = 500;
+const MAX_PLUGIN_MANIFESTS = 200;
+const SAFE_NAME = /^[A-Za-z0-9][A-Za-z0-9._-]{0,127}$/;
+const AGENT_PLUGINS_SCHEMA_PREFIX = "https://agent-plugins.org/schemas/";
+const AGENT_PLUGINS_V1_SCHEMA = /^https:\/\/agent-plugins\.org\/schemas\/(1\.0\.0)\/plugin\.schema\.json$/;
+const AGENT_PLUGINS_NAME = /^[a-z0-9](?:[a-z0-9.-]{0,62}[a-z0-9])?$/;
+const TITLE_ACRONYMS = /* @__PURE__ */ new Map([
+  ["ai", "AI"],
+  ["api", "API"],
+  ["cli", "CLI"],
+  ["mcp", "MCP"],
+  ["sql", "SQL"],
+  ["ui", "UI"],
+  ["url", "URL"]
+]);
+function recordValue(value) {
+  return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function stringValue(value, limit = 500) {
+  return typeof value === "string" ? value.trim().replace(/[\x00-\x08\x0b\x0c\x0e-\x1f\x7f]/g, "").slice(0, limit) : "";
+}
+function readText(filePath) {
+  try {
+    const stats = fs.statSync(filePath);
+    if (!stats.isFile() || stats.size > MAX_FILE_BYTES) return "";
+    return fs.readFileSync(filePath, "utf8");
+  } catch {
+    return "";
+  }
+}
+function readJson(filePath) {
+  const contents = readText(filePath);
+  if (!contents) return null;
+  try {
+    const value = JSON.parse(contents);
+    return value && typeof value === "object" && !Array.isArray(value) ? value : null;
+  } catch {
+    return null;
+  }
+}
+function titleFromName(name) {
+  return name.split(/[-_.]+/).filter(Boolean).map((part) => TITLE_ACRONYMS.get(part.toLowerCase()) || part.slice(0, 1).toUpperCase() + part.slice(1)).join(" ") || name;
+}
+function sourceFileWithin(homePath, absoluteFile) {
+  const relative = path.relative(homePath, absoluteFile);
+  if (!relative || relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return "";
+  try {
+    const realHome = fs.realpathSync(homePath);
+    const realFile = fs.realpathSync(absoluteFile);
+    const realRelative = path.relative(realHome, realFile);
+    if (realRelative === ".." || realRelative.startsWith(`..${path.sep}`) || path.isAbsolute(realRelative)) return "";
+  } catch {
+    return "";
+  }
+  return relative.split(path.sep).join("/");
+}
+function safePluginPath(pluginRoot, configured, fallback) {
+  const raw = stringValue(configured) || fallback;
+  if (!raw) return "";
+  const resolved = path.resolve(pluginRoot, raw);
+  const relative = path.relative(pluginRoot, resolved);
+  if (relative === ".." || relative.startsWith(`..${path.sep}`) || path.isAbsolute(relative)) return "";
+  if (fs.existsSync(resolved)) {
+    try {
+      const realPluginRoot = fs.realpathSync(pluginRoot);
+      const realResolved = fs.realpathSync(resolved);
+      const realRelative = path.relative(realPluginRoot, realResolved);
+      if (realRelative === ".." || realRelative.startsWith(`..${path.sep}`) || path.isAbsolute(realRelative)) return "";
+    } catch {
+      return "";
+    }
+  }
+  return resolved;
+}
+function addItem(items, item) {
+  if (items.length >= MAX_ITEMS || !item.name || !item.sourceFile) return;
+  const key = `${item.kind}\0${item.sourceFile}\0${item.name}`.toLowerCase();
+  if (items.some((existing) => `${existing.kind}\0${existing.sourceFile}\0${existing.name}`.toLowerCase() === key)) return;
+  items.push(item);
+}
+function parseMarkdownFrontMatter(filePath) {
+  const contents = readText(filePath).slice(0, 32 * 1024);
+  const frontMatter = contents.match(/^---\s*\r?\n([\s\S]*?)\r?\n---\s*(?:\r?\n|$)/)?.[1] || "";
+  const fields = /* @__PURE__ */ new Map();
+  frontMatter.split(/\r?\n/).forEach((line) => {
+    const match = line.match(/^([A-Za-z0-9_-]+):\s*(.*)$/);
+    if (!match) return;
+    fields.set(match[1].toLowerCase(), match[2].trim().replace(/^['"]|['"]$/g, ""));
+  });
+  return {
+    name: stringValue(fields.get("name"), 128),
+    description: stringValue(fields.get("description"))
+  };
+}
+function discoverSkillDirectory(items, homePath, skillsDir, scope, pluginName = "") {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(skillsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  entries.forEach((entry) => {
+    if (!entry.isDirectory() || !SAFE_NAME.test(entry.name)) return;
+    const sourceFile = path.join(skillsDir, entry.name, "SKILL.md");
+    if (!fs.existsSync(sourceFile)) return;
+    const metadata = parseMarkdownFrontMatter(sourceFile);
+    const name = metadata.name || titleFromName(entry.name);
+    addItem(items, {
+      id: `skill:${pluginName || scope}:${entry.name}`,
+      name: pluginName ? `${pluginName}: ${name}` : name,
+      description: metadata.description || `Skill from ${scope.toLowerCase()}`,
+      kind: "skill",
+      scope,
+      status: "configured",
+      sourceFile: sourceFileWithin(homePath, sourceFile)
+    });
+  });
+}
+function discoverCommandDirectory(items, homePath, commandsDir, scope, pluginName = "") {
+  let entries = [];
+  try {
+    entries = fs.readdirSync(commandsDir, { withFileTypes: true });
+  } catch {
+    return;
+  }
+  entries.forEach((entry) => {
+    if (!entry.isFile() || !entry.name.endsWith(".md")) return;
+    const commandName = entry.name.slice(0, -3);
+    if (!SAFE_NAME.test(commandName)) return;
+    const sourceFile = path.join(commandsDir, entry.name);
+    const metadata = parseMarkdownFrontMatter(sourceFile);
+    addItem(items, {
+      id: `command:${pluginName || scope}:${commandName}`,
+      name: pluginName ? `${pluginName}: ${metadata.name || titleFromName(commandName)}` : metadata.name || titleFromName(commandName),
+      description: metadata.description || `Command from ${scope.toLowerCase()}`,
+      kind: "command",
+      scope,
+      status: "configured",
+      sourceFile: sourceFileWithin(homePath, sourceFile)
+    });
+  });
+}
+function mcpStatus(configuration) {
+  return configuration.enabled === false || configuration.disabled === true ? "disabled" : "configured";
+}
+function mcpDescription(configuration) {
+  const explicit = stringValue(configuration.description);
+  if (explicit) return explicit;
+  const command = stringValue(configuration.command, 160);
+  if (command) return `stdio \xB7 ${path.basename(command)}`;
+  const url = stringValue(configuration.url, 300) || stringValue(configuration.serverUrl, 300);
+  if (url) {
+    try {
+      const parsed = new URL(url);
+      return `${parsed.protocol.replace(":", "").toUpperCase()} \xB7 ${parsed.host}`;
+    } catch {
+      return "Remote MCP server";
+    }
+  }
+  return "MCP server configuration";
+}
+function discoverMcpMap(items, homePath, sourceFile, rawMap, scope, pluginName = "") {
+  Object.entries(recordValue(rawMap)).slice(0, MAX_ITEMS).forEach(([name, rawConfiguration]) => {
+    if (!SAFE_NAME.test(name)) return;
+    const configuration = recordValue(rawConfiguration);
+    addItem(items, {
+      id: `mcp:${pluginName || scope}:${name}`,
+      name: stringValue(configuration.title, 128) || (pluginName ? `${pluginName}: ${titleFromName(name)}` : titleFromName(name)),
+      description: mcpDescription(configuration),
+      kind: "mcp",
+      scope,
+      status: mcpStatus(configuration),
+      sourceFile: sourceFileWithin(homePath, sourceFile)
+    });
+  });
+}
+function discoverMcpFile(items, homePath, sourceFile, scope, pluginName = "") {
+  const document = readJson(sourceFile);
+  if (!document) return;
+  discoverMcpMap(items, homePath, sourceFile, document.mcpServers || document.servers || document, scope, pluginName);
+}
+function discoverAgentPluginsV1McpFile(items, homePath, sourceFile, pluginName, schemaVersion) {
+  const document = readJson(sourceFile);
+  if (!document) return;
+  if (document.$schema !== `https://agent-plugins.org/schemas/${schemaVersion}/mcp.schema.json`) return;
+  if (!document.mcpServers || typeof document.mcpServers !== "object" || Array.isArray(document.mcpServers)) return;
+  discoverMcpMap(items, homePath, sourceFile, document.mcpServers, "Plugin", pluginName);
+}
+function discoverHookMap(items, homePath, sourceFile, rawHooks, scope, pluginName = "") {
+  Object.entries(recordValue(rawHooks)).slice(0, MAX_ITEMS).forEach(([eventName, rawGroups]) => {
+    if (!SAFE_NAME.test(eventName)) return;
+    const groups = Array.isArray(rawGroups) ? rawGroups : [rawGroups];
+    let handlerCount = 0;
+    groups.forEach((group) => {
+      const hooks = recordValue(group).hooks;
+      handlerCount += Array.isArray(hooks) ? hooks.length : hooks ? 1 : 0;
+    });
+    addItem(items, {
+      id: `hook:${pluginName || scope}:${eventName}`,
+      name: pluginName ? `${pluginName}: ${titleFromName(eventName)}` : titleFromName(eventName),
+      description: `${handlerCount || groups.length} configured handler${handlerCount === 1 ? "" : "s"}`,
+      kind: "hook",
+      scope,
+      status: "configured",
+      sourceFile: sourceFileWithin(homePath, sourceFile)
+    });
+  });
+}
+function discoverHookFile(items, homePath, sourceFile, scope, pluginName = "") {
+  const document = readJson(sourceFile);
+  if (!document) return;
+  discoverHookMap(items, homePath, sourceFile, document.hooks || document, scope, pluginName);
+}
+function manifestPluginRoot(manifestFile) {
+  const manifestDir = path.dirname(manifestFile);
+  return [".codex-plugin", ".claude-plugin", ".qoder-plugin", ".plugin"].includes(path.basename(manifestDir)) ? path.dirname(manifestDir) : manifestDir;
+}
+function findPluginManifests(root) {
+  const manifests = [];
+  const visit = (directory, depth) => {
+    if (depth > 8 || manifests.length >= MAX_PLUGIN_MANIFESTS) return;
+    let entries = [];
+    try {
+      entries = fs.readdirSync(directory, { withFileTypes: true });
+    } catch {
+      return;
+    }
+    entries.sort((left, right) => left.name.localeCompare(right.name));
+    for (const entry of entries) {
+      if (manifests.length >= MAX_PLUGIN_MANIFESTS) break;
+      if (entry.isDirectory()) {
+        if (entry.name === "node_modules" || entry.name === ".git") continue;
+        visit(path.join(directory, entry.name), depth + 1);
+        continue;
+      }
+      if (entry.name !== "plugin.json") continue;
+      const manifestFile = path.join(directory, entry.name);
+      const parentName = path.basename(directory);
+      if (parentName === ".codex-plugin" || parentName === ".claude-plugin" || parentName === ".qoder-plugin" || parentName === ".plugin" || depth <= 3) {
+        manifests.push(manifestFile);
+      }
+    }
+  };
+  visit(root, 0);
+  return manifests;
+}
+function claudePluginSources(homePath, settings) {
+  const enabledPlugins = recordValue(settings.enabledPlugins);
+  const installedFile = path.join(homePath, "plugins", "installed_plugins.json");
+  const installed = recordValue(readJson(installedFile)?.plugins);
+  const sources = [];
+  Object.entries(installed).slice(0, MAX_PLUGIN_MANIFESTS).forEach(([pluginId, rawEntries]) => {
+    const entries = Array.isArray(rawEntries) ? rawEntries : [];
+    entries.forEach((rawEntry) => {
+      const installPath = stringValue(recordValue(rawEntry).installPath, 2e3);
+      if (!installPath) return;
+      const candidates = [
+        path.join(installPath, ".claude-plugin", "plugin.json"),
+        path.join(installPath, "plugin.json")
+      ];
+      const manifestFile = candidates.find((candidate) => fs.existsSync(candidate));
+      if (!manifestFile) return;
+      sources.push({
+        manifestFile,
+        pluginRoot: manifestPluginRoot(manifestFile),
+        nativeStatus: enabledPlugins[pluginId] === true ? "enabled" : enabledPlugins[pluginId] === false ? "disabled" : "configured"
+      });
+    });
+  });
+  let directEntries = [];
+  try {
+    directEntries = fs.readdirSync(path.join(homePath, "plugins"), { withFileTypes: true });
+  } catch {
+  }
+  directEntries.forEach((entry) => {
+    if (!entry.isDirectory() || entry.name === "cache" || entry.name === "marketplaces") return;
+    const manifestFile = path.join(homePath, "plugins", entry.name, ".claude-plugin", "plugin.json");
+    if (!fs.existsSync(manifestFile)) return;
+    sources.push({
+      manifestFile,
+      pluginRoot: manifestPluginRoot(manifestFile),
+      nativeStatus: "configured"
+    });
+  });
+  return sources;
+}
+function providerPluginSources(homePath, settings) {
+  const enabledPlugins = recordValue(settings.enabledPlugins);
+  return findPluginManifests(path.join(homePath, "plugins")).map((manifestFile) => {
+    const pluginRoot = manifestPluginRoot(manifestFile);
+    const manifest = readJson(manifestFile) || {};
+    const candidateNames = new Set([
+      stringValue(manifest.name, 128),
+      path.basename(pluginRoot)
+    ].filter(Boolean));
+    const nativeEntry = Object.entries(enabledPlugins).find(([pluginId]) => candidateNames.has(pluginId.split("@")[0] || ""));
+    return {
+      manifestFile,
+      pluginRoot,
+      nativeStatus: nativeEntry?.[1] === true ? "enabled" : nativeEntry?.[1] === false ? "disabled" : "configured"
+    };
+  });
+}
+function discoverPlugin(items, homePath, source) {
+  const firstPluginItemIndex = items.length;
+  const manifest = readJson(source.manifestFile);
+  if (!manifest) return;
+  const pluginRoot = source.pluginRoot;
+  const declaredSchema = stringValue(manifest.$schema);
+  const agentPluginsSchema = declaredSchema.match(AGENT_PLUGINS_V1_SCHEMA);
+  if (declaredSchema.startsWith(AGENT_PLUGINS_SCHEMA_PREFIX) && !agentPluginsSchema) return;
+  const agentPluginsSchemaVersion = agentPluginsSchema?.[1] || "";
+  const interfaceMetadata = recordValue(manifest.interface);
+  const rawName = agentPluginsSchemaVersion ? stringValue(manifest.name, 128) : stringValue(manifest.name, 128) || path.basename(pluginRoot);
+  if (agentPluginsSchemaVersion && (!AGENT_PLUGINS_NAME.test(rawName) || rawName.includes("--") || rawName.includes(".."))) return;
+  const pluginName = stringValue(interfaceMetadata.displayName, 128) || stringValue(manifest.displayName, 128) || titleFromName(rawName);
+  const description = stringValue(interfaceMetadata.shortDescription) || stringValue(manifest.description) || "Agent plugin";
+  addItem(items, {
+    id: `plugin:${rawName}`,
+    name: pluginName,
+    description,
+    kind: "plugin",
+    scope: stringValue(manifest.version, 64) ? `Plugin \xB7 ${stringValue(manifest.version, 64)}` : "Plugin",
+    status: source.nativeStatus || "configured",
+    sourceFile: sourceFileWithin(homePath, source.manifestFile)
+  });
+  if (agentPluginsSchemaVersion) {
+    const skillsDir2 = safePluginPath(pluginRoot, "./skills", "");
+    if (skillsDir2) discoverSkillDirectory(items, homePath, skillsDir2, "Plugin", rawName);
+    const mcpFile = safePluginPath(pluginRoot, "./mcp.json", "");
+    if (mcpFile && fs.existsSync(mcpFile)) {
+      discoverAgentPluginsV1McpFile(items, homePath, mcpFile, rawName, agentPluginsSchemaVersion);
+    }
+    return;
+  }
+  const skillsDir = safePluginPath(pluginRoot, manifest.skills, "skills");
+  if (skillsDir) discoverSkillDirectory(items, homePath, skillsDir, "Plugin", rawName);
+  const commandsDir = safePluginPath(pluginRoot, manifest.commands, "commands");
+  if (commandsDir) discoverCommandDirectory(items, homePath, commandsDir, "Plugin", rawName);
+  if (manifest.mcpServers && typeof manifest.mcpServers === "object" && !Array.isArray(manifest.mcpServers)) {
+    discoverMcpMap(items, homePath, source.manifestFile, manifest.mcpServers, "Plugin", rawName);
+  } else {
+    const configuredMcp = safePluginPath(pluginRoot, manifest.mcpServers || manifest.mcp, "");
+    const mcpFile = configuredMcp || [path.join(pluginRoot, "mcp.json"), path.join(pluginRoot, ".mcp.json")].find((candidate) => fs.existsSync(candidate)) || "";
+    if (mcpFile) discoverMcpFile(items, homePath, mcpFile, "Plugin", rawName);
+  }
+  if (manifest.hooks && typeof manifest.hooks === "object" && !Array.isArray(manifest.hooks)) {
+    discoverHookMap(items, homePath, source.manifestFile, manifest.hooks, "Plugin", rawName);
+  } else {
+    const configuredHooks = safePluginPath(pluginRoot, manifest.hooks, "");
+    const hooksFile = configuredHooks || [path.join(pluginRoot, "hooks", "hooks.json"), path.join(pluginRoot, "hooks.json")].find((candidate) => fs.existsSync(candidate)) || "";
+    if (hooksFile) discoverHookFile(items, homePath, hooksFile, "Plugin", rawName);
+  }
+  if (source.nativeStatus === "enabled" || source.nativeStatus === "disabled") {
+    items.slice(firstPluginItemIndex).forEach((item) => {
+      item.status = source.nativeStatus;
+    });
+  }
+}
+function discoverCodexTomlMcp(items, homePath) {
+  const sourceFile = path.join(homePath, "config.toml");
+  const contents = readText(sourceFile);
+  if (!contents) return;
+  const sections = contents.split(/^\s*\[mcp_servers\.((?:"(?:\\.|[^"])*")|[^\]]+)\]\s*$/m);
+  for (let index = 1; index < sections.length; index += 2) {
+    const rawName = (sections[index] || "").trim();
+    if (!rawName.startsWith('"') && rawName.includes(".")) continue;
+    const name = rawName.startsWith('"') ? (() => {
+      try {
+        return JSON.parse(rawName);
+      } catch {
+        return "";
+      }
+    })() : rawName;
+    if (!SAFE_NAME.test(name)) continue;
+    const body = sections[index + 1] || "";
+    const disabled = /^\s*enabled\s*=\s*false\s*(?:#.*)?$/m.test(body);
+    const command = body.match(/^\s*command\s*=\s*["']([^"']+)["']/m)?.[1] || "";
+    addItem(items, {
+      id: `mcp:home:${name}`,
+      name: titleFromName(name),
+      description: command ? `stdio \xB7 ${path.basename(command)}` : "MCP server configuration",
+      kind: "mcp",
+      scope: "Home",
+      status: disabled ? "disabled" : "configured",
+      sourceFile: sourceFileWithin(homePath, sourceFile)
+    });
+  }
+}
+function discoverAgentExtensions({ provider, providerHomePath } = {}) {
+  const normalizedProvider = stringValue(provider, 64).toLowerCase();
+  const rawHomePath = stringValue(providerHomePath, 2e3);
+  if (!normalizedProvider || !rawHomePath) return [];
+  const homePath = path.resolve(rawHomePath);
+  if (!fs.existsSync(homePath)) return [];
+  const items = [];
+  discoverSkillDirectory(items, homePath, path.join(homePath, "skills"), "Home");
+  discoverCommandDirectory(items, homePath, path.join(homePath, "commands"), "Home");
+  const settingsFile = path.join(homePath, "settings.json");
+  const settings = readJson(settingsFile) || {};
+  if (settings.hooks) discoverHookMap(items, homePath, settingsFile, settings.hooks, "Home");
+  if (settings.mcpServers) discoverMcpMap(items, homePath, settingsFile, settings.mcpServers, "Home");
+  const hooksFile = path.join(homePath, "hooks.json");
+  if (fs.existsSync(hooksFile)) discoverHookFile(items, homePath, hooksFile, "Home");
+  const mcpFile = path.join(homePath, "mcp.json");
+  if (fs.existsSync(mcpFile)) discoverMcpFile(items, homePath, mcpFile, "Home");
+  if (normalizedProvider === "codex") discoverCodexTomlMcp(items, homePath);
+  const pluginSources = normalizedProvider === "claude" ? claudePluginSources(homePath, settings) : providerPluginSources(homePath, settings);
+  const seenPluginRoots = /* @__PURE__ */ new Set();
+  pluginSources.forEach((source) => {
+    let canonicalRoot = source.pluginRoot;
+    try {
+      canonicalRoot = fs.realpathSync(source.pluginRoot);
+    } catch {
+    }
+    if (seenPluginRoots.has(canonicalRoot)) return;
+    seenPluginRoots.add(canonicalRoot);
+    discoverPlugin(items, homePath, source);
+  });
+  return items.sort((left, right) => left.kind.localeCompare(right.kind) || left.name.localeCompare(right.name) || left.sourceFile.localeCompare(right.sourceFile));
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  discoverAgentExtensions
+});

package/backend/agent-extension-inventory.cjs

@@ -0,0 +1,116 @@
+// Generated by scripts/build-backend-runtime.ts. Do not edit.
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var agent_extension_inventory_exports = {};
+__export(agent_extension_inventory_exports, {
+  AgentExtensionInventory: () => AgentExtensionInventory,
+  extensionWatchPaths: () => extensionWatchPaths
+});
+module.exports = __toCommonJS(agent_extension_inventory_exports);
+var path = __toESM(require("path"));
+var import_agent_extension_discovery = require("./agent-extension-discovery.cjs");
+var import_provider_home_configuration = require("./provider-home-configuration.cjs");
+var import_authoritative_inventory_cache = require("./authoritative-inventory-cache.cjs");
+function extensionWatchPaths(provider, homePath) {
+  const configurationFiles = import_provider_home_configuration.PROVIDER_CONFIGURATION_FILES[provider] || [];
+  return [
+    path.join(homePath, "skills"),
+    path.join(homePath, "commands"),
+    path.join(homePath, "plugins"),
+    path.join(homePath, "hooks.json"),
+    path.join(homePath, "mcp.json"),
+    ...configurationFiles.map((fileName) => path.join(homePath, fileName))
+  ];
+}
+function inventoryKey(provider, homePath) {
+  return JSON.stringify({
+    version: 1,
+    provider,
+    homePath: path.resolve(homePath)
+  });
+}
+class AgentExtensionInventory {
+  cache;
+  discoverExtensions;
+  readConfiguration;
+  constructor(options) {
+    this.discoverExtensions = options.discoverExtensions || import_agent_extension_discovery.discoverAgentExtensions;
+    this.readConfiguration = options.readConfiguration || import_provider_home_configuration.readProviderHomeConfiguration;
+    this.cache = new import_authoritative_inventory_cache.AuthoritativeInventoryCache({
+      fingerprintOptions: { maxDepth: 12, maxEntries: 2e4 },
+      refreshDebounceMs: 150,
+      snapshotFile: options.cacheFile
+    });
+  }
+  invalidate() {
+    this.cache.invalidate();
+  }
+  close() {
+    return this.cache.close();
+  }
+  get(provider, homePath) {
+    const normalizedProvider = String(provider || "").trim().toLowerCase();
+    const rawHomePath = String(homePath || "").trim();
+    if (!rawHomePath) {
+      return Promise.resolve({
+        configuration: this.readConfiguration(normalizedProvider, ""),
+        extensions: []
+      });
+    }
+    const normalizedHomePath = path.resolve(rawHomePath);
+    const key = inventoryKey(normalizedProvider, normalizedHomePath);
+    return this.cache.get(key, {
+      watchPaths: extensionWatchPaths(normalizedProvider, normalizedHomePath),
+      load: () => ({
+        configuration: this.readConfiguration(normalizedProvider, normalizedHomePath),
+        extensions: this.discoverExtensions({
+          provider: normalizedProvider,
+          providerHomePath: normalizedHomePath
+        })
+      }),
+      validate: (value) => Boolean(
+        value && typeof value === "object" && Array.isArray(value.extensions) && value.configuration && typeof value.configuration === "object"
+      )
+    });
+  }
+  retain(homes) {
+    return this.cache.retain(new Set(homes.flatMap((home) => {
+      const homePath = String(home.path || "").trim();
+      return homePath ? [inventoryKey(
+        String(home.provider || "").trim().toLowerCase(),
+        path.resolve(homePath)
+      )] : [];
+    })));
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AgentExtensionInventory,
+  extensionWatchPaths
+});