@dexto/agent-management 1.5.6 → 1.5.8

package/dist/plugins/index.js

@@ -0,0 +1,115 @@
+import {
+  PluginManifestSchema,
+  DextoPluginManifestSchema,
+  PluginMCPConfigSchema,
+  InstalledPluginEntrySchema,
+  InstalledPluginsFileSchema
+} from "./schemas.js";
+import { PluginErrorCode } from "./error-codes.js";
+import { PluginError } from "./errors.js";
+import {
+  discoverClaudeCodePlugins,
+  getPluginSearchPaths,
+  getInstalledPluginsPath
+} from "./discover-plugins.js";
+import { discoverStandaloneSkills, getSkillSearchPaths } from "./discover-skills.js";
+import { loadClaudeCodePlugin } from "./load-plugin.js";
+import { validatePluginDirectory, tryLoadManifest } from "./validate-plugin.js";
+import { listInstalledPlugins, getDextoInstalledPluginsPath } from "./list-plugins.js";
+import {
+  installPluginFromPath,
+  loadDextoInstalledPlugins,
+  saveDextoInstalledPlugins,
+  isPluginInstalled
+} from "./install-plugin.js";
+import { uninstallPlugin } from "./uninstall-plugin.js";
+import {
+  MarketplaceSourceSchema,
+  MarketplaceEntrySchema,
+  KnownMarketplacesFileSchema,
+  MarketplaceManifestSchema,
+  MarketplacePluginEntrySchema,
+  MarketplaceAddCommandSchema,
+  MarketplaceInstallCommandSchema,
+  MarketplaceErrorCode,
+  MarketplaceError,
+  DEFAULT_MARKETPLACES,
+  getMarketplacesRegistryPath,
+  getMarketplacesDir,
+  getMarketplaceCacheDir,
+  loadKnownMarketplaces,
+  saveKnownMarketplaces,
+  getMarketplaceEntry,
+  marketplaceExists,
+  getAllMarketplaces,
+  getUninstalledDefaults,
+  isDefaultMarketplace,
+  parseMarketplaceSource,
+  deriveMarketplaceName,
+  addMarketplace,
+  removeMarketplace,
+  updateMarketplace,
+  listMarketplaces,
+  scanMarketplacePlugins,
+  listAllMarketplacePlugins,
+  findPluginInMarketplaces,
+  parsePluginSpec,
+  installPluginFromMarketplace,
+  searchMarketplacePlugins
+} from "./marketplace/index.js";
+export {
+  DEFAULT_MARKETPLACES,
+  DextoPluginManifestSchema,
+  InstalledPluginEntrySchema,
+  InstalledPluginsFileSchema,
+  KnownMarketplacesFileSchema,
+  MarketplaceAddCommandSchema,
+  MarketplaceEntrySchema,
+  MarketplaceError,
+  MarketplaceErrorCode,
+  MarketplaceInstallCommandSchema,
+  MarketplaceManifestSchema,
+  MarketplacePluginEntrySchema,
+  MarketplaceSourceSchema,
+  PluginError,
+  PluginErrorCode,
+  PluginMCPConfigSchema,
+  PluginManifestSchema,
+  addMarketplace,
+  deriveMarketplaceName,
+  discoverClaudeCodePlugins,
+  discoverStandaloneSkills,
+  findPluginInMarketplaces,
+  getAllMarketplaces,
+  getDextoInstalledPluginsPath,
+  getInstalledPluginsPath,
+  getMarketplaceCacheDir,
+  getMarketplaceEntry,
+  getMarketplacesDir,
+  getMarketplacesRegistryPath,
+  getPluginSearchPaths,
+  getSkillSearchPaths,
+  getUninstalledDefaults,
+  installPluginFromMarketplace,
+  installPluginFromPath,
+  isDefaultMarketplace,
+  isPluginInstalled,
+  listAllMarketplacePlugins,
+  listInstalledPlugins,
+  listMarketplaces,
+  loadClaudeCodePlugin,
+  loadDextoInstalledPlugins,
+  loadKnownMarketplaces,
+  marketplaceExists,
+  parseMarketplaceSource,
+  parsePluginSpec,
+  removeMarketplace,
+  saveDextoInstalledPlugins,
+  saveKnownMarketplaces,
+  scanMarketplacePlugins,
+  searchMarketplacePlugins,
+  tryLoadManifest,
+  uninstallPlugin,
+  updateMarketplace,
+  validatePluginDirectory
+};

package/dist/plugins/install-plugin.cjs

@@ -0,0 +1,211 @@
+"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_plugin_exports = {};
+__export(install_plugin_exports, {
+  getDextoInstalledPluginsPath: () => getDextoInstalledPluginsPath,
+  installPluginFromPath: () => installPluginFromPath,
+  isPluginInstalled: () => isPluginInstalled,
+  loadDextoInstalledPlugins: () => loadDextoInstalledPlugins,
+  saveDextoInstalledPlugins: () => saveDextoInstalledPlugins
+});
+module.exports = __toCommonJS(install_plugin_exports);
+var path = __toESM(require("path"), 1);
+var import_fs = require("fs");
+var import_path = require("../utils/path.js");
+var import_validate_plugin = require("./validate-plugin.js");
+var import_errors = require("./errors.js");
+var import_schemas = require("./schemas.js");
+function getDextoInstalledPluginsPath() {
+  return (0, import_path.getDextoGlobalPath)("plugins", "installed_plugins.json");
+}
+function loadDextoInstalledPlugins() {
+  const filePath = getDextoInstalledPluginsPath();
+  if (!(0, import_fs.existsSync)(filePath)) {
+    return { version: 1, plugins: {} };
+  }
+  try {
+    const content = (0, import_fs.readFileSync)(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    const result = import_schemas.InstalledPluginsFileSchema.safeParse(parsed);
+    if (!result.success) {
+      return { version: 1, plugins: {} };
+    }
+    return result.data;
+  } catch {
+    return { version: 1, plugins: {} };
+  }
+}
+function saveDextoInstalledPlugins(data) {
+  const filePath = getDextoInstalledPluginsPath();
+  const dirPath = path.dirname(filePath);
+  if (!(0, import_fs.existsSync)(dirPath)) {
+    (0, import_fs.mkdirSync)(dirPath, { recursive: true });
+  }
+  try {
+    (0, import_fs.writeFileSync)(filePath, JSON.stringify(data, null, 2), "utf-8");
+  } catch (error) {
+    throw import_errors.PluginError.installManifestWriteFailed(
+      filePath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function isPluginInstalled(pluginName, projectPath) {
+  const installed = loadDextoInstalledPlugins();
+  const normalizedName = pluginName.toLowerCase();
+  for (const [_id, installations] of Object.entries(installed.plugins)) {
+    for (const installation of installations) {
+      const manifestPath = path.join(
+        installation.installPath,
+        ".claude-plugin",
+        "plugin.json"
+      );
+      if (!(0, import_fs.existsSync)(manifestPath)) continue;
+      try {
+        const content = (0, import_fs.readFileSync)(manifestPath, "utf-8");
+        const manifest = JSON.parse(content);
+        if (manifest.name?.toLowerCase() === normalizedName) {
+          if ((installation.scope === "project" || installation.scope === "local") && installation.projectPath) {
+            if (projectPath) {
+              const normalizedInstallProject = path.resolve(installation.projectPath).toLowerCase();
+              const normalizedCurrentProject = path.resolve(projectPath).toLowerCase();
+              if (normalizedInstallProject === normalizedCurrentProject) {
+                return installation;
+              }
+            }
+            continue;
+          }
+          return installation;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+async function installPluginFromPath(sourcePath, options) {
+  const { scope, projectPath, force = false } = options;
+  const warnings = [];
+  const absoluteSourcePath = path.isAbsolute(sourcePath) ? sourcePath : path.resolve(sourcePath);
+  const validation = (0, import_validate_plugin.validatePluginDirectory)(absoluteSourcePath);
+  if (!validation.valid) {
+    throw import_errors.PluginError.installSourceNotFound(absoluteSourcePath);
+  }
+  if (!validation.manifest) {
+    throw import_errors.PluginError.installSourceNotFound(absoluteSourcePath);
+  }
+  warnings.push(...validation.warnings);
+  const pluginName = validation.manifest.name;
+  const currentProjectPath = projectPath || process.cwd();
+  const existingInstall = isPluginInstalled(pluginName, currentProjectPath);
+  if (existingInstall && !force) {
+    throw import_errors.PluginError.installAlreadyExists(pluginName, existingInstall.installPath);
+  }
+  let installPath;
+  let isLocal = false;
+  switch (scope) {
+    case "user":
+      installPath = path.join((0, import_path.getDextoGlobalPath)("plugins"), pluginName);
+      break;
+    case "project":
+      installPath = path.join(currentProjectPath, ".dexto", "plugins", pluginName);
+      break;
+    case "local":
+      installPath = absoluteSourcePath;
+      isLocal = true;
+      break;
+    default:
+      throw import_errors.PluginError.invalidScope(scope);
+  }
+  if (!isLocal) {
+    if (existingInstall && force) {
+      try {
+        (0, import_fs.rmSync)(existingInstall.installPath, { recursive: true, force: true });
+      } catch (error) {
+        throw import_errors.PluginError.installCopyFailed(
+          absoluteSourcePath,
+          installPath,
+          `Failed to remove existing: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    const parentDir = path.dirname(installPath);
+    if (!(0, import_fs.existsSync)(parentDir)) {
+      (0, import_fs.mkdirSync)(parentDir, { recursive: true });
+    }
+    try {
+      await (0, import_path.copyDirectory)(absoluteSourcePath, installPath);
+    } catch (error) {
+      throw import_errors.PluginError.installCopyFailed(
+        absoluteSourcePath,
+        installPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  const installed = loadDextoInstalledPlugins();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = {
+    scope,
+    installPath,
+    version: validation.manifest.version,
+    installedAt: now,
+    lastUpdated: now,
+    ...scope !== "user" && { projectPath: currentProjectPath },
+    ...isLocal && { isLocal: true }
+  };
+  if (!installed.plugins[pluginName]) {
+    installed.plugins[pluginName] = [];
+  }
+  installed.plugins[pluginName] = installed.plugins[pluginName].filter((e) => {
+    if (e.scope !== scope) return true;
+    if (scope === "user") return false;
+    if (e.projectPath && currentProjectPath) {
+      return path.resolve(e.projectPath).toLowerCase() !== path.resolve(currentProjectPath).toLowerCase();
+    }
+    return true;
+  });
+  installed.plugins[pluginName].push(entry);
+  saveDextoInstalledPlugins(installed);
+  return {
+    success: true,
+    pluginName,
+    installPath,
+    warnings
+  };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDextoInstalledPluginsPath,
+  installPluginFromPath,
+  isPluginInstalled,
+  loadDextoInstalledPlugins,
+  saveDextoInstalledPlugins
+});

package/dist/plugins/install-plugin.d.ts

@@ -0,0 +1,47 @@
+/**
+ * Plugin Installation
+ *
+ * Installs plugins from local directories to Dexto's plugin directory.
+ * Manages Dexto's own installed_plugins.json for tracking installations.
+ */
+import type { PluginInstallScope, PluginInstallResult, InstalledPluginsFile, InstalledPluginEntry } from './types.js';
+/**
+ * Options for plugin installation
+ */
+export interface InstallPluginOptions {
+    /** Installation scope: 'user', 'project', or 'local' */
+    scope: PluginInstallScope;
+    /** Project path for project-scoped plugins */
+    projectPath?: string;
+    /** Force overwrite if plugin already exists */
+    force?: boolean;
+}
+/**
+ * Path to Dexto's installed_plugins.json
+ */
+export declare function getDextoInstalledPluginsPath(): string;
+/**
+ * Loads Dexto's installed_plugins.json
+ */
+export declare function loadDextoInstalledPlugins(): InstalledPluginsFile;
+/**
+ * Saves Dexto's installed_plugins.json
+ */
+export declare function saveDextoInstalledPlugins(data: InstalledPluginsFile): void;
+/**
+ * Checks if a plugin is already installed.
+ *
+ * @param pluginName Plugin name to check
+ * @param projectPath Optional project path for project-scoped check
+ * @returns Installation entry if found, null otherwise
+ */
+export declare function isPluginInstalled(pluginName: string, projectPath?: string): InstalledPluginEntry | null;
+/**
+ * Installs a plugin from a local directory.
+ *
+ * @param sourcePath Absolute or relative path to the plugin source directory
+ * @param options Installation options
+ * @returns Installation result with success status and warnings
+ */
+export declare function installPluginFromPath(sourcePath: string, options: InstallPluginOptions): Promise<PluginInstallResult>;
+//# sourceMappingURL=install-plugin.d.ts.map

package/dist/plugins/install-plugin.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"install-plugin.d.ts","sourceRoot":"","sources":["../../src/plugins/install-plugin.ts"],"names":[],"mappings":"AAAA;;;;;GAKG;AAQH,OAAO,KAAK,EACR,kBAAkB,EAClB,mBAAmB,EACnB,oBAAoB,EACpB,oBAAoB,EACvB,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,MAAM,WAAW,oBAAoB;IACjC,wDAAwD;IACxD,KAAK,EAAE,kBAAkB,CAAC;IAC1B,8CAA8C;IAC9C,WAAW,CAAC,EAAE,MAAM,CAAC;IACrB,+CAA+C;IAC/C,KAAK,CAAC,EAAE,OAAO,CAAC;CACnB;AAED;;GAEG;AACH,wBAAgB,4BAA4B,IAAI,MAAM,CAErD;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,oBAAoB,CAsBhE;AAED;;GAEG;AACH,wBAAgB,yBAAyB,CAAC,IAAI,EAAE,oBAAoB,GAAG,IAAI,CAiB1E;AAED;;;;;;GAMG;AACH,wBAAgB,iBAAiB,CAC7B,UAAU,EAAE,MAAM,EAClB,WAAW,CAAC,EAAE,MAAM,GACrB,oBAAoB,GAAG,IAAI,CA+C7B;AAED;;;;;;GAMG;AACH,wBAAsB,qBAAqB,CACvC,UAAU,EAAE,MAAM,EAClB,OAAO,EAAE,oBAAoB,GAC9B,OAAO,CAAC,mBAAmB,CAAC,CA6H9B"}

package/dist/plugins/install-plugin.js

@@ -0,0 +1,173 @@
+import * as path from "path";
+import { existsSync, readFileSync, writeFileSync, mkdirSync, rmSync } from "fs";
+import { getDextoGlobalPath, copyDirectory } from "../utils/path.js";
+import { validatePluginDirectory } from "./validate-plugin.js";
+import { PluginError } from "./errors.js";
+import { InstalledPluginsFileSchema } from "./schemas.js";
+function getDextoInstalledPluginsPath() {
+  return getDextoGlobalPath("plugins", "installed_plugins.json");
+}
+function loadDextoInstalledPlugins() {
+  const filePath = getDextoInstalledPluginsPath();
+  if (!existsSync(filePath)) {
+    return { version: 1, plugins: {} };
+  }
+  try {
+    const content = readFileSync(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    const result = InstalledPluginsFileSchema.safeParse(parsed);
+    if (!result.success) {
+      return { version: 1, plugins: {} };
+    }
+    return result.data;
+  } catch {
+    return { version: 1, plugins: {} };
+  }
+}
+function saveDextoInstalledPlugins(data) {
+  const filePath = getDextoInstalledPluginsPath();
+  const dirPath = path.dirname(filePath);
+  if (!existsSync(dirPath)) {
+    mkdirSync(dirPath, { recursive: true });
+  }
+  try {
+    writeFileSync(filePath, JSON.stringify(data, null, 2), "utf-8");
+  } catch (error) {
+    throw PluginError.installManifestWriteFailed(
+      filePath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function isPluginInstalled(pluginName, projectPath) {
+  const installed = loadDextoInstalledPlugins();
+  const normalizedName = pluginName.toLowerCase();
+  for (const [_id, installations] of Object.entries(installed.plugins)) {
+    for (const installation of installations) {
+      const manifestPath = path.join(
+        installation.installPath,
+        ".claude-plugin",
+        "plugin.json"
+      );
+      if (!existsSync(manifestPath)) continue;
+      try {
+        const content = readFileSync(manifestPath, "utf-8");
+        const manifest = JSON.parse(content);
+        if (manifest.name?.toLowerCase() === normalizedName) {
+          if ((installation.scope === "project" || installation.scope === "local") && installation.projectPath) {
+            if (projectPath) {
+              const normalizedInstallProject = path.resolve(installation.projectPath).toLowerCase();
+              const normalizedCurrentProject = path.resolve(projectPath).toLowerCase();
+              if (normalizedInstallProject === normalizedCurrentProject) {
+                return installation;
+              }
+            }
+            continue;
+          }
+          return installation;
+        }
+      } catch {
+        continue;
+      }
+    }
+  }
+  return null;
+}
+async function installPluginFromPath(sourcePath, options) {
+  const { scope, projectPath, force = false } = options;
+  const warnings = [];
+  const absoluteSourcePath = path.isAbsolute(sourcePath) ? sourcePath : path.resolve(sourcePath);
+  const validation = validatePluginDirectory(absoluteSourcePath);
+  if (!validation.valid) {
+    throw PluginError.installSourceNotFound(absoluteSourcePath);
+  }
+  if (!validation.manifest) {
+    throw PluginError.installSourceNotFound(absoluteSourcePath);
+  }
+  warnings.push(...validation.warnings);
+  const pluginName = validation.manifest.name;
+  const currentProjectPath = projectPath || process.cwd();
+  const existingInstall = isPluginInstalled(pluginName, currentProjectPath);
+  if (existingInstall && !force) {
+    throw PluginError.installAlreadyExists(pluginName, existingInstall.installPath);
+  }
+  let installPath;
+  let isLocal = false;
+  switch (scope) {
+    case "user":
+      installPath = path.join(getDextoGlobalPath("plugins"), pluginName);
+      break;
+    case "project":
+      installPath = path.join(currentProjectPath, ".dexto", "plugins", pluginName);
+      break;
+    case "local":
+      installPath = absoluteSourcePath;
+      isLocal = true;
+      break;
+    default:
+      throw PluginError.invalidScope(scope);
+  }
+  if (!isLocal) {
+    if (existingInstall && force) {
+      try {
+        rmSync(existingInstall.installPath, { recursive: true, force: true });
+      } catch (error) {
+        throw PluginError.installCopyFailed(
+          absoluteSourcePath,
+          installPath,
+          `Failed to remove existing: ${error instanceof Error ? error.message : String(error)}`
+        );
+      }
+    }
+    const parentDir = path.dirname(installPath);
+    if (!existsSync(parentDir)) {
+      mkdirSync(parentDir, { recursive: true });
+    }
+    try {
+      await copyDirectory(absoluteSourcePath, installPath);
+    } catch (error) {
+      throw PluginError.installCopyFailed(
+        absoluteSourcePath,
+        installPath,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  const installed = loadDextoInstalledPlugins();
+  const now = (/* @__PURE__ */ new Date()).toISOString();
+  const entry = {
+    scope,
+    installPath,
+    version: validation.manifest.version,
+    installedAt: now,
+    lastUpdated: now,
+    ...scope !== "user" && { projectPath: currentProjectPath },
+    ...isLocal && { isLocal: true }
+  };
+  if (!installed.plugins[pluginName]) {
+    installed.plugins[pluginName] = [];
+  }
+  installed.plugins[pluginName] = installed.plugins[pluginName].filter((e) => {
+    if (e.scope !== scope) return true;
+    if (scope === "user") return false;
+    if (e.projectPath && currentProjectPath) {
+      return path.resolve(e.projectPath).toLowerCase() !== path.resolve(currentProjectPath).toLowerCase();
+    }
+    return true;
+  });
+  installed.plugins[pluginName].push(entry);
+  saveDextoInstalledPlugins(installed);
+  return {
+    success: true,
+    pluginName,
+    installPath,
+    warnings
+  };
+}
+export {
+  getDextoInstalledPluginsPath,
+  installPluginFromPath,
+  isPluginInstalled,
+  loadDextoInstalledPlugins,
+  saveDextoInstalledPlugins
+};

package/dist/plugins/list-plugins.cjs

@@ -0,0 +1,134 @@
+"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 list_plugins_exports = {};
+__export(list_plugins_exports, {
+  getDextoInstalledPluginsPath: () => getDextoInstalledPluginsPath,
+  listInstalledPlugins: () => listInstalledPlugins
+});
+module.exports = __toCommonJS(list_plugins_exports);
+var path = __toESM(require("path"), 1);
+var import_fs = require("fs");
+var import_path = require("../utils/path.js");
+var import_schemas = require("./schemas.js");
+var import_validate_plugin = require("./validate-plugin.js");
+function getDextoInstalledPluginsPath() {
+  return (0, import_path.getDextoGlobalPath)("plugins", "installed_plugins.json");
+}
+function listInstalledPlugins(projectPath) {
+  const plugins = [];
+  const seenNames = /* @__PURE__ */ new Set();
+  const cwd = projectPath || process.cwd();
+  const addPlugin = (plugin) => {
+    const normalizedName = plugin.name.toLowerCase();
+    if (seenNames.has(normalizedName)) {
+      return false;
+    }
+    seenNames.add(normalizedName);
+    plugins.push(plugin);
+    return true;
+  };
+  const { plugins: dextoPlugins } = readDextoInstalledPlugins(cwd);
+  for (const plugin of dextoPlugins) {
+    addPlugin(plugin);
+  }
+  const scanPluginsDir = (dir) => {
+    if (!(0, import_fs.existsSync)(dir)) return;
+    try {
+      const entries = (0, import_fs.readdirSync)(dir, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (entry.name === "cache" || entry.name === "marketplaces") continue;
+        const pluginPath = path.join(dir, entry.name);
+        const manifest = (0, import_validate_plugin.tryLoadManifest)(pluginPath);
+        if (manifest) {
+          addPlugin({
+            name: manifest.name,
+            description: manifest.description,
+            version: manifest.version,
+            path: pluginPath,
+            source: "dexto"
+          });
+        }
+      }
+    } catch {
+    }
+  };
+  scanPluginsDir(path.join(cwd, ".dexto", "plugins"));
+  scanPluginsDir((0, import_path.getDextoGlobalPath)("plugins"));
+  return plugins;
+}
+function readDextoInstalledPlugins(currentProjectPath) {
+  const plugins = [];
+  const filePath = getDextoInstalledPluginsPath();
+  if (!(0, import_fs.existsSync)(filePath)) {
+    return { plugins };
+  }
+  try {
+    const content = (0, import_fs.readFileSync)(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    const result = import_schemas.InstalledPluginsFileSchema.safeParse(parsed);
+    if (!result.success) {
+      return { plugins };
+    }
+    for (const [_pluginId, installations] of Object.entries(result.data.plugins)) {
+      for (const installation of installations) {
+        const { scope, installPath, version, installedAt, projectPath } = installation;
+        if (!(0, import_fs.existsSync)(installPath)) {
+          continue;
+        }
+        const manifest = (0, import_validate_plugin.tryLoadManifest)(installPath);
+        if (manifest) {
+          if ((scope === "project" || scope === "local") && projectPath) {
+            const normalizedProjectPath = path.resolve(projectPath).toLowerCase();
+            const normalizedCurrentPath = path.resolve(currentProjectPath).toLowerCase();
+            if (normalizedProjectPath !== normalizedCurrentPath) {
+              continue;
+            }
+          }
+          plugins.push({
+            name: manifest.name,
+            description: manifest.description,
+            version: version || manifest.version,
+            path: installPath,
+            source: "dexto",
+            scope,
+            installedAt
+          });
+        }
+      }
+    }
+  } catch {
+  }
+  return { plugins };
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  getDextoInstalledPluginsPath,
+  listInstalledPlugins
+});