@adminide-stack/marketplace-module-server 12.0.4-alpha.92 → 13.0.1-alpha.0

package/lib/services/extension-gallery-repository.js

@@ -0,0 +1,192 @@
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import'@cdm-logger/core';import*as fs from'fs';import*as https from'https';import*as http from'http';let ExtensionGalleryRepository = class ExtensionGalleryRepository {
+  logger;
+  constructor(logger) {
+    this.logger = logger;
+    this.logger = logger;
+  }
+  async asset(extensionSlug, version, asset) {
+    this.logger.trace('ExtensionGalleryRepository.asset: %s@%s/%s', extensionSlug, version, asset);
+    try {
+      // Try to fetch asset from different sources
+      const assetUrl = this.buildAssetUrl(extensionSlug, version, asset);
+      if (assetUrl.startsWith('http')) {
+        // Fetch from remote URL
+        return await this.fetchHttpAsset(assetUrl);
+      }
+      // Try to read from local filesystem
+      return await this.readLocalAsset(assetUrl);
+    } catch (error) {
+      this.logger.warn('Failed to fetch asset %s@%s/%s: %s', extensionSlug, version, asset, error.message);
+      return null;
+    }
+  }
+  buildAssetUrl(extensionSlug, version, asset) {
+    // Build URL based on common extension repository patterns
+    const baseUrl = process.env.EXTENSION_REGISTRY_URL || 'https://marketplace.visualstudio.com/_apis/public/gallery';
+    return `${baseUrl}/publishers/${extensionSlug}/vsextensions/${version}/vspackage/${asset}`;
+  }
+  async fetchHttpAsset(url) {
+    return new Promise((resolve, reject) => {
+      const client = url.startsWith('https') ? https : http;
+      const req = client.get(url, response => {
+        if (response.statusCode !== 200) {
+          reject(new Error(`HTTP ${response.statusCode}: ${response.statusMessage}`));
+          return;
+        }
+        let data = '';
+        response.setEncoding('utf8');
+        response.on('data', chunk => {
+          data += chunk;
+        });
+        response.on('end', () => {
+          try {
+            // Try to parse as JSON first, fallback to string
+            const result = data.startsWith('{') || data.startsWith('[') ? JSON.parse(data) : data;
+            resolve(result);
+          } catch (parseError) {
+            resolve(data);
+          }
+        });
+      });
+      req.on('error', error => {
+        reject(error);
+      });
+      req.setTimeout(10000, () => {
+        req.destroy();
+        reject(new Error('Request timeout'));
+      });
+    });
+  }
+  async readLocalAsset(filePath) {
+    return new Promise((resolve, reject) => {
+      fs.readFile(filePath, 'utf8', (err, data) => {
+        if (err) {
+          reject(err);
+          return;
+        }
+        try {
+          // Try to parse as JSON first, fallback to string
+          const result = data.startsWith('{') || data.startsWith('[') ? JSON.parse(data) : data;
+          resolve(result);
+        } catch (parseError) {
+          resolve(data);
+        }
+      });
+    });
+  }
+  async get(id, fields) {
+    this.logger.trace('ExtensionGalleryRepository.get: %s fields: %j', id, fields);
+    try {
+      // In a real implementation, this would:
+      // 1. Parse the ID (could be extension slug, UUID, etc.)
+      // 2. Query the database/registry for matching extensions
+      // 3. Apply field filtering to optimize response size
+      // 4. Handle multiple IDs if the id parameter supports it
+      // For now, we validate the inputs and return empty result
+      if (!id || !id.trim()) {
+        throw new Error('Extension ID is required');
+      }
+      // Validate fields array
+      const validFields = this.validateFields(fields);
+      this.logger.info('Looking for extension with ID: %s, fields: %j', id, validFields);
+      // This would be replaced with actual database/API query
+      const extensions = [];
+      return extensions;
+    } catch (error) {
+      this.logger.error('Failed to get extension %s: %s', id, error.message);
+      return [];
+    }
+  }
+  validateFields(fields) {
+    if (!fields || fields.length === 0) {
+      // Return default fields if none specified
+      return ['id', 'name', 'version', 'displayName', 'description', 'publisher'];
+    }
+    // Define allowed fields to prevent data leakage
+    const allowedFields = ['id', 'name', 'version', 'displayName', 'description', 'publisher', 'assets', 'categories', 'tags', 'statistics', 'releaseDate', 'lastUpdated', 'shortDescription', 'installCount'];
+    return fields.filter(field => allowedFields.includes(field));
+  }
+  async download(extension) {
+    this.logger.trace('ExtensionGalleryRepository.download: %s', extension.id);
+    try {
+      // Get download URL from extension assets
+      const downloadAsset = extension.assets?.download;
+      if (!downloadAsset?.uri) {
+        throw new Error('No download URL available');
+      }
+      // Verify the download is accessible
+      const isAccessible = await this.verifyDownloadUrl(downloadAsset.uri);
+      if (!isAccessible) {
+        throw new Error('Download URL is not accessible');
+      }
+      // In a real implementation, you might:
+      // 1. Download the file to a local cache
+      // 2. Verify the package integrity
+      // 3. Store download metrics
+      // 4. Return download stream or file path
+      this.logger.info('Extension %s download verified successfully', extension.id);
+      return true;
+    } catch (error) {
+      this.logger.error('Download failed for %s: %s', extension.id, error.message);
+      return false;
+    }
+  }
+  async verifyDownloadUrl(url) {
+    return new Promise(resolve => {
+      const client = url.startsWith('https') ? https : http;
+      const req = client.request(url, {
+        method: 'HEAD'
+      }, response => {
+        const isSuccess = response.statusCode >= 200 && response.statusCode < 300;
+        resolve(isSuccess);
+      });
+      req.on('error', () => {
+        resolve(false);
+      });
+      req.setTimeout(5000, () => {
+        req.destroy();
+        resolve(false);
+      });
+      req.end();
+    });
+  }
+  async query(query) {
+    this.logger.trace('ExtensionGalleryRepository.query: %j', query);
+    try {
+      // Extract common query parameters
+      const pageSize = Math.min(query.pageSize || 50, 100); // Cap at 100
+      // In a real implementation, this would:
+      // 1. Query a search engine (Elasticsearch, etc.)
+      // 2. Query a database with proper indexing
+      // 3. Call external APIs like VS Code Marketplace
+      // 4. Apply filters like: query.search, query.category, query.publisher, etc.
+      // For now, return a structured empty result with proper pagination
+      const mockResult = {
+        results: [],
+        total: 0,
+        pageSize
+      };
+      this.logger.info('Extension query completed: %d results', mockResult.total);
+      return mockResult;
+    } catch (error) {
+      this.logger.error('Extension query failed: %s', error.message);
+      // Return empty result on error
+      return {
+        results: [],
+        total: 0,
+        pageSize: 50
+      };
+    }
+  }
+  extractFilters(query) {
+    const filters = {};
+    // Extract common filter parameters
+    if (query.category) filters.category = query.category;
+    if (query.publisher) filters.publisher = query.publisher;
+    if (query.featured) filters.featured = query.featured;
+    if (query.verified) filters.verified = query.verified;
+    if (query.targetPlatform) filters.targetPlatform = query.targetPlatform;
+    return filters;
+  }
+};
+ExtensionGalleryRepository = __decorate([injectable(), __param(0, inject('Logger')), __metadata("design:paramtypes", [Object])], ExtensionGalleryRepository);export{ExtensionGalleryRepository};//# sourceMappingURL=extension-gallery-repository.js.map

package/lib/services/extension-gallery-repository.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-gallery-repository.js","sources":["../../src/services/extension-gallery-repository.ts"],"sourcesContent":[null],"names":[],"mappings":"iMAgCI,IAAA,0BAAqB,GAAA,MAAA,0BAAA,CAAA;;aA2CP,CAAA,MAAA,EAAA;AAmBD,IAAA,IAAI,CAAA,MAAI,GAAM,MAAE;AA8B7B,IAAA,IAAA,CAAA,MAAQ,GAAA,MAAA;;aA0DM,CAAA,aAAA,EAAiB,OAAA,EAAA,KAAA,EAAA;AAqBlB,IAAA,IAAA,CAAK,MAAM,CAAA,KAAE,CAAA,2DAAsD,EAAA,OAAA,EAAA,KAAA,CAAA;AAkChF,IAAA,IAAA;AAYH;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/services/extension-gallery-service-new.d.ts

@@ -0,0 +1,39 @@
+import { CdmLogger } from '@cdm-logger/core';
+import { IMarketplacePublisherService, IRegistryExtensionService, IGalleryExtension, IExtensionIdentifier, IExtensionManifest } from 'common/server';
+export interface IExtensionGalleryService {
+    isEnabled(): boolean;
+    query(options?: any): Promise<any>;
+    getExtension(identifier: IExtensionIdentifier | string, version?: string): Promise<IGalleryExtension | null>;
+    download(extension: IGalleryExtension, operation: any): Promise<string>;
+    getReadme(extension: IGalleryExtension, token?: unknown): Promise<string>;
+    getManifest(extension: IGalleryExtension, token?: unknown): Promise<IExtensionManifest | null>;
+    getChangelog(extension: IGalleryExtension, token?: unknown): Promise<string>;
+    getLicense(extension: IGalleryExtension, token?: unknown): Promise<string>;
+    loadCompatibleVersion(extension: IGalleryExtension): Promise<IGalleryExtension>;
+}
+export declare class ExtensionGalleryService implements IExtensionGalleryService {
+    private readonly logger;
+    private readonly registryExtensionService;
+    private readonly publisherService;
+    private readonly disposables;
+    private readonly _onDidChange;
+    readonly onDidChange: import("@adminide-stack/core").Event<void>;
+    constructor(logger: CdmLogger.ILogger, registryExtensionService: IRegistryExtensionService, publisherService: IMarketplacePublisherService);
+    isEnabled(): boolean;
+    query(options?: any): Promise<any>;
+    getExtension(identifier: IExtensionIdentifier | string, version?: string): Promise<IGalleryExtension | null>;
+    download(extension: IGalleryExtension, operation: any): Promise<string>;
+    getReadme(extension: IGalleryExtension, token?: unknown): Promise<string>;
+    getManifest(extension: IGalleryExtension, token?: unknown): Promise<IExtensionManifest | null>;
+    getChangelog(extension: IGalleryExtension, token?: unknown): Promise<string>;
+    getLicense(extension: IGalleryExtension, token?: unknown): Promise<string>;
+    loadCompatibleVersion(extension: IGalleryExtension): Promise<IGalleryExtension>;
+    private toGalleryExtension;
+    /**
+     * Helper method to get manifest from the current release
+     * Since manifests are stored in releases, not directly in the registry extension
+     */
+    private getManifestFromRelease;
+    dispose(): void;
+}
+//# sourceMappingURL=extension-gallery-service-new.d.ts.map

package/lib/services/extension-gallery-service-new.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-gallery-service-new.d.ts","sourceRoot":"","sources":["../../src/services/extension-gallery-service-new.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EACH,4BAA4B,EAC5B,yBAAyB,EAGzB,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,EAIrB,MAAM,eAAe,CAAC;AAEvB,MAAM,WAAW,wBAAwB;IACrC,SAAS,IAAI,OAAO,CAAC;IACrB,KAAK,CAAC,OAAO,CAAC,EAAE,GAAG,GAAG,OAAO,CAAC,GAAG,CAAC,CAAC;IACnC,YAAY,CAAC,UAAU,EAAE,oBAAoB,GAAG,MAAM,EAAE,OAAO,CAAC,EAAE,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC,CAAC;IAC7G,QAAQ,CAAC,SAAS,EAAE,iBAAiB,EAAE,SAAS,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IACxE,SAAS,CAAC,SAAS,EAAE,iBAAiB,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC1E,WAAW,CAAC,SAAS,EAAE,iBAAiB,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC,CAAC;IAC/F,YAAY,CAAC,SAAS,EAAE,iBAAiB,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC7E,UAAU,CAAC,SAAS,EAAE,iBAAiB,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC,CAAC;IAC3E,qBAAqB,CAAC,SAAS,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC,CAAC;CACnF;AAED,qBACa,uBAAwB,YAAW,wBAAwB;IAO9C,OAAO,CAAC,QAAQ,CAAC,MAAM;IAEzC,OAAO,CAAC,QAAQ,CAAC,wBAAwB;IAEzC,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAVrC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA8B;IAC1D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAuB;IAEpD,SAAgB,WAAW,6CAA2B;gBAGf,MAAM,EAAE,SAAS,CAAC,OAAO,EAE3C,wBAAwB,EAAE,yBAAyB,EAEnD,gBAAgB,EAAE,4BAA4B;IAK5D,SAAS,IAAI,OAAO;IAId,KAAK,CAAC,OAAO,GAAE,GAAQ,GAAG,OAAO,CAAC,GAAG,CAAC;IAkCtC,YAAY,CACrB,UAAU,EAAE,oBAAoB,GAAG,MAAM,EACzC,OAAO,CAAC,EAAE,MAAM,GACjB,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAqBvB,QAAQ,CAAC,SAAS,EAAE,iBAAiB,EAAE,SAAS,EAAE,GAAG,GAAG,OAAO,CAAC,MAAM,CAAC;IAKvE,SAAS,CAAC,SAAS,EAAE,iBAAiB,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAOzE,WAAW,CAAC,SAAS,EAAE,iBAAiB,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAK9F,YAAY,CAAC,SAAS,EAAE,iBAAiB,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAO5E,UAAU,CAAC,SAAS,EAAE,iBAAiB,EAAE,KAAK,CAAC,EAAE,OAAO,GAAG,OAAO,CAAC,MAAM,CAAC;IAO1E,qBAAqB,CAAC,SAAS,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;YAI9E,kBAAkB;IAwIhC;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IAoEvB,OAAO,IAAI,IAAI;CAGzB"}

package/lib/services/extension-gallery-service.d.ts

@@ -0,0 +1,30 @@
+import { CdmLogger } from '@cdm-logger/core';
+import { IMarketplacePublisherService, IRegistryExtensionService, IGalleryExtension, IExtensionIdentifier, IExtensionManifest, IGalleryPager, IExtensionGalleryService, IQueryOptions, IExtensionGalleryRepository } from 'common/server';
+export declare class ExtensionGalleryService implements IExtensionGalleryService {
+    private readonly logger;
+    private readonly registryExtensionService;
+    private readonly publisherService;
+    private readonly galleryRepository;
+    private readonly disposables;
+    private readonly _onDidChange;
+    readonly onDidChange: import("@adminide-stack/core").Event<void>;
+    constructor(logger: CdmLogger.ILogger, registryExtensionService: IRegistryExtensionService, publisherService: IMarketplacePublisherService, galleryRepository: IExtensionGalleryRepository);
+    isEnabled(): boolean;
+    query(options?: IQueryOptions): Promise<IGalleryPager>;
+    getExtension(identifier: IExtensionIdentifier | string): Promise<IGalleryExtension | null>;
+    download(extension: IGalleryExtension): Promise<string>;
+    getReadme(extension: IGalleryExtension): Promise<string>;
+    getManifest(extension: IGalleryExtension): Promise<IExtensionManifest | null>;
+    getChangelog(extension: IGalleryExtension): Promise<string>;
+    getLicense(extension: IGalleryExtension): Promise<string>;
+    loadCompatibleVersion(extension: IGalleryExtension): Promise<IGalleryExtension>;
+    private toGalleryExtension;
+    getAllVersions(extension: IGalleryExtension): Promise<IGalleryExtension[]>;
+    /**
+     * Helper method to get manifest from the current release
+     * Since manifests are stored in releases, not directly in the registry extension
+     */
+    private getManifestFromRelease;
+    dispose(): void;
+}
+//# sourceMappingURL=extension-gallery-service.d.ts.map

package/lib/services/extension-gallery-service.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-gallery-service.d.ts","sourceRoot":"","sources":["../../src/services/extension-gallery-service.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAE7C,OAAO,EACH,4BAA4B,EAC5B,yBAAyB,EAGzB,iBAAiB,EACjB,oBAAoB,EACpB,kBAAkB,EAClB,aAAa,EAGb,wBAAwB,EACxB,aAAa,EACb,2BAA2B,EAC9B,MAAM,eAAe,CAAC;AAEvB,qBACa,uBAAwB,YAAW,wBAAwB;IAQ9C,OAAO,CAAC,QAAQ,CAAC,MAAM;IAEzC,OAAO,CAAC,QAAQ,CAAC,wBAAwB;IAEzC,OAAO,CAAC,QAAQ,CAAC,gBAAgB;IAEjC,OAAO,CAAC,QAAQ,CAAC,iBAAiB;IAbtC,OAAO,CAAC,QAAQ,CAAC,WAAW,CAA8B;IAE1D,OAAO,CAAC,QAAQ,CAAC,YAAY,CAAuB;IAEpD,SAAgB,WAAW,6CAA2B;gBAGf,MAAM,EAAE,SAAS,CAAC,OAAO,EAE3C,wBAAwB,EAAE,yBAAyB,EAEnD,gBAAgB,EAAE,4BAA4B,EAE9C,iBAAiB,EAAE,2BAA2B;IAK5D,SAAS,IAAI,OAAO;IAId,KAAK,CAAC,OAAO,GAAE,aAAkB,GAAG,OAAO,CAAC,aAAa,CAAC;IAkC1D,YAAY,CAAC,UAAU,EAAE,oBAAoB,GAAG,MAAM,GAAG,OAAO,CAAC,iBAAiB,GAAG,IAAI,CAAC;IAqB1F,QAAQ,CAAC,SAAS,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAkBvD,SAAS,CAAC,SAAS,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAsBxD,WAAW,CAAC,SAAS,EAAE,iBAAiB,GAAG,OAAO,CAAC,kBAAkB,GAAG,IAAI,CAAC;IAuB7E,YAAY,CAAC,SAAS,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAsB3D,UAAU,CAAC,SAAS,EAAE,iBAAiB,GAAG,OAAO,CAAC,MAAM,CAAC;IAsBzD,qBAAqB,CAAC,SAAS,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,CAAC;YAsC9E,kBAAkB;IA0InB,cAAc,CAAC,SAAS,EAAE,iBAAiB,GAAG,OAAO,CAAC,iBAAiB,EAAE,CAAC;IA2BvF;;;OAGG;IACH,OAAO,CAAC,sBAAsB;IA8CvB,OAAO,IAAI,IAAI;CAGzB"}

package/lib/services/extension-gallery-service.js

@@ -0,0 +1,334 @@
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import'@cdm-logger/core';import {DisposableCollection,Emitter}from'@adminide-stack/core';import {SERVER_TYPES,ExtensionRegistryStatus}from'common/server';let ExtensionGalleryService = class ExtensionGalleryService {
+  logger;
+  registryExtensionService;
+  publisherService;
+  galleryRepository;
+  disposables = new DisposableCollection();
+  _onDidChange = new Emitter();
+  onDidChange = this._onDidChange.event;
+  constructor(logger, registryExtensionService, publisherService, galleryRepository) {
+    this.logger = logger;
+    this.registryExtensionService = registryExtensionService;
+    this.publisherService = publisherService;
+    this.galleryRepository = galleryRepository;
+    this.disposables.push(this._onDidChange);
+  }
+  isEnabled() {
+    return true;
+  }
+  async query(options = {}) {
+    this.logger.trace('ExtensionGalleryService.query with options: %j', options);
+    try {
+      const {
+        text = '',
+        pageSize = 50
+      } = options;
+      const extensions = await this.registryExtensionService.findExtensions(pageSize, text, false,
+      // local
+      true);
+      const galleryExtensions = await Promise.all(extensions.map(ext => this.toGalleryExtension(ext)));
+      return {
+        __typename: 'GalleryPager',
+        firstPage: galleryExtensions,
+        total: galleryExtensions.length,
+        pageSize,
+        page: 0
+      };
+    } catch (error) {
+      this.logger.error('ExtensionGalleryService.query error: %s', error.message);
+      return {
+        __typename: 'GalleryPager',
+        firstPage: [],
+        total: 0,
+        pageSize: options.pageSize || 50,
+        page: 0
+      };
+    }
+  }
+  async getExtension(identifier) {
+    this.logger.trace('ExtensionGalleryService.getExtension: %s', typeof identifier === 'string' ? identifier : identifier.id);
+    try {
+      const extensionId = typeof identifier === 'string' ? identifier : identifier.id;
+      const extension = await this.registryExtensionService.findExtension(extensionId);
+      if (!extension) {
+        return null;
+      }
+      return this.toGalleryExtension(extension);
+    } catch (error) {
+      this.logger.error('ExtensionGalleryService.getExtension error: %s', error.message);
+      return null;
+    }
+  }
+  async download(extension) {
+    this.logger.trace('ExtensionGalleryService.download: %s', extension.id);
+    try {
+      const success = await this.galleryRepository.download(extension);
+      if (success) {
+        // Return the download URL for the extension
+        const downloadUrl = extension.assets?.download?.uri || `${extension.url}/${extension.version}.vsix`;
+        this.logger.info('Extension download prepared: %s -> %s', extension.id, downloadUrl);
+        return downloadUrl;
+      }
+      throw new Error(`Failed to prepare download for extension: ${extension.id}`);
+    } catch (error) {
+      this.logger.error('ExtensionGalleryService.download error: %s', error.message);
+      throw error;
+    }
+  }
+  async getReadme(extension) {
+    this.logger.trace('ExtensionGalleryService.getReadme: %s', extension.id);
+    try {
+      const readmeUrl = extension.assets?.readme?.uri;
+      if (!readmeUrl) {
+        return 'No README available for this extension.';
+      }
+      const readmeAsset = await this.galleryRepository.asset(extension.extensionSlug || extension.id, extension.version, 'README.md');
+      return readmeAsset || 'README content could not be loaded.';
+    } catch (error) {
+      this.logger.warn('Failed to fetch README for %s: %s', extension.id, error.message);
+      return 'Error loading README content.';
+    }
+  }
+  async getManifest(extension) {
+    this.logger.trace('ExtensionGalleryService.getManifest: %s', extension.id);
+    try {
+      // First try to return the already loaded manifest
+      if (extension.manifest) {
+        return extension.manifest;
+      }
+      // If not available, try to fetch from repository
+      const manifestAsset = await this.galleryRepository.asset(extension.extensionSlug || extension.id, extension.version, 'package.json');
+      return manifestAsset;
+    } catch (error) {
+      this.logger.warn('Failed to fetch manifest for %s: %s', extension.id, error.message);
+      return null;
+    }
+  }
+  async getChangelog(extension) {
+    this.logger.trace('ExtensionGalleryService.getChangelog: %s', extension.id);
+    try {
+      const changelogUrl = extension.assets?.changelog?.uri;
+      if (!changelogUrl) {
+        return 'No changelog available for this extension.';
+      }
+      const changelogAsset = await this.galleryRepository.asset(extension.extensionSlug || extension.id, extension.version, 'CHANGELOG.md');
+      return changelogAsset || 'Changelog content could not be loaded.';
+    } catch (error) {
+      this.logger.warn('Failed to fetch changelog for %s: %s', extension.id, error.message);
+      return 'Error loading changelog content.';
+    }
+  }
+  async getLicense(extension) {
+    this.logger.trace('ExtensionGalleryService.getLicense: %s', extension.id);
+    try {
+      const licenseUrl = extension.assets?.license?.uri;
+      if (!licenseUrl) {
+        return 'No license information available for this extension.';
+      }
+      const licenseAsset = await this.galleryRepository.asset(extension.extensionSlug || extension.id, extension.version, 'LICENSE');
+      return licenseAsset || 'License content could not be loaded.';
+    } catch (error) {
+      this.logger.warn('Failed to fetch license for %s: %s', extension.id, error.message);
+      return 'Error loading license information.';
+    }
+  }
+  async loadCompatibleVersion(extension) {
+    this.logger.trace('ExtensionGalleryService.loadCompatibleVersion: %s', extension.id);
+    try {
+      // Get all extensions from registry (search for this specific extension)
+      const allExtensions = await this.registryExtensionService.findExtensions(100, `${extension.publisher.displayName}.${extension.name}`, true, true);
+      // Filter to get versions of the same extension
+      const extensionVersions = allExtensions.filter(ext => ext.name === extension.name);
+      if (!extensionVersions || extensionVersions.length === 0) {
+        // If no versions found, return the current extension
+        return extension;
+      }
+      // Find the latest compatible version
+      const latestVersion = extensionVersions.sort((a, b) => b.version.localeCompare(a.version, undefined, {
+        numeric: true
+      }))[0];
+      // Convert to gallery extension if different from current
+      if (latestVersion.version !== extension.version) {
+        return this.toGalleryExtension(latestVersion);
+      }
+      return extension;
+    } catch (error) {
+      this.logger.warn('Failed to load compatible version for %s: %s', extension.id, error.message);
+      // Return original extension if we can't find a compatible version
+      return extension;
+    }
+  }
+  async toGalleryExtension(registryExt) {
+    let publisherInfo = null;
+    try {
+      const publisherId = registryExt.publisherId || registryExt.publisher;
+      if (publisherId) {
+        publisherInfo = await this.publisherService.findById(publisherId);
+      }
+    } catch (error) {
+      this.logger.warn('Failed to get publisher info: %s', error.message);
+    }
+    const manifest = this.getManifestFromRelease(registryExt);
+    // Get the raw manifest as JSON string for resources.manifest
+    const rawManifest = manifest ? JSON.stringify(manifest) : null;
+    const galleryExtension = {
+      __typename: 'GalleryExtension',
+      id: registryExt.id || registryExt._id?.toString() || '',
+      uuid: registryExt.uuid,
+      name: registryExt.name,
+      displayName: manifest?.displayName || registryExt.name,
+      description: manifest?.description || '',
+      version: registryExt.version || '0.0.1',
+      extensionSlug: registryExt.extensionSlug,
+      manifest: {
+        ...manifest,
+        raw: rawManifest || undefined,
+        // Include raw manifest in manifest object
+        screenshots: manifest?.screenshots || [],
+        author: manifest?.author || undefined,
+        license: manifest?.license || undefined,
+        preview: manifest?.preview || false
+      },
+      publisher: publisherInfo,
+      publisherId: publisherInfo?.id || '',
+      installed: registryExt.installed || false,
+      updatedAt: registryExt.updatedAt,
+      url: registryExt.url,
+      remoteURL: registryExt.remoteURL,
+      status: ExtensionRegistryStatus.Active,
+      viewerCanAdminister: registryExt.viewerCanAdminister || false,
+      isLocal: registryExt.isLocal || false,
+      categories: manifest?.categories || [],
+      tags: manifest?.tags || manifest?.keywords || [],
+      releases: registryExt.releases || [],
+      downloadCount: 0,
+      installCount: 0,
+      weeklyDownloads: 0,
+      rating: 0,
+      ratingCount: 0,
+      featured: false,
+      preview: manifest?.preview || false,
+      date: registryExt.updatedAt?.toISOString(),
+      assets: {
+        __typename: 'GalleryExtensionAssets',
+        icon: {
+          __typename: 'GalleryExtensionAsset',
+          uri: manifest?.icon || './media/defaultIcon.png',
+          fallbackUri: './media/defaultIcon.png'
+        },
+        readme: {
+          __typename: 'GalleryExtensionAsset',
+          uri: `${registryExt.url}/README.md`,
+          fallbackUri: `${registryExt.url}/README.md`
+        },
+        changelog: {
+          __typename: 'GalleryExtensionAsset',
+          uri: `${registryExt.url}/CHANGELOG.md`,
+          fallbackUri: `${registryExt.url}/CHANGELOG.md`
+        },
+        license: {
+          __typename: 'GalleryExtensionAsset',
+          uri: `${registryExt.url}/LICENSE`,
+          fallbackUri: `${registryExt.url}/LICENSE`
+        },
+        download: {
+          __typename: 'GalleryExtensionAsset',
+          uri: `${registryExt.url}/${registryExt.version}.vsix`,
+          fallbackUri: `${registryExt.url}/${registryExt.version}.vsix`
+        },
+        manifest: {
+          __typename: 'GalleryExtensionAsset',
+          uri: `${registryExt.url}/package.json`,
+          fallbackUri: `${registryExt.url}/package.json`
+        }
+      },
+      properties: {
+        __typename: 'GalleryExtensionProperties',
+        dependencies: manifest?.extensionDependencies || [],
+        extensionPack: manifest?.extensionPack || [],
+        engine: manifest?.engines?.vscode || 'unknown',
+        localizedLanguages: []
+      },
+      resources: {
+        __typename: 'GalleryExtensionResources',
+        license: `${registryExt.url}/LICENSE`,
+        repository: manifest?.repository?.url || '',
+        changelog: `${registryExt.url}/CHANGELOG.md`,
+        download: `${registryExt.url}/${registryExt.version}.vsix`,
+        icon: manifest?.icon || './media/defaultIcon.png',
+        manifest: rawManifest || `${registryExt.url}/package.json`,
+        // Store raw manifest JSON string
+        readme: `${registryExt.url}/README.md`
+      },
+      coreExtension: registryExt,
+      identifier: {
+        __typename: 'ExtensionIdentifier',
+        id: registryExt.extensionSlug || registryExt.id,
+        uuid: registryExt.uuid
+      }
+    };
+    return galleryExtension;
+  }
+  async getAllVersions(extension) {
+    this.logger.trace('ExtensionGalleryService.getAllVersions: %s', extension.id);
+    try {
+      // Get all versions from registry
+      const allExtensions = await this.registryExtensionService.findExtensions(1000,
+      // Get more versions
+      `${extension.publisher.displayName}.${extension.name}`, true, true);
+      // Filter to get all versions of the same extension
+      const extensionVersions = allExtensions.filter(ext => ext.name === extension.name);
+      // Convert all to gallery extensions and sort by version (newest first)
+      const galleryVersions = await Promise.all(extensionVersions.map(ext => this.toGalleryExtension(ext)));
+      // Sort by version (descending)
+      return galleryVersions.sort((a, b) => b.version.localeCompare(a.version, undefined, {
+        numeric: true
+      }));
+    } catch (error) {
+      this.logger.warn('Failed to get all versions for %s: %s', extension.id, error.message);
+      // Return empty array if we can't find versions
+      return [];
+    }
+  }
+  /**
+   * Helper method to get manifest from the current release
+   * Since manifests are stored in releases, not directly in the registry extension
+   */
+  getManifestFromRelease(registryExt) {
+    const {
+      releases
+    } = registryExt;
+    if (!releases || releases.length === 0) {
+      return null;
+    }
+    // Find the current release that matches the extension's version
+    const currentRelease = releases.find(release => release.version === registryExt.version);
+    if (!currentRelease || !currentRelease.manifest) {
+      // If no matching release, try the first release
+      const firstRelease = releases[0];
+      if (!firstRelease || !firstRelease.manifest) {
+        return null;
+      }
+      try {
+        // Parse the manifest from the release (stored as JSON string or object)
+        const parsedManifest = typeof firstRelease.manifest === 'string' ? JSON.parse(firstRelease.manifest) : firstRelease.manifest;
+        return parsedManifest;
+      } catch (error) {
+        this.logger.warn('Failed to parse extension manifest for', registryExt.extensionSlug, ':', error);
+        return null;
+      }
+    }
+    try {
+      // Parse the manifest from the release (stored as JSON string or object)
+      const parsedManifest = typeof currentRelease.manifest === 'string' ? JSON.parse(currentRelease.manifest) : currentRelease.manifest;
+      return parsedManifest;
+    } catch (error) {
+      this.logger.warn('Failed to parse extension manifest for', registryExt.extensionSlug, ':', error);
+      return null;
+    }
+  }
+  dispose() {
+    this.disposables.dispose();
+  }
+};
+ExtensionGalleryService = __decorate([injectable(), __param(0, inject('Logger')), __param(1, inject(SERVER_TYPES.IRegistryExtensionService)), __param(2, inject(SERVER_TYPES.IMarketplacePublisherService)), __param(3, inject(SERVER_TYPES.IExtensionGalleryRepository)), __metadata("design:paramtypes", [Object, Object, Object, Object])], ExtensionGalleryService);export{ExtensionGalleryService};//# sourceMappingURL=extension-gallery-service.js.map

package/lib/services/extension-gallery-service.js.map

@@ -0,0 +1 @@
+{"version":3,"file":"extension-gallery-service.js","sources":["../../src/services/extension-gallery-service.ts"],"sourcesContent":[null],"names":[],"mappings":"0PAgCQ,uBAAiB,GAAA,MAAA,uBAAgB,CAAA;QAEjC;AAbJ,EAAA,wBAAiB;AAEjB,EAAA,gBAAQ;AAER,EAAA;AAGuC,EAAA,WAAA,GAAA,IAAA,oBAAkB;AAWlD,EAAA,eAAa,IAAA,OAAO,EAAA;oBAIC,CAAA,YAAkB,MAAG;AAkCpC,EAAA,WAAA,CAAA,MAAa,EAAA,wBAAY,EAAA,gBAAgC,EAAA,iBAAQ,EAAA;IAqBjE,IAAA,CAAA,eAAoB;IAkBpB,IAAA,CAAA,wBAAqB,GAAA,wBAAmC;IAsBxD,IAAA,CAAA,gBAAqB,GAAE,gBAAiB;IAuBxC,IAAA,CAAA,iBAAsB,GAAE;IAsBxB,IAAA,CAAA,gBAAoB,CAAE,IAAA,CAAA,YAAiB;;cA4DtC;IA0ID,OAAA,IAAA;AA2Bb,EAAA;;;AAGG,IAAA,IAAA;AACH,MAAA,MAAQ;AA8CD,QAAA,OAAW,EAAA;AAGrB,QAAA,QAAA,GAAA;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;;"}

package/lib/services/index.d.ts

@@ -1,2 +1,7 @@
-export * from './extension-service';
+export * from './installed-extension-service';
+export * from './installed-extension-service-ext';
+export * from './publisher-service';
+export * from './publisher-event-service';
+export * from './extension-gallery-service';
+export * from './extension-gallery-repository';
 //# sourceMappingURL=index.d.ts.map

package/lib/services/index.d.ts.map

@@ -1 +1 @@
-{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,qBAAqB,CAAC"}
+{"version":3,"file":"index.d.ts","sourceRoot":"","sources":["../../src/services/index.ts"],"names":[],"mappings":"AAAA,cAAc,+BAA+B,CAAC;AAC9C,cAAc,mCAAmC,CAAC;AAClD,cAAc,qBAAqB,CAAC;AACpC,cAAc,2BAA2B,CAAC;AAC1C,cAAc,6BAA6B,CAAC;AAC5C,cAAc,gCAAgC,CAAC"}

package/lib/services/installed-extension-service-ext.d.ts

@@ -0,0 +1,16 @@
+import { ServiceBroker } from 'moleculer';
+import { CdmLogger } from '@cdm-logger/core';
+import { IRegistryExtensionService, IInstalledExtensionRepository, ISlugService, IRedisCacheManager } from 'common/server';
+import { InstalledExtensionService } from './installed-extension-service';
+/**
+ * Extended InstalledExtensionService that handles Moleculer event broadcasting
+ * Follows the pattern of AccountService/AccountServiceExt
+ */
+export declare class InstalledExtensionServiceExt extends InstalledExtensionService {
+    protected slugService: ISlugService;
+    protected readonly redisCacheManager: IRedisCacheManager;
+    constructor(repository: IInstalledExtensionRepository, registryService: IRegistryExtensionService, slugService: ISlugService, redisCacheManager: IRedisCacheManager, broker: ServiceBroker, logger: CdmLogger.ILogger);
+    private setupEventListeners;
+    private dropCache;
+}
+//# sourceMappingURL=installed-extension-service-ext.d.ts.map

package/lib/services/installed-extension-service-ext.d.ts.map

@@ -0,0 +1 @@
+{"version":3,"file":"installed-extension-service-ext.d.ts","sourceRoot":"","sources":["../../src/services/installed-extension-service-ext.ts"],"names":[],"mappings":"AACA,OAAO,EAAE,aAAa,EAAE,MAAM,WAAW,CAAC;AAE1C,OAAO,EAAE,SAAS,EAAE,MAAM,kBAAkB,CAAC;AAC7C,OAAO,EAgBH,yBAAyB,EACzB,6BAA6B,EAO7B,YAAY,EACZ,kBAAkB,EACrB,MAAM,eAAe,CAAC;AACvB,OAAO,EAAE,yBAAyB,EAAE,MAAM,+BAA+B,CAAC;AA0D1E;;;GAGG;AACH,qBACa,4BAA6B,SAAQ,yBAAyB;IAKnE,SAAS,CAAC,WAAW,EAAE,YAAY;IAEnC,SAAS,CAAC,QAAQ,CAAC,iBAAiB,EAAE,kBAAkB;gBALJ,UAAU,EAAE,6BAA6B,EAC7C,eAAe,EAAE,yBAAyB,EAEhF,WAAW,EAAE,YAAY,EAEhB,iBAAiB,EAAE,kBAAkB,EACnB,MAAM,EAAE,aAAa,EAC/B,MAAM,EAAE,SAAS,CAAC,OAAO;IAMxD,OAAO,CAAC,mBAAmB;YA6gBb,SAAS;CA8C1B"}