@dexto/agent-management 1.5.6 → 1.5.8

package/dist/plugins/errors.cjs

@@ -0,0 +1,197 @@
+"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 errors_exports = {};
+__export(errors_exports, {
+  PluginError: () => PluginError
+});
+module.exports = __toCommonJS(errors_exports);
+var import_core = require("@dexto/core");
+var import_error_codes = require("./error-codes.js");
+class PluginError {
+  // Manifest errors
+  static manifestNotFound(pluginPath) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.MANIFEST_NOT_FOUND,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.USER,
+      `Plugin manifest not found: ${pluginPath}/.claude-plugin/plugin.json`,
+      { pluginPath },
+      "Ensure the plugin has a valid .claude-plugin/plugin.json file"
+    );
+  }
+  static manifestInvalid(pluginPath, issues) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.MANIFEST_INVALID,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.USER,
+      `Invalid plugin manifest at ${pluginPath}: ${issues}`,
+      { pluginPath, issues },
+      "Check the plugin.json file matches the expected schema (name is required)"
+    );
+  }
+  static manifestParseError(pluginPath, cause) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.MANIFEST_PARSE_ERROR,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.USER,
+      `Failed to parse plugin manifest at ${pluginPath}: ${cause}`,
+      { pluginPath, cause },
+      "Ensure plugin.json contains valid JSON"
+    );
+  }
+  // Loading errors
+  static directoryReadError(pluginPath, cause) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.DIRECTORY_READ_ERROR,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.SYSTEM,
+      `Failed to read plugin directory ${pluginPath}: ${cause}`,
+      { pluginPath, cause },
+      "Check file permissions and that the directory exists"
+    );
+  }
+  static mcpConfigInvalid(pluginPath, cause) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.MCP_CONFIG_INVALID,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.USER,
+      `Invalid MCP config in plugin ${pluginPath}: ${cause}`,
+      { pluginPath, cause },
+      "Check the .mcp.json file contains valid JSON"
+    );
+  }
+  // Installation errors
+  static installSourceNotFound(sourcePath) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.INSTALL_SOURCE_NOT_FOUND,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.USER,
+      `Plugin source not found: ${sourcePath}`,
+      { sourcePath },
+      "Ensure the path points to a valid plugin directory with .claude-plugin/plugin.json"
+    );
+  }
+  static installAlreadyExists(pluginName, existingPath) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.INSTALL_ALREADY_EXISTS,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.USER,
+      `Plugin '${pluginName}' is already installed at ${existingPath}`,
+      { pluginName, existingPath },
+      "Use --force to overwrite the existing installation"
+    );
+  }
+  static installCopyFailed(sourcePath, destPath, cause) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.INSTALL_COPY_FAILED,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.SYSTEM,
+      `Failed to copy plugin from ${sourcePath} to ${destPath}: ${cause}`,
+      { sourcePath, destPath, cause },
+      "Check file permissions and disk space"
+    );
+  }
+  static installManifestWriteFailed(manifestPath, cause) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.INSTALL_MANIFEST_WRITE_FAILED,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.SYSTEM,
+      `Failed to update installed plugins manifest at ${manifestPath}: ${cause}`,
+      { manifestPath, cause },
+      "Check file permissions and ensure the directory exists"
+    );
+  }
+  static invalidScope(scope) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.INSTALL_INVALID_SCOPE,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.USER,
+      `Invalid installation scope: ${scope}. Must be 'user', 'project', or 'local'.`,
+      { scope },
+      "Check the scope parameter is one of: 'user', 'project', 'local'"
+    );
+  }
+  // Import errors
+  static importNotFound(pluginName) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.IMPORT_NOT_FOUND,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.USER,
+      `Plugin '${pluginName}' not found`,
+      { pluginName },
+      "Use `dexto plugin list` to see available plugins"
+    );
+  }
+  // Uninstallation errors
+  static uninstallNotFound(pluginName, hint) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.UNINSTALL_NOT_FOUND,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.USER,
+      `Plugin '${pluginName}' is not installed`,
+      { pluginName },
+      hint || "Use `dexto plugin list` to see installed plugins"
+    );
+  }
+  static uninstallDeleteFailed(pluginPath, cause) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.UNINSTALL_DELETE_FAILED,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.SYSTEM,
+      `Failed to delete plugin at ${pluginPath}: ${cause}`,
+      { pluginPath, cause },
+      "Check file permissions and ensure the plugin is not in use"
+    );
+  }
+  static uninstallManifestUpdateFailed(manifestPath, cause) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.UNINSTALL_MANIFEST_UPDATE_FAILED,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.SYSTEM,
+      `Failed to update installed plugins manifest at ${manifestPath}: ${cause}`,
+      { manifestPath, cause },
+      "Check file permissions"
+    );
+  }
+  // Validation errors
+  static validationInvalidStructure(pluginPath, details) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.VALIDATION_INVALID_STRUCTURE,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.USER,
+      `Invalid plugin structure at ${pluginPath}: ${details}`,
+      { pluginPath, details },
+      "Ensure the plugin has a .claude-plugin/plugin.json file"
+    );
+  }
+  static validationMissingRequired(pluginPath, missing) {
+    return new import_core.DextoRuntimeError(
+      import_error_codes.PluginErrorCode.VALIDATION_MISSING_REQUIRED,
+      import_core.ErrorScope.CONFIG,
+      import_core.ErrorType.USER,
+      `Plugin at ${pluginPath} is missing required fields: ${missing.join(", ")}`,
+      { pluginPath, missing },
+      "Add the missing fields to .claude-plugin/plugin.json"
+    );
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  PluginError
+});

package/dist/plugins/errors.d.ts

@@ -0,0 +1,68 @@
+import { DextoRuntimeError } from '@dexto/core';
+/**
+ * Plugin runtime error factory methods
+ * Creates properly typed errors for plugin operations
+ */
+export declare class PluginError {
+    static manifestNotFound(pluginPath: string): DextoRuntimeError<{
+        pluginPath: string;
+    }>;
+    static manifestInvalid(pluginPath: string, issues: string): DextoRuntimeError<{
+        pluginPath: string;
+        issues: string;
+    }>;
+    static manifestParseError(pluginPath: string, cause: string): DextoRuntimeError<{
+        pluginPath: string;
+        cause: string;
+    }>;
+    static directoryReadError(pluginPath: string, cause: string): DextoRuntimeError<{
+        pluginPath: string;
+        cause: string;
+    }>;
+    static mcpConfigInvalid(pluginPath: string, cause: string): DextoRuntimeError<{
+        pluginPath: string;
+        cause: string;
+    }>;
+    static installSourceNotFound(sourcePath: string): DextoRuntimeError<{
+        sourcePath: string;
+    }>;
+    static installAlreadyExists(pluginName: string, existingPath: string): DextoRuntimeError<{
+        pluginName: string;
+        existingPath: string;
+    }>;
+    static installCopyFailed(sourcePath: string, destPath: string, cause: string): DextoRuntimeError<{
+        sourcePath: string;
+        destPath: string;
+        cause: string;
+    }>;
+    static installManifestWriteFailed(manifestPath: string, cause: string): DextoRuntimeError<{
+        manifestPath: string;
+        cause: string;
+    }>;
+    static invalidScope(scope: unknown): DextoRuntimeError<{
+        scope: unknown;
+    }>;
+    static importNotFound(pluginName: string): DextoRuntimeError<{
+        pluginName: string;
+    }>;
+    static uninstallNotFound(pluginName: string, hint?: string): DextoRuntimeError<{
+        pluginName: string;
+    }>;
+    static uninstallDeleteFailed(pluginPath: string, cause: string): DextoRuntimeError<{
+        pluginPath: string;
+        cause: string;
+    }>;
+    static uninstallManifestUpdateFailed(manifestPath: string, cause: string): DextoRuntimeError<{
+        manifestPath: string;
+        cause: string;
+    }>;
+    static validationInvalidStructure(pluginPath: string, details: string): DextoRuntimeError<{
+        pluginPath: string;
+        details: string;
+    }>;
+    static validationMissingRequired(pluginPath: string, missing: string[]): DextoRuntimeError<{
+        pluginPath: string;
+        missing: string[];
+    }>;
+}
+//# sourceMappingURL=errors.d.ts.map

package/dist/plugins/errors.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"errors.d.ts","sourceRoot":"","sources":["../../src/plugins/errors.ts"],"names":[],"mappings":"AAAA,OAAO,EAAE,iBAAiB,EAAyB,MAAM,aAAa,CAAC;AAGvE;;;GAGG;AACH,qBAAa,WAAW;IAEpB,MAAM,CAAC,gBAAgB,CAAC,UAAU,EAAE,MAAM;;;IAW1C,MAAM,CAAC,eAAe,CAAC,UAAU,EAAE,MAAM,EAAE,MAAM,EAAE,MAAM;;;;IAWzD,MAAM,CAAC,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAY3D,MAAM,CAAC,kBAAkB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAW3D,MAAM,CAAC,gBAAgB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAYzD,MAAM,CAAC,qBAAqB,CAAC,UAAU,EAAE,MAAM;;;IAW/C,MAAM,CAAC,oBAAoB,CAAC,UAAU,EAAE,MAAM,EAAE,YAAY,EAAE,MAAM;;;;IAWpE,MAAM,CAAC,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,QAAQ,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;;IAW5E,MAAM,CAAC,0BAA0B,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAWrE,MAAM,CAAC,YAAY,CAAC,KAAK,EAAE,OAAO;;;IAYlC,MAAM,CAAC,cAAc,CAAC,UAAU,EAAE,MAAM;;;IAYxC,MAAM,CAAC,iBAAiB,CAAC,UAAU,EAAE,MAAM,EAAE,IAAI,CAAC,EAAE,MAAM;;;IAW1D,MAAM,CAAC,qBAAqB,CAAC,UAAU,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAW9D,MAAM,CAAC,6BAA6B,CAAC,YAAY,EAAE,MAAM,EAAE,KAAK,EAAE,MAAM;;;;IAYxE,MAAM,CAAC,0BAA0B,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM;;;;IAWrE,MAAM,CAAC,yBAAyB,CAAC,UAAU,EAAE,MAAM,EAAE,OAAO,EAAE,MAAM,EAAE;;;;CAUzE"}

package/dist/plugins/errors.js

@@ -0,0 +1,173 @@
+import { DextoRuntimeError, ErrorScope, ErrorType } from "@dexto/core";
+import { PluginErrorCode } from "./error-codes.js";
+class PluginError {
+  // Manifest errors
+  static manifestNotFound(pluginPath) {
+    return new DextoRuntimeError(
+      PluginErrorCode.MANIFEST_NOT_FOUND,
+      ErrorScope.CONFIG,
+      ErrorType.USER,
+      `Plugin manifest not found: ${pluginPath}/.claude-plugin/plugin.json`,
+      { pluginPath },
+      "Ensure the plugin has a valid .claude-plugin/plugin.json file"
+    );
+  }
+  static manifestInvalid(pluginPath, issues) {
+    return new DextoRuntimeError(
+      PluginErrorCode.MANIFEST_INVALID,
+      ErrorScope.CONFIG,
+      ErrorType.USER,
+      `Invalid plugin manifest at ${pluginPath}: ${issues}`,
+      { pluginPath, issues },
+      "Check the plugin.json file matches the expected schema (name is required)"
+    );
+  }
+  static manifestParseError(pluginPath, cause) {
+    return new DextoRuntimeError(
+      PluginErrorCode.MANIFEST_PARSE_ERROR,
+      ErrorScope.CONFIG,
+      ErrorType.USER,
+      `Failed to parse plugin manifest at ${pluginPath}: ${cause}`,
+      { pluginPath, cause },
+      "Ensure plugin.json contains valid JSON"
+    );
+  }
+  // Loading errors
+  static directoryReadError(pluginPath, cause) {
+    return new DextoRuntimeError(
+      PluginErrorCode.DIRECTORY_READ_ERROR,
+      ErrorScope.CONFIG,
+      ErrorType.SYSTEM,
+      `Failed to read plugin directory ${pluginPath}: ${cause}`,
+      { pluginPath, cause },
+      "Check file permissions and that the directory exists"
+    );
+  }
+  static mcpConfigInvalid(pluginPath, cause) {
+    return new DextoRuntimeError(
+      PluginErrorCode.MCP_CONFIG_INVALID,
+      ErrorScope.CONFIG,
+      ErrorType.USER,
+      `Invalid MCP config in plugin ${pluginPath}: ${cause}`,
+      { pluginPath, cause },
+      "Check the .mcp.json file contains valid JSON"
+    );
+  }
+  // Installation errors
+  static installSourceNotFound(sourcePath) {
+    return new DextoRuntimeError(
+      PluginErrorCode.INSTALL_SOURCE_NOT_FOUND,
+      ErrorScope.CONFIG,
+      ErrorType.USER,
+      `Plugin source not found: ${sourcePath}`,
+      { sourcePath },
+      "Ensure the path points to a valid plugin directory with .claude-plugin/plugin.json"
+    );
+  }
+  static installAlreadyExists(pluginName, existingPath) {
+    return new DextoRuntimeError(
+      PluginErrorCode.INSTALL_ALREADY_EXISTS,
+      ErrorScope.CONFIG,
+      ErrorType.USER,
+      `Plugin '${pluginName}' is already installed at ${existingPath}`,
+      { pluginName, existingPath },
+      "Use --force to overwrite the existing installation"
+    );
+  }
+  static installCopyFailed(sourcePath, destPath, cause) {
+    return new DextoRuntimeError(
+      PluginErrorCode.INSTALL_COPY_FAILED,
+      ErrorScope.CONFIG,
+      ErrorType.SYSTEM,
+      `Failed to copy plugin from ${sourcePath} to ${destPath}: ${cause}`,
+      { sourcePath, destPath, cause },
+      "Check file permissions and disk space"
+    );
+  }
+  static installManifestWriteFailed(manifestPath, cause) {
+    return new DextoRuntimeError(
+      PluginErrorCode.INSTALL_MANIFEST_WRITE_FAILED,
+      ErrorScope.CONFIG,
+      ErrorType.SYSTEM,
+      `Failed to update installed plugins manifest at ${manifestPath}: ${cause}`,
+      { manifestPath, cause },
+      "Check file permissions and ensure the directory exists"
+    );
+  }
+  static invalidScope(scope) {
+    return new DextoRuntimeError(
+      PluginErrorCode.INSTALL_INVALID_SCOPE,
+      ErrorScope.CONFIG,
+      ErrorType.USER,
+      `Invalid installation scope: ${scope}. Must be 'user', 'project', or 'local'.`,
+      { scope },
+      "Check the scope parameter is one of: 'user', 'project', 'local'"
+    );
+  }
+  // Import errors
+  static importNotFound(pluginName) {
+    return new DextoRuntimeError(
+      PluginErrorCode.IMPORT_NOT_FOUND,
+      ErrorScope.CONFIG,
+      ErrorType.USER,
+      `Plugin '${pluginName}' not found`,
+      { pluginName },
+      "Use `dexto plugin list` to see available plugins"
+    );
+  }
+  // Uninstallation errors
+  static uninstallNotFound(pluginName, hint) {
+    return new DextoRuntimeError(
+      PluginErrorCode.UNINSTALL_NOT_FOUND,
+      ErrorScope.CONFIG,
+      ErrorType.USER,
+      `Plugin '${pluginName}' is not installed`,
+      { pluginName },
+      hint || "Use `dexto plugin list` to see installed plugins"
+    );
+  }
+  static uninstallDeleteFailed(pluginPath, cause) {
+    return new DextoRuntimeError(
+      PluginErrorCode.UNINSTALL_DELETE_FAILED,
+      ErrorScope.CONFIG,
+      ErrorType.SYSTEM,
+      `Failed to delete plugin at ${pluginPath}: ${cause}`,
+      { pluginPath, cause },
+      "Check file permissions and ensure the plugin is not in use"
+    );
+  }
+  static uninstallManifestUpdateFailed(manifestPath, cause) {
+    return new DextoRuntimeError(
+      PluginErrorCode.UNINSTALL_MANIFEST_UPDATE_FAILED,
+      ErrorScope.CONFIG,
+      ErrorType.SYSTEM,
+      `Failed to update installed plugins manifest at ${manifestPath}: ${cause}`,
+      { manifestPath, cause },
+      "Check file permissions"
+    );
+  }
+  // Validation errors
+  static validationInvalidStructure(pluginPath, details) {
+    return new DextoRuntimeError(
+      PluginErrorCode.VALIDATION_INVALID_STRUCTURE,
+      ErrorScope.CONFIG,
+      ErrorType.USER,
+      `Invalid plugin structure at ${pluginPath}: ${details}`,
+      { pluginPath, details },
+      "Ensure the plugin has a .claude-plugin/plugin.json file"
+    );
+  }
+  static validationMissingRequired(pluginPath, missing) {
+    return new DextoRuntimeError(
+      PluginErrorCode.VALIDATION_MISSING_REQUIRED,
+      ErrorScope.CONFIG,
+      ErrorType.USER,
+      `Plugin at ${pluginPath} is missing required fields: ${missing.join(", ")}`,
+      { pluginPath, missing },
+      "Add the missing fields to .claude-plugin/plugin.json"
+    );
+  }
+}
+export {
+  PluginError
+};

package/dist/plugins/index.cjs

@@ -0,0 +1,144 @@
+"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 plugins_exports = {};
+__export(plugins_exports, {
+  DEFAULT_MARKETPLACES: () => import_marketplace.DEFAULT_MARKETPLACES,
+  DextoPluginManifestSchema: () => import_schemas.DextoPluginManifestSchema,
+  InstalledPluginEntrySchema: () => import_schemas.InstalledPluginEntrySchema,
+  InstalledPluginsFileSchema: () => import_schemas.InstalledPluginsFileSchema,
+  KnownMarketplacesFileSchema: () => import_marketplace.KnownMarketplacesFileSchema,
+  MarketplaceAddCommandSchema: () => import_marketplace.MarketplaceAddCommandSchema,
+  MarketplaceEntrySchema: () => import_marketplace.MarketplaceEntrySchema,
+  MarketplaceError: () => import_marketplace.MarketplaceError,
+  MarketplaceErrorCode: () => import_marketplace.MarketplaceErrorCode,
+  MarketplaceInstallCommandSchema: () => import_marketplace.MarketplaceInstallCommandSchema,
+  MarketplaceManifestSchema: () => import_marketplace.MarketplaceManifestSchema,
+  MarketplacePluginEntrySchema: () => import_marketplace.MarketplacePluginEntrySchema,
+  MarketplaceSourceSchema: () => import_marketplace.MarketplaceSourceSchema,
+  PluginError: () => import_errors.PluginError,
+  PluginErrorCode: () => import_error_codes.PluginErrorCode,
+  PluginMCPConfigSchema: () => import_schemas.PluginMCPConfigSchema,
+  PluginManifestSchema: () => import_schemas.PluginManifestSchema,
+  addMarketplace: () => import_marketplace.addMarketplace,
+  deriveMarketplaceName: () => import_marketplace.deriveMarketplaceName,
+  discoverClaudeCodePlugins: () => import_discover_plugins.discoverClaudeCodePlugins,
+  discoverStandaloneSkills: () => import_discover_skills.discoverStandaloneSkills,
+  findPluginInMarketplaces: () => import_marketplace.findPluginInMarketplaces,
+  getAllMarketplaces: () => import_marketplace.getAllMarketplaces,
+  getDextoInstalledPluginsPath: () => import_list_plugins.getDextoInstalledPluginsPath,
+  getInstalledPluginsPath: () => import_discover_plugins.getInstalledPluginsPath,
+  getMarketplaceCacheDir: () => import_marketplace.getMarketplaceCacheDir,
+  getMarketplaceEntry: () => import_marketplace.getMarketplaceEntry,
+  getMarketplacesDir: () => import_marketplace.getMarketplacesDir,
+  getMarketplacesRegistryPath: () => import_marketplace.getMarketplacesRegistryPath,
+  getPluginSearchPaths: () => import_discover_plugins.getPluginSearchPaths,
+  getSkillSearchPaths: () => import_discover_skills.getSkillSearchPaths,
+  getUninstalledDefaults: () => import_marketplace.getUninstalledDefaults,
+  installPluginFromMarketplace: () => import_marketplace.installPluginFromMarketplace,
+  installPluginFromPath: () => import_install_plugin.installPluginFromPath,
+  isDefaultMarketplace: () => import_marketplace.isDefaultMarketplace,
+  isPluginInstalled: () => import_install_plugin.isPluginInstalled,
+  listAllMarketplacePlugins: () => import_marketplace.listAllMarketplacePlugins,
+  listInstalledPlugins: () => import_list_plugins.listInstalledPlugins,
+  listMarketplaces: () => import_marketplace.listMarketplaces,
+  loadClaudeCodePlugin: () => import_load_plugin.loadClaudeCodePlugin,
+  loadDextoInstalledPlugins: () => import_install_plugin.loadDextoInstalledPlugins,
+  loadKnownMarketplaces: () => import_marketplace.loadKnownMarketplaces,
+  marketplaceExists: () => import_marketplace.marketplaceExists,
+  parseMarketplaceSource: () => import_marketplace.parseMarketplaceSource,
+  parsePluginSpec: () => import_marketplace.parsePluginSpec,
+  removeMarketplace: () => import_marketplace.removeMarketplace,
+  saveDextoInstalledPlugins: () => import_install_plugin.saveDextoInstalledPlugins,
+  saveKnownMarketplaces: () => import_marketplace.saveKnownMarketplaces,
+  scanMarketplacePlugins: () => import_marketplace.scanMarketplacePlugins,
+  searchMarketplacePlugins: () => import_marketplace.searchMarketplacePlugins,
+  tryLoadManifest: () => import_validate_plugin.tryLoadManifest,
+  uninstallPlugin: () => import_uninstall_plugin.uninstallPlugin,
+  updateMarketplace: () => import_marketplace.updateMarketplace,
+  validatePluginDirectory: () => import_validate_plugin.validatePluginDirectory
+});
+module.exports = __toCommonJS(plugins_exports);
+var import_schemas = require("./schemas.js");
+var import_error_codes = require("./error-codes.js");
+var import_errors = require("./errors.js");
+var import_discover_plugins = require("./discover-plugins.js");
+var import_discover_skills = require("./discover-skills.js");
+var import_load_plugin = require("./load-plugin.js");
+var import_validate_plugin = require("./validate-plugin.js");
+var import_list_plugins = require("./list-plugins.js");
+var import_install_plugin = require("./install-plugin.js");
+var import_uninstall_plugin = require("./uninstall-plugin.js");
+var import_marketplace = require("./marketplace/index.js");
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  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/index.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Plugin Loader
+ *
+ * Discovers and loads bundled plugins from community sources.
+ * Supports two formats:
+ * - .claude-plugin: Claude Code compatible format
+ * - .dexto-plugin: Dexto-native format with extended features (customToolProviders)
+ */
+export type { PluginManifest, DextoPluginManifest, PluginFormat, DiscoveredPlugin, PluginCommand, PluginMCPConfig, LoadedPlugin, PluginInstallScope, InstalledPluginEntry, InstalledPluginsFile, ListedPlugin, PluginValidationResult, PluginInstallResult, PluginUninstallResult, } from './types.js';
+export { PluginManifestSchema, DextoPluginManifestSchema, PluginMCPConfigSchema, InstalledPluginEntrySchema, InstalledPluginsFileSchema, } from './schemas.js';
+export type { ValidatedPluginManifest, ValidatedDextoPluginManifest, ValidatedPluginMCPConfig, ValidatedInstalledPluginsFile, ValidatedInstalledPluginEntry, } from './schemas.js';
+export { PluginErrorCode } from './error-codes.js';
+export { PluginError } from './errors.js';
+export { discoverClaudeCodePlugins, getPluginSearchPaths, getInstalledPluginsPath, } from './discover-plugins.js';
+export { discoverStandaloneSkills, getSkillSearchPaths } from './discover-skills.js';
+export type { DiscoveredSkill } from './discover-skills.js';
+export { loadClaudeCodePlugin } from './load-plugin.js';
+export { validatePluginDirectory, tryLoadManifest } from './validate-plugin.js';
+export { listInstalledPlugins, getDextoInstalledPluginsPath } from './list-plugins.js';
+export { installPluginFromPath, loadDextoInstalledPlugins, saveDextoInstalledPlugins, isPluginInstalled, type InstallPluginOptions, } from './install-plugin.js';
+export { uninstallPlugin, type UninstallPluginOptions } from './uninstall-plugin.js';
+export { type MarketplaceSourceType, type MarketplaceSource, type MarketplaceEntry, type KnownMarketplacesFile, type MarketplacePlugin, type MarketplaceAddResult, type MarketplaceRemoveResult, type MarketplaceUpdateResult, type MarketplaceInstallResult, type MarketplaceAddOptions, type MarketplaceInstallOptions, type MarketplaceManifest, 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';
+//# sourceMappingURL=index.d.ts.map

package/dist/plugins/index.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/plugins/index.ts"],"names":[],"mappings":"AAAA;;;;;;;GAOG;AAGH,YAAY,EACR,cAAc,EACd,mBAAmB,EACnB,YAAY,EACZ,gBAAgB,EAChB,aAAa,EACb,eAAe,EACf,YAAY,EACZ,kBAAkB,EAClB,oBAAoB,EACpB,oBAAoB,EACpB,YAAY,EACZ,sBAAsB,EACtB,mBAAmB,EACnB,qBAAqB,GACxB,MAAM,YAAY,CAAC;AAGpB,OAAO,EACH,oBAAoB,EACpB,yBAAyB,EACzB,qBAAqB,EACrB,0BAA0B,EAC1B,0BAA0B,GAC7B,MAAM,cAAc,CAAC;AACtB,YAAY,EACR,uBAAuB,EACvB,4BAA4B,EAC5B,wBAAwB,EACxB,6BAA6B,EAC7B,6BAA6B,GAChC,MAAM,cAAc,CAAC;AAGtB,OAAO,EAAE,eAAe,EAAE,MAAM,kBAAkB,CAAC;AACnD,OAAO,EAAE,WAAW,EAAE,MAAM,aAAa,CAAC;AAG1C,OAAO,EACH,yBAAyB,EACzB,oBAAoB,EACpB,uBAAuB,GAC1B,MAAM,uBAAuB,CAAC;AAG/B,OAAO,EAAE,wBAAwB,EAAE,mBAAmB,EAAE,MAAM,sBAAsB,CAAC;AACrF,YAAY,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAG5D,OAAO,EAAE,oBAAoB,EAAE,MAAM,kBAAkB,CAAC;AAGxD,OAAO,EAAE,uBAAuB,EAAE,eAAe,EAAE,MAAM,sBAAsB,CAAC;AAGhF,OAAO,EAAE,oBAAoB,EAAE,4BAA4B,EAAE,MAAM,mBAAmB,CAAC;AAGvF,OAAO,EACH,qBAAqB,EACrB,yBAAyB,EACzB,yBAAyB,EACzB,iBAAiB,EACjB,KAAK,oBAAoB,GAC5B,MAAM,qBAAqB,CAAC;AAG7B,OAAO,EAAE,eAAe,EAAE,KAAK,sBAAsB,EAAE,MAAM,uBAAuB,CAAC;AAGrF,OAAO,EAEH,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,gBAAgB,EACrB,KAAK,qBAAqB,EAC1B,KAAK,iBAAiB,EACtB,KAAK,oBAAoB,EACzB,KAAK,uBAAuB,EAC5B,KAAK,uBAAuB,EAC5B,KAAK,wBAAwB,EAC7B,KAAK,qBAAqB,EAC1B,KAAK,yBAAyB,EAC9B,KAAK,mBAAmB,EAExB,uBAAuB,EACvB,sBAAsB,EACtB,2BAA2B,EAC3B,yBAAyB,EACzB,4BAA4B,EAC5B,2BAA2B,EAC3B,+BAA+B,EAE/B,oBAAoB,EACpB,gBAAgB,EAEhB,oBAAoB,EACpB,2BAA2B,EAC3B,kBAAkB,EAClB,sBAAsB,EACtB,qBAAqB,EACrB,qBAAqB,EACrB,mBAAmB,EACnB,iBAAiB,EACjB,kBAAkB,EAClB,sBAAsB,EACtB,oBAAoB,EAEpB,sBAAsB,EACtB,qBAAqB,EACrB,cAAc,EACd,iBAAiB,EACjB,iBAAiB,EACjB,gBAAgB,EAChB,sBAAsB,EACtB,yBAAyB,EACzB,wBAAwB,EAExB,eAAe,EACf,4BAA4B,EAC5B,wBAAwB,GAC3B,MAAM,wBAAwB,CAAC"}