@dexto/agent-management 1.5.6 → 1.5.8

package/dist/plugins/marketplace/operations.d.ts

@@ -0,0 +1,43 @@
+/**
+ * Plugin Marketplace Operations
+ *
+ * Handles adding, removing, updating, and listing marketplaces.
+ */
+import type { MarketplaceSource, MarketplaceEntry, MarketplacePlugin, MarketplaceAddOptions, MarketplaceAddResult, MarketplaceRemoveResult, MarketplaceUpdateResult } from './types.js';
+/**
+ * Parse a source string to determine its type and value
+ */
+export declare function parseMarketplaceSource(source: string): MarketplaceSource;
+/**
+ * Derive a marketplace name from its source
+ */
+export declare function deriveMarketplaceName(source: MarketplaceSource): string;
+/**
+ * Add a marketplace
+ */
+export declare function addMarketplace(source: string, options?: MarketplaceAddOptions): Promise<MarketplaceAddResult>;
+/**
+ * Remove a marketplace
+ */
+export declare function removeMarketplace(name: string): Promise<MarketplaceRemoveResult>;
+/**
+ * Update a marketplace (git pull)
+ */
+export declare function updateMarketplace(name?: string): Promise<MarketplaceUpdateResult[]>;
+/**
+ * List all registered marketplaces
+ */
+export declare function listMarketplaces(): MarketplaceEntry[];
+/**
+ * Scan a marketplace directory for plugins
+ */
+export declare function scanMarketplacePlugins(marketplacePath: string, marketplaceName: string): MarketplacePlugin[];
+/**
+ * List all plugins across all marketplaces
+ */
+export declare function listAllMarketplacePlugins(): MarketplacePlugin[];
+/**
+ * Find a plugin by name across all marketplaces
+ */
+export declare function findPluginInMarketplaces(pluginName: string, marketplaceName?: string): MarketplacePlugin | null;
+//# sourceMappingURL=operations.d.ts.map

package/dist/plugins/marketplace/operations.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"operations.d.ts","sourceRoot":"","sources":["../../../src/plugins/marketplace/operations.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAgBH,OAAO,KAAK,EACR,iBAAiB,EACjB,gBAAgB,EAChB,iBAAiB,EACjB,qBAAqB,EACrB,oBAAoB,EACpB,uBAAuB,EACvB,uBAAuB,EAE1B,MAAM,YAAY,CAAC;AAEpB;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,MAAM,EAAE,MAAM,GAAG,iBAAiB,CA0BxE;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,MAAM,EAAE,iBAAiB,GAAG,MAAM,CAqBvE;AAgCD;;GAEG;AACH,wBAAsB,cAAc,CAChC,MAAM,EAAE,MAAM,EACd,OAAO,GAAE,qBAA0B,GACpC,OAAO,CAAC,oBAAoB,CAAC,CAmE/B;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,CAAC,CA6BtF;AAED;;GAEG;AACH,wBAAsB,iBAAiB,CAAC,IAAI,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,uBAAuB,EAAE,CAAC,CAiBzF;AAwFD;;GAEG;AACH,wBAAgB,gBAAgB,IAAI,gBAAgB,EAAE,CAErD;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAClC,eAAe,EAAE,MAAM,EACvB,eAAe,EAAE,MAAM,GACxB,iBAAiB,EAAE,CA0GrB;AAED;;GAEG;AACH,wBAAgB,yBAAyB,IAAI,iBAAiB,EAAE,CAY/D;AAED;;GAEG;AACH,wBAAgB,wBAAwB,CACpC,UAAU,EAAE,MAAM,EAClB,eAAe,CAAC,EAAE,MAAM,GACzB,iBAAiB,GAAG,IAAI,CAiB1B"}

package/dist/plugins/marketplace/operations.js

@@ -0,0 +1,339 @@
+import * as path from "path";
+import { existsSync, readdirSync, readFileSync, rmSync } from "fs";
+import { execSync } from "child_process";
+import {
+  getMarketplacesDir,
+  addMarketplaceEntry,
+  removeMarketplaceEntry,
+  getMarketplaceEntry,
+  getAllMarketplaces,
+  updateMarketplaceTimestamp
+} from "./registry.js";
+import { MarketplaceError } from "./errors.js";
+import { MarketplaceManifestSchema } from "./schemas.js";
+import { tryLoadManifest } from "../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 = 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 = getMarketplaceEntry(name);
+  if (existing) {
+    throw 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 (!existsSync(localPath)) {
+      throw MarketplaceError.addLocalNotFound(localPath);
+    }
+    installLocation = localPath;
+  } else {
+    const marketplacesDir = getMarketplacesDir();
+    installLocation = path.join(marketplacesDir, name);
+    const cloneUrl = getCloneUrl(parsedSource);
+    try {
+      execSync(`git clone "${cloneUrl}" "${installLocation}"`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch (error) {
+      throw 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()
+  };
+  addMarketplaceEntry(entry);
+  return {
+    success: true,
+    name,
+    pluginCount: plugins.length,
+    warnings
+  };
+}
+async function removeMarketplace(name) {
+  const entry = getMarketplaceEntry(name);
+  if (!entry) {
+    throw MarketplaceError.removeNotFound(name);
+  }
+  if (entry.source.type !== "local") {
+    try {
+      if (existsSync(entry.installLocation)) {
+        rmSync(entry.installLocation, { recursive: true, force: true });
+      }
+    } catch (error) {
+      throw MarketplaceError.removeDeleteFailed(
+        name,
+        entry.installLocation,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+  }
+  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 = getAllMarketplaces();
+    for (const marketplace of marketplaces) {
+      const result = await updateSingleMarketplace(marketplace.name);
+      results.push(result);
+    }
+  }
+  return results;
+}
+async function updateSingleMarketplace(name) {
+  const entry = getMarketplaceEntry(name);
+  if (!entry) {
+    throw 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 (!existsSync(entry.installLocation)) {
+    warnings.push("Marketplace directory not found, re-cloning");
+    const cloneUrl = getCloneUrl(entry.source);
+    try {
+      execSync(`git clone "${cloneUrl}" "${entry.installLocation}"`, {
+        encoding: "utf-8",
+        stdio: ["pipe", "pipe", "pipe"]
+      });
+    } catch (error) {
+      throw MarketplaceError.updatePullFailed(
+        name,
+        error instanceof Error ? error.message : String(error)
+      );
+    }
+    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 {
+    execSync("git pull --ff-only", {
+      cwd: entry.installLocation,
+      encoding: "utf-8",
+      stdio: ["pipe", "pipe", "pipe"]
+    });
+  } catch (error) {
+    throw MarketplaceError.updatePullFailed(
+      name,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+  const newShaValue = getGitSha(entry.installLocation);
+  const hasChanges = previousShaValue !== newShaValue;
+  if (hasChanges) {
+    updateMarketplaceTimestamp(name);
+  }
+  return {
+    success: true,
+    name,
+    ...previousShaValue !== void 0 && { previousSha: previousShaValue },
+    ...newShaValue !== void 0 && { newSha: newShaValue },
+    hasChanges,
+    warnings
+  };
+}
+function listMarketplaces() {
+  return getAllMarketplaces();
+}
+function scanMarketplacePlugins(marketplacePath, marketplaceName) {
+  const plugins = [];
+  const manifestPath = path.join(marketplacePath, "marketplace.json");
+  if (existsSync(manifestPath)) {
+    try {
+      const content = readFileSync(manifestPath, "utf-8");
+      const parsed = JSON.parse(content);
+      const result = 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 (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 (!existsSync(dirPath)) continue;
+    try {
+      const entries = readdirSync(dirPath, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        const pluginPath = path.join(dirPath, entry.name);
+        const manifest = 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 = 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 = 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 (!existsSync(marketplace.installLocation)) continue;
+    const plugins = scanMarketplacePlugins(marketplace.installLocation, marketplace.name);
+    allPlugins.push(...plugins);
+  }
+  return allPlugins;
+}
+function findPluginInMarketplaces(pluginName, marketplaceName) {
+  const marketplaces = marketplaceName ? [getMarketplaceEntry(marketplaceName)].filter(Boolean) : listMarketplaces();
+  for (const marketplace of marketplaces) {
+    if (!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;
+}
+export {
+  addMarketplace,
+  deriveMarketplaceName,
+  findPluginInMarketplaces,
+  listAllMarketplacePlugins,
+  listMarketplaces,
+  parseMarketplaceSource,
+  removeMarketplace,
+  scanMarketplacePlugins,
+  updateMarketplace
+};

package/dist/plugins/marketplace/registry.cjs

@@ -0,0 +1,166 @@
+"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 registry_exports = {};
+__export(registry_exports, {
+  DEFAULT_MARKETPLACES: () => DEFAULT_MARKETPLACES,
+  addMarketplaceEntry: () => addMarketplaceEntry,
+  getAllMarketplaces: () => getAllMarketplaces,
+  getMarketplaceCacheDir: () => getMarketplaceCacheDir,
+  getMarketplaceEntry: () => getMarketplaceEntry,
+  getMarketplacesDir: () => getMarketplacesDir,
+  getMarketplacesRegistryPath: () => getMarketplacesRegistryPath,
+  getUninstalledDefaults: () => getUninstalledDefaults,
+  isDefaultMarketplace: () => isDefaultMarketplace,
+  loadKnownMarketplaces: () => loadKnownMarketplaces,
+  marketplaceExists: () => marketplaceExists,
+  removeMarketplaceEntry: () => removeMarketplaceEntry,
+  saveKnownMarketplaces: () => saveKnownMarketplaces,
+  updateMarketplaceTimestamp: () => updateMarketplaceTimestamp
+});
+module.exports = __toCommonJS(registry_exports);
+var path = __toESM(require("path"), 1);
+var import_fs = require("fs");
+var import_os = require("os");
+var import_schemas = require("./schemas.js");
+var import_errors = require("./errors.js");
+const DEFAULT_MARKETPLACES = [
+  {
+    name: "claude-plugins-official",
+    source: {
+      type: "github",
+      value: "anthropics/claude-plugins-official"
+    }
+  }
+];
+function getMarketplacesRegistryPath() {
+  return path.join((0, import_os.homedir)(), ".dexto", "plugins", "known_marketplaces.json");
+}
+function getMarketplacesDir() {
+  return path.join((0, import_os.homedir)(), ".dexto", "plugins", "marketplaces");
+}
+function getMarketplaceCacheDir() {
+  return path.join((0, import_os.homedir)(), ".dexto", "plugins", "cache");
+}
+function loadKnownMarketplaces() {
+  const filePath = getMarketplacesRegistryPath();
+  if (!(0, import_fs.existsSync)(filePath)) {
+    return { version: 1, marketplaces: {} };
+  }
+  try {
+    const content = (0, import_fs.readFileSync)(filePath, "utf-8");
+    const parsed = JSON.parse(content);
+    const result = import_schemas.KnownMarketplacesFileSchema.safeParse(parsed);
+    if (!result.success) {
+      return { version: 1, marketplaces: {} };
+    }
+    return result.data;
+  } catch {
+    return { version: 1, marketplaces: {} };
+  }
+}
+function saveKnownMarketplaces(data) {
+  const filePath = getMarketplacesRegistryPath();
+  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.MarketplaceError.registryWriteFailed(
+      filePath,
+      error instanceof Error ? error.message : String(error)
+    );
+  }
+}
+function getMarketplaceEntry(name) {
+  const registry = loadKnownMarketplaces();
+  return registry.marketplaces[name] || null;
+}
+function marketplaceExists(name) {
+  return getMarketplaceEntry(name) !== null;
+}
+function getAllMarketplaces() {
+  const registry = loadKnownMarketplaces();
+  return Object.values(registry.marketplaces);
+}
+function addMarketplaceEntry(entry) {
+  const registry = loadKnownMarketplaces();
+  registry.marketplaces[entry.name] = entry;
+  saveKnownMarketplaces(registry);
+}
+function removeMarketplaceEntry(name) {
+  const registry = loadKnownMarketplaces();
+  if (!registry.marketplaces[name]) {
+    return false;
+  }
+  delete registry.marketplaces[name];
+  saveKnownMarketplaces(registry);
+  return true;
+}
+function updateMarketplaceTimestamp(name) {
+  const registry = loadKnownMarketplaces();
+  if (registry.marketplaces[name]) {
+    registry.marketplaces[name].lastUpdated = (/* @__PURE__ */ new Date()).toISOString();
+    saveKnownMarketplaces(registry);
+  }
+}
+function getUninstalledDefaults() {
+  const registry = loadKnownMarketplaces();
+  const uninstalled = [];
+  for (const defaultMarket of DEFAULT_MARKETPLACES) {
+    if (!registry.marketplaces[defaultMarket.name]) {
+      uninstalled.push({
+        ...defaultMarket,
+        isDefault: true
+      });
+    }
+  }
+  return uninstalled;
+}
+function isDefaultMarketplace(name) {
+  return DEFAULT_MARKETPLACES.some((m) => m.name === name);
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  DEFAULT_MARKETPLACES,
+  addMarketplaceEntry,
+  getAllMarketplaces,
+  getMarketplaceCacheDir,
+  getMarketplaceEntry,
+  getMarketplacesDir,
+  getMarketplacesRegistryPath,
+  getUninstalledDefaults,
+  isDefaultMarketplace,
+  loadKnownMarketplaces,
+  marketplaceExists,
+  removeMarketplaceEntry,
+  saveKnownMarketplaces,
+  updateMarketplaceTimestamp
+});

package/dist/plugins/marketplace/registry.d.ts

@@ -0,0 +1,72 @@
+/**
+ * Plugin Marketplace Registry
+ *
+ * Manages the known_marketplaces.json file that tracks registered marketplaces.
+ */
+import type { KnownMarketplacesFile, MarketplaceEntry, MarketplaceSource } from './types.js';
+/**
+ * Default marketplace configuration
+ * Claude Code's official plugin marketplace is included by default
+ */
+export declare const DEFAULT_MARKETPLACES: Array<{
+    name: string;
+    source: MarketplaceSource;
+}>;
+/**
+ * Get the path to known_marketplaces.json
+ */
+export declare function getMarketplacesRegistryPath(): string;
+/**
+ * Get the directory where marketplaces are cloned
+ */
+export declare function getMarketplacesDir(): string;
+/**
+ * Get the marketplace cache directory (for versioned plugin copies)
+ */
+export declare function getMarketplaceCacheDir(): string;
+/**
+ * Load the known marketplaces registry
+ */
+export declare function loadKnownMarketplaces(): KnownMarketplacesFile;
+/**
+ * Save the known marketplaces registry
+ */
+export declare function saveKnownMarketplaces(data: KnownMarketplacesFile): void;
+/**
+ * Get a specific marketplace entry by name
+ */
+export declare function getMarketplaceEntry(name: string): MarketplaceEntry | null;
+/**
+ * Check if a marketplace exists by name
+ */
+export declare function marketplaceExists(name: string): boolean;
+/**
+ * Get all registered marketplaces
+ */
+export declare function getAllMarketplaces(): MarketplaceEntry[];
+/**
+ * Add a marketplace entry to the registry
+ */
+export declare function addMarketplaceEntry(entry: MarketplaceEntry): void;
+/**
+ * Remove a marketplace entry from the registry
+ */
+export declare function removeMarketplaceEntry(name: string): boolean;
+/**
+ * Update a marketplace entry's lastUpdated timestamp
+ */
+export declare function updateMarketplaceTimestamp(name: string): void;
+/**
+ * Get default marketplaces that are not yet installed
+ * Returns entries with a special flag indicating they need to be added
+ */
+export declare function getUninstalledDefaults(): Array<{
+    name: string;
+    source: MarketplaceSource;
+    isDefault: true;
+}>;
+/**
+ * Check if a marketplace is a default marketplace
+ */
+export declare function isDefaultMarketplace(name: string): boolean;
+//# sourceMappingURL=registry.d.ts.map

package/dist/plugins/marketplace/registry.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"registry.d.ts","sourceRoot":"","sources":["../../../src/plugins/marketplace/registry.ts"],"names":[],"mappings":"AAAA;;;;GAIG;AAOH,OAAO,KAAK,EAAE,qBAAqB,EAAE,gBAAgB,EAAE,iBAAiB,EAAE,MAAM,YAAY,CAAC;AAE7F;;;GAGG;AACH,eAAO,MAAM,oBAAoB,EAAE,KAAK,CAAC;IACrC,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,iBAAiB,CAAC;CAC7B,CAQA,CAAC;AAEF;;GAEG;AACH,wBAAgB,2BAA2B,IAAI,MAAM,CAEpD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,MAAM,CAE3C;AAED;;GAEG;AACH,wBAAgB,sBAAsB,IAAI,MAAM,CAE/C;AAED;;GAEG;AACH,wBAAgB,qBAAqB,IAAI,qBAAqB,CAsB7D;AAED;;GAEG;AACH,wBAAgB,qBAAqB,CAAC,IAAI,EAAE,qBAAqB,GAAG,IAAI,CAiBvE;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,IAAI,EAAE,MAAM,GAAG,gBAAgB,GAAG,IAAI,CAGzE;AAED;;GAEG;AACH,wBAAgB,iBAAiB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAEvD;AAED;;GAEG;AACH,wBAAgB,kBAAkB,IAAI,gBAAgB,EAAE,CAGvD;AAED;;GAEG;AACH,wBAAgB,mBAAmB,CAAC,KAAK,EAAE,gBAAgB,GAAG,IAAI,CAIjE;AAED;;GAEG;AACH,wBAAgB,sBAAsB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAU5D;AAED;;GAEG;AACH,wBAAgB,0BAA0B,CAAC,IAAI,EAAE,MAAM,GAAG,IAAI,CAO7D;AAED;;;GAGG;AACH,wBAAgB,sBAAsB,IAAI,KAAK,CAAC;IAC5C,IAAI,EAAE,MAAM,CAAC;IACb,MAAM,EAAE,iBAAiB,CAAC;IAC1B,SAAS,EAAE,IAAI,CAAC;CACnB,CAAC,CAkBD;AAED;;GAEG;AACH,wBAAgB,oBAAoB,CAAC,IAAI,EAAE,MAAM,GAAG,OAAO,CAE1D"}