@dexto/agent-management 1.5.6 → 1.5.7

package/dist/plugins/marketplace/install-from-marketplace.cjs

@@ -0,0 +1,152 @@
+"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 install_from_marketplace_exports = {};
+__export(install_from_marketplace_exports, {
+  installPluginFromMarketplace: () => installPluginFromMarketplace,
+  parsePluginSpec: () => parsePluginSpec,
+  searchMarketplacePlugins: () => searchMarketplacePlugins
+});
+module.exports = __toCommonJS(install_from_marketplace_exports);
+var path = __toESM(require("path"), 1);
+var import_fs = require("fs");
+var import_child_process = require("child_process");
+var import_path = require("../../utils/path.js");
+var import_registry = require("./registry.js");
+var import_operations = require("./operations.js");
+var import_errors = require("./errors.js");
+var import_install_plugin = require("../install-plugin.js");
+function parsePluginSpec(spec) {
+  const atIndex = spec.lastIndexOf("@");
+  if (atIndex <= 0) {
+    return { pluginName: spec };
+  }
+  return {
+    pluginName: spec.substring(0, atIndex),
+    marketplace: spec.substring(atIndex + 1)
+  };
+}
+function getGitSha(dir) {
+  try {
+    const result = (0, import_child_process.execSync)("git rev-parse HEAD", {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim();
+  } catch {
+    return void 0;
+  }
+}
+function getShortSha(sha) {
+  if (!sha) return "unknown";
+  return sha.substring(0, 8);
+}
+async function installPluginFromMarketplace(pluginSpec, options = {}) {
+  const { scope = "user", projectPath, force = false } = options;
+  const warnings = [];
+  const { pluginName, marketplace: specifiedMarketplace } = parsePluginSpec(pluginSpec);
+  let plugin = null;
+  if (specifiedMarketplace) {
+    const marketplaceEntry2 = (0, import_registry.getMarketplaceEntry)(specifiedMarketplace);
+    if (!marketplaceEntry2) {
+      throw import_errors.MarketplaceError.installMarketplaceNotFound(specifiedMarketplace);
+    }
+    const plugins = (0, import_operations.scanMarketplacePlugins)(
+      marketplaceEntry2.installLocation,
+      marketplaceEntry2.name
+    );
+    plugin = plugins.find((p) => p.name.toLowerCase() === pluginName.toLowerCase()) || null;
+    if (!plugin) {
+      throw import_errors.MarketplaceError.installPluginNotFound(pluginName, specifiedMarketplace);
+    }
+  } else {
+    plugin = (0, import_operations.findPluginInMarketplaces)(pluginName);
+    if (!plugin) {
+      throw import_errors.MarketplaceError.installPluginNotFound(pluginName);
+    }
+    warnings.push(`Found plugin in marketplace: ${plugin.marketplace}`);
+  }
+  const marketplaceEntry = (0, import_registry.getMarketplaceEntry)(plugin.marketplace);
+  let gitCommitSha;
+  if (marketplaceEntry) {
+    gitCommitSha = getGitSha(marketplaceEntry.installLocation);
+  }
+  const cacheDir = (0, import_registry.getMarketplaceCacheDir)();
+  const shortSha = getShortSha(gitCommitSha);
+  const cachePath = path.join(cacheDir, plugin.marketplace, plugin.name, shortSha);
+  if (!(0, import_fs.existsSync)(cachePath)) {
+    try {
+      (0, import_fs.mkdirSync)(cachePath, { recursive: true });
+      await (0, import_path.copyDirectory)(plugin.sourcePath, cachePath);
+    } catch (error) {
+      throw import_errors.MarketplaceError.installCopyFailed(
+        pluginName,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  const installOptions = {
+    scope,
+    force,
+    ...projectPath !== void 0 && { projectPath }
+  };
+  const installResult = await (0, import_install_plugin.installPluginFromPath)(cachePath, installOptions);
+  return {
+    success: installResult.success,
+    pluginName: installResult.pluginName,
+    marketplace: plugin.marketplace,
+    installPath: installResult.installPath,
+    ...gitCommitSha !== void 0 && { gitCommitSha },
+    warnings: [...warnings, ...installResult.warnings]
+  };
+}
+function searchMarketplacePlugins(query, marketplaceName) {
+  const lowerQuery = query.toLowerCase();
+  let plugins;
+  if (marketplaceName) {
+    const entry = (0, import_registry.getMarketplaceEntry)(marketplaceName);
+    if (!entry || !(0, import_fs.existsSync)(entry.installLocation)) {
+      return [];
+    }
+    plugins = (0, import_operations.scanMarketplacePlugins)(entry.installLocation, entry.name);
+  } else {
+    plugins = (0, import_operations.listAllMarketplacePlugins)();
+  }
+  return plugins.filter((p) => {
+    const nameMatch = p.name.toLowerCase().includes(lowerQuery);
+    const descMatch = p.description?.toLowerCase().includes(lowerQuery);
+    return nameMatch || descMatch;
+  });
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  installPluginFromMarketplace,
+  parsePluginSpec,
+  searchMarketplacePlugins
+});

package/dist/plugins/marketplace/install-from-marketplace.d.ts

@@ -0,0 +1,25 @@
+/**
+ * Plugin Installation from Marketplace
+ *
+ * Handles installing plugins from registered marketplaces.
+ */
+import type { MarketplaceInstallOptions, MarketplaceInstallResult, MarketplacePlugin } from './types.js';
+/**
+ * Parse a plugin spec (name or name@marketplace)
+ */
+export declare function parsePluginSpec(spec: string): {
+    pluginName: string;
+    marketplace?: string;
+};
+/**
+ * Install a plugin from a marketplace
+ *
+ * @param pluginSpec Plugin spec in format "name" or "name@marketplace"
+ * @param options Installation options
+ */
+export declare function installPluginFromMarketplace(pluginSpec: string, options?: MarketplaceInstallOptions): Promise<MarketplaceInstallResult>;
+/**
+ * Search for plugins by name pattern across all marketplaces
+ */
+export declare function searchMarketplacePlugins(query: string, marketplaceName?: string): MarketplacePlugin[];
+//# sourceMappingURL=install-from-marketplace.d.ts.map

package/dist/plugins/marketplace/install-from-marketplace.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-from-marketplace.d.ts","sourceRoot":"","sources":["../../../src/plugins/marketplace/install-from-marketplace.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAcH,OAAO,KAAK,EACR,yBAAyB,EACzB,wBAAwB,EACxB,iBAAiB,EACpB,MAAM,YAAY,CAAC;AAGpB;;GAEG;AACH,wBAAgB,eAAe,CAAC,IAAI,EAAE,MAAM,GAAG;IAAE,UAAU,EAAE,MAAM,CAAC;IAAC,WAAW,CAAC,EAAE,MAAM,CAAA;CAAE,CAY1F;AA0BD;;;;;GAKG;AACH,wBAAsB,4BAA4B,CAC9C,UAAU,EAAE,MAAM,EAClB,OAAO,GAAE,yBAA8B,GACxC,OAAO,CAAC,wBAAwB,CAAC,CAgFnC;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACpC,KAAK,EAAE,MAAM,EACb,eAAe,CAAC,EAAE,MAAM,GACzB,iBAAiB,EAAE,CAqBrB"}

package/dist/plugins/marketplace/install-from-marketplace.js

@@ -0,0 +1,120 @@
+import * as path from "path";
+import { existsSync, mkdirSync } from "fs";
+import { execSync } from "child_process";
+import { copyDirectory } from "../../utils/path.js";
+import { getMarketplaceCacheDir, getMarketplaceEntry } from "./registry.js";
+import {
+  findPluginInMarketplaces,
+  scanMarketplacePlugins,
+  listAllMarketplacePlugins
+} from "./operations.js";
+import { MarketplaceError } from "./errors.js";
+import { installPluginFromPath } from "../install-plugin.js";
+function parsePluginSpec(spec) {
+  const atIndex = spec.lastIndexOf("@");
+  if (atIndex <= 0) {
+    return { pluginName: spec };
+  }
+  return {
+    pluginName: spec.substring(0, atIndex),
+    marketplace: spec.substring(atIndex + 1)
+  };
+}
+function getGitSha(dir) {
+  try {
+    const result = execSync("git rev-parse HEAD", {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim();
+  } catch {
+    return void 0;
+  }
+}
+function getShortSha(sha) {
+  if (!sha) return "unknown";
+  return sha.substring(0, 8);
+}
+async function installPluginFromMarketplace(pluginSpec, options = {}) {
+  const { scope = "user", projectPath, force = false } = options;
+  const warnings = [];
+  const { pluginName, marketplace: specifiedMarketplace } = parsePluginSpec(pluginSpec);
+  let plugin = null;
+  if (specifiedMarketplace) {
+    const marketplaceEntry2 = getMarketplaceEntry(specifiedMarketplace);
+    if (!marketplaceEntry2) {
+      throw MarketplaceError.installMarketplaceNotFound(specifiedMarketplace);
+    }
+    const plugins = scanMarketplacePlugins(
+      marketplaceEntry2.installLocation,
+      marketplaceEntry2.name
+    );
+    plugin = plugins.find((p) => p.name.toLowerCase() === pluginName.toLowerCase()) || null;
+    if (!plugin) {
+      throw MarketplaceError.installPluginNotFound(pluginName, specifiedMarketplace);
+    }
+  } else {
+    plugin = findPluginInMarketplaces(pluginName);
+    if (!plugin) {
+      throw MarketplaceError.installPluginNotFound(pluginName);
+    }
+    warnings.push(`Found plugin in marketplace: ${plugin.marketplace}`);
+  }
+  const marketplaceEntry = getMarketplaceEntry(plugin.marketplace);
+  let gitCommitSha;
+  if (marketplaceEntry) {
+    gitCommitSha = getGitSha(marketplaceEntry.installLocation);
+  }
+  const cacheDir = getMarketplaceCacheDir();
+  const shortSha = getShortSha(gitCommitSha);
+  const cachePath = path.join(cacheDir, plugin.marketplace, plugin.name, shortSha);
+  if (!existsSync(cachePath)) {
+    try {
+      mkdirSync(cachePath, { recursive: true });
+      await copyDirectory(plugin.sourcePath, cachePath);
+    } catch (error) {
+      throw MarketplaceError.installCopyFailed(
+        pluginName,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  const installOptions = {
+    scope,
+    force,
+    ...projectPath !== void 0 && { projectPath }
+  };
+  const installResult = await installPluginFromPath(cachePath, installOptions);
+  return {
+    success: installResult.success,
+    pluginName: installResult.pluginName,
+    marketplace: plugin.marketplace,
+    installPath: installResult.installPath,
+    ...gitCommitSha !== void 0 && { gitCommitSha },
+    warnings: [...warnings, ...installResult.warnings]
+  };
+}
+function searchMarketplacePlugins(query, marketplaceName) {
+  const lowerQuery = query.toLowerCase();
+  let plugins;
+  if (marketplaceName) {
+    const entry = getMarketplaceEntry(marketplaceName);
+    if (!entry || !existsSync(entry.installLocation)) {
+      return [];
+    }
+    plugins = scanMarketplacePlugins(entry.installLocation, entry.name);
+  } else {
+    plugins = listAllMarketplacePlugins();
+  }
+  return plugins.filter((p) => {
+    const nameMatch = p.name.toLowerCase().includes(lowerQuery);
+    const descMatch = p.description?.toLowerCase().includes(lowerQuery);
+    return nameMatch || descMatch;
+  });
+}
+export {
+  installPluginFromMarketplace,
+  parsePluginSpec,
+  searchMarketplacePlugins
+};

package/dist/plugins/marketplace/operations.cjs

@@ -0,0 +1,374 @@
+"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 operations_exports = {};
+__export(operations_exports, {
+  addMarketplace: () => addMarketplace,
+  deriveMarketplaceName: () => deriveMarketplaceName,
+  findPluginInMarketplaces: () => findPluginInMarketplaces,
+  listAllMarketplacePlugins: () => listAllMarketplacePlugins,
+  listMarketplaces: () => listMarketplaces,
+  parseMarketplaceSource: () => parseMarketplaceSource,
+  removeMarketplace: () => removeMarketplace,
+  scanMarketplacePlugins: () => scanMarketplacePlugins,
+  updateMarketplace: () => updateMarketplace
+});
+module.exports = __toCommonJS(operations_exports);
+var path = __toESM(require("path"), 1);
+var import_fs = require("fs");
+var import_child_process = require("child_process");
+var import_registry = require("./registry.js");
+var import_errors = require("./errors.js");
+var import_schemas = require("./schemas.js");
+var import_validate_plugin = require("../validate-plugin.js");
+function parseMarketplaceSource(source) {
+  const trimmed = source.trim();
+  if (trimmed.startsWith("/") || trimmed.startsWith("./") || trimmed.startsWith("../") || trimmed.startsWith("~/")) {
+    return { type: "local", value: trimmed };
+  }
+  if (trimmed.includes("://") || trimmed.endsWith(".git")) {
+    return { type: "git", value: trimmed };
+  }
+  const githubMatch = /^([a-zA-Z0-9_-]+)\/([a-zA-Z0-9_.-]+)$/.exec(trimmed);
+  if (githubMatch) {
+    return { type: "github", value: trimmed };
+  }
+  return { type: "git", value: trimmed };
+}
+function deriveMarketplaceName(source) {
+  switch (source.type) {
+    case "github": {
+      const parts = source.value.split("/");
+      return parts[parts.length - 1] ?? source.value;
+    }
+    case "git": {
+      const url = source.value.replace(/\.git$/, "");
+      const parts = url.split("/");
+      return parts[parts.length - 1] ?? "marketplace";
+    }
+    case "local": {
+      const resolved = source.value.startsWith("~") ? source.value.replace("~", process.env.HOME || "") : path.resolve(source.value);
+      return path.basename(resolved);
+    }
+  }
+}
+function getCloneUrl(source) {
+  switch (source.type) {
+    case "github":
+      return `https://github.com/${source.value}.git`;
+    case "git":
+      return source.value;
+    case "local":
+      throw new Error("Cannot clone local source");
+  }
+}
+function getGitSha(dir) {
+  try {
+    const result = (0, import_child_process.execSync)("git rev-parse HEAD", {
+      cwd: dir,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+    return result.trim();
+  } catch {
+    return void 0;
+  }
+}
+async function addMarketplace(source, options = {}) {
+  const parsedSource = parseMarketplaceSource(source);
+  const name = options.name || deriveMarketplaceName(parsedSource);
+  const warnings = [];
+  const existing = (0, import_registry.getMarketplaceEntry)(name);
+  if (existing) {
+    throw import_errors.MarketplaceError.addAlreadyExists(name, existing.installLocation);
+  }
+  let installLocation;
+  if (parsedSource.type === "local") {
+    const localPath = parsedSource.value.startsWith("~") ? parsedSource.value.replace("~", process.env.HOME || "") : path.resolve(parsedSource.value);
+    if (!(0, import_fs.existsSync)(localPath)) {
+      throw import_errors.MarketplaceError.addLocalNotFound(localPath);
+    }
+    installLocation = localPath;
+  } else {
+    const marketplacesDir = (0, import_registry.getMarketplacesDir)();
+    installLocation = path.join(marketplacesDir, name);
+    const cloneUrl = getCloneUrl(parsedSource);
+    try {
+      (0, import_child_process.execSync)(`git clone "${cloneUrl}" "${installLocation}"`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch (error) {
+      throw import_errors.MarketplaceError.addCloneFailed(
+        source,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  const plugins = scanMarketplacePlugins(installLocation, name);
+  if (plugins.length === 0) {
+    warnings.push("No plugins found in marketplace");
+  }
+  const entry = {
+    name,
+    source: parsedSource,
+    installLocation,
+    lastUpdated: (/* @__PURE__ */ new Date()).toISOString()
+  };
+  (0, import_registry.addMarketplaceEntry)(entry);
+  return {
+    success: true,
+    name,
+    pluginCount: plugins.length,
+    warnings
+  };
+}
+async function removeMarketplace(name) {
+  const entry = (0, import_registry.getMarketplaceEntry)(name);
+  if (!entry) {
+    throw import_errors.MarketplaceError.removeNotFound(name);
+  }
+  if (entry.source.type !== "local") {
+    try {
+      if ((0, import_fs.existsSync)(entry.installLocation)) {
+        (0, import_fs.rmSync)(entry.installLocation, { recursive: true, force: true });
+      }
+    } catch (error) {
+      throw import_errors.MarketplaceError.removeDeleteFailed(
+        name,
+        entry.installLocation,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  (0, import_registry.removeMarketplaceEntry)(name);
+  return {
+    success: true,
+    name
+  };
+}
+async function updateMarketplace(name) {
+  const results = [];
+  if (name) {
+    const result = await updateSingleMarketplace(name);
+    results.push(result);
+  } else {
+    const marketplaces = (0, import_registry.getAllMarketplaces)();
+    for (const marketplace of marketplaces) {
+      const result = await updateSingleMarketplace(marketplace.name);
+      results.push(result);
+    }
+  }
+  return results;
+}
+async function updateSingleMarketplace(name) {
+  const entry = (0, import_registry.getMarketplaceEntry)(name);
+  if (!entry) {
+    throw import_errors.MarketplaceError.updateNotFound(name);
+  }
+  const warnings = [];
+  if (entry.source.type === "local") {
+    return {
+      success: true,
+      name,
+      hasChanges: false,
+      warnings: ["Local marketplaces do not support automatic updates"]
+    };
+  }
+  if (!(0, import_fs.existsSync)(entry.installLocation)) {
+    warnings.push("Marketplace directory not found, re-cloning");
+    const cloneUrl = getCloneUrl(entry.source);
+    try {
+      (0, import_child_process.execSync)(`git clone "${cloneUrl}" "${entry.installLocation}"`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch (error) {
+      throw import_errors.MarketplaceError.updatePullFailed(
+        name,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    (0, import_registry.updateMarketplaceTimestamp)(name);
+    const newShaValue2 = getGitSha(entry.installLocation);
+    return {
+      success: true,
+      name,
+      ...newShaValue2 !== void 0 && { newSha: newShaValue2 },
+      hasChanges: true,
+      warnings
+    };
+  }
+  const previousShaValue = getGitSha(entry.installLocation);
+  try {
+    (0, import_child_process.execSync)("git pull --ff-only", {
+      cwd: entry.installLocation,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (error) {
+    throw import_errors.MarketplaceError.updatePullFailed(
+      name,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  const newShaValue = getGitSha(entry.installLocation);
+  const hasChanges = previousShaValue !== newShaValue;
+  if (hasChanges) {
+    (0, import_registry.updateMarketplaceTimestamp)(name);
+  }
+  return {
+    success: true,
+    name,
+    ...previousShaValue !== void 0 && { previousSha: previousShaValue },
+    ...newShaValue !== void 0 && { newSha: newShaValue },
+    hasChanges,
+    warnings
+  };
+}
+function listMarketplaces() {
+  return (0, import_registry.getAllMarketplaces)();
+}
+function scanMarketplacePlugins(marketplacePath, marketplaceName) {
+  const plugins = [];
+  const manifestPath = path.join(marketplacePath, "marketplace.json");
+  if ((0, import_fs.existsSync)(manifestPath)) {
+    try {
+      const content = (0, import_fs.readFileSync)(manifestPath, "utf-8");
+      const parsed = JSON.parse(content);
+      const result = import_schemas.MarketplaceManifestSchema.safeParse(parsed);
+      if (result.success) {
+        const manifest = result.data;
+        if (manifest.plugins && manifest.plugins.length > 0) {
+          for (const plugin of manifest.plugins) {
+            const pluginPath = path.join(marketplacePath, plugin.source);
+            if ((0, import_fs.existsSync)(pluginPath)) {
+              plugins.push({
+                name: plugin.name,
+                ...plugin.description !== void 0 && {
+                  description: plugin.description
+                },
+                ...plugin.version !== void 0 && { version: plugin.version },
+                ...plugin.category !== void 0 && { category: plugin.category },
+                sourcePath: pluginPath,
+                marketplace: marketplaceName
+              });
+            }
+          }
+          return plugins;
+        }
+      }
+    } catch {
+    }
+  }
+  const pluginDirs = ["plugins", "external_plugins"];
+  for (const dir of pluginDirs) {
+    const dirPath = path.join(marketplacePath, dir);
+    if (!(0, import_fs.existsSync)(dirPath)) continue;
+    try {
+      const entries = (0, import_fs.readdirSync)(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const pluginPath = path.join(dirPath, entry.name);
+        const manifest = (0, import_validate_plugin.tryLoadManifest)(pluginPath);
+        if (manifest) {
+          plugins.push({
+            name: manifest.name,
+            ...manifest.description !== void 0 && {
+              description: manifest.description
+            },
+            ...manifest.version !== void 0 && { version: manifest.version },
+            sourcePath: pluginPath,
+            marketplace: marketplaceName
+          });
+        }
+      }
+    } catch {
+    }
+  }
+  try {
+    const rootEntries = (0, import_fs.readdirSync)(marketplacePath, { withFileTypes: true });
+    for (const entry of rootEntries) {
+      if (!entry.isDirectory()) continue;
+      if (["plugins", "external_plugins", ".git", "node_modules"].includes(entry.name))
+        continue;
+      const pluginPath = path.join(marketplacePath, entry.name);
+      const manifest = (0, import_validate_plugin.tryLoadManifest)(pluginPath);
+      if (manifest) {
+        const existing = plugins.find((p) => p.name === manifest.name);
+        if (!existing) {
+          plugins.push({
+            name: manifest.name,
+            ...manifest.description !== void 0 && {
+              description: manifest.description
+            },
+            ...manifest.version !== void 0 && { version: manifest.version },
+            sourcePath: pluginPath,
+            marketplace: marketplaceName
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return plugins;
+}
+function listAllMarketplacePlugins() {
+  const marketplaces = listMarketplaces();
+  const allPlugins = [];
+  for (const marketplace of marketplaces) {
+    if (!(0, import_fs.existsSync)(marketplace.installLocation)) continue;
+    const plugins = scanMarketplacePlugins(marketplace.installLocation, marketplace.name);
+    allPlugins.push(...plugins);
+  }
+  return allPlugins;
+}
+function findPluginInMarketplaces(pluginName, marketplaceName) {
+  const marketplaces = marketplaceName ? [(0, import_registry.getMarketplaceEntry)(marketplaceName)].filter(Boolean) : listMarketplaces();
+  for (const marketplace of marketplaces) {
+    if (!(0, import_fs.existsSync)(marketplace.installLocation)) continue;
+    const plugins = scanMarketplacePlugins(marketplace.installLocation, marketplace.name);
+    const found = plugins.find((p) => p.name.toLowerCase() === pluginName.toLowerCase());
+    if (found) {
+      return found;
+    }
+  }
+  return null;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  addMarketplace,
+  deriveMarketplaceName,
+  findPluginInMarketplaces,
+  listAllMarketplacePlugins,
+  listMarketplaces,
+  parseMarketplaceSource,
+  removeMarketplace,
+  scanMarketplacePlugins,
+  updateMarketplace
+});