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

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

@@ -0,0 +1,633 @@
+import {__decorate,__param,__metadata}from'tslib';import {injectable,inject}from'inversify';import'@cdm-logger/core';import {ServiceBroker}from'moleculer';import {CommonType}from'@common-stack/core';import {Emitter,DisposableCollection}from'@adminide-stack/core';import {BaseService2}from'@common-stack/store-mongo';import {SERVER_TYPES,DB_COLL_NAMES,ExtensionActivationState}from'common/server';var InstalledExtensionService_1;
+let InstalledExtensionService = InstalledExtensionService_1 = class InstalledExtensionService extends BaseService2 {
+  installedExtensionRepository;
+  registryExtensionService;
+  slugService;
+  broker;
+  onExtensionInstalled = new Emitter();
+  onExtensionUninstalled = new Emitter();
+  onExtensionEnabled = new Emitter();
+  onExtensionDisabled = new Emitter();
+  onExtensionUpdated = new Emitter();
+  onExtensionVersionUpdated = new Emitter();
+  onExtensionConfigurationUpdated = new Emitter();
+  onExtensionSyncCompleted = new Emitter();
+  onExtensionCleanupCompleted = new Emitter();
+  onExtensionStatusChanged = new Emitter();
+  onExtensionActivationFailed = new Emitter();
+  onExtensionDeprecated = new Emitter();
+  onExtensionOrphaned = new Emitter();
+  toDispose = new DisposableCollection(this.onExtensionInstalled, this.onExtensionUninstalled, this.onExtensionEnabled, this.onExtensionDisabled, this.onExtensionUpdated, this.onExtensionVersionUpdated, this.onExtensionConfigurationUpdated, this.onExtensionSyncCompleted, this.onExtensionCleanupCompleted, this.onExtensionStatusChanged, this.onExtensionActivationFailed, this.onExtensionDeprecated, this.onExtensionOrphaned);
+  logger;
+  constructor(installedExtensionRepository, registryExtensionService, slugService, broker, logger) {
+    super(installedExtensionRepository);
+    this.installedExtensionRepository = installedExtensionRepository;
+    this.registryExtensionService = registryExtensionService;
+    this.slugService = slugService;
+    this.broker = broker;
+    this.logger = logger.child({
+      className: InstalledExtensionService_1.name
+    });
+  }
+  dispose() {
+    this.toDispose.dispose();
+  }
+  resolveExtensionSlug(extensionSlug) {
+    return this.slugService.resolveSlugWithProvider(DB_COLL_NAMES.ExtensionRegistries, 'extensionSlug', extensionSlug);
+  }
+  /**
+   * Install a new extension from the registry
+   */
+  async installExtension(input, tenantId) {
+    this.logger.debug('Installing extension [%s] for organization [%s] with input [%j]', input.extensionSlug, input.orgId, input);
+    if (!input.orgId) {
+      this.logger.error('Organization ID missing for extension installation [%s]', input.extensionSlug);
+      throw new Error('Organization ID (orgId) is required for extension installation');
+    }
+    this.logger.info('Installing extension [%s] for organization [%s]', input.extensionSlug, input.orgId);
+    // Check if extension already exists for this organization
+    this.logger.debug('Resolving extension slug [%s] to extension ID', input.extensionSlug);
+    const extensionId = await this.resolveExtensionSlug(input.extensionSlug);
+    this.logger.debug('Extension slug [%s] resolved to ID [%s]', input.extensionSlug, extensionId);
+    this.logger.debug('Checking if extension [%s] already exists for organization [%s]', extensionId, input.orgId);
+    const existing = await this.installedExtensionRepository.exists(input.orgId, extensionId);
+    if (existing) {
+      this.logger.warn('Extension [%s] already installed for organization [%s]', input.extensionSlug, input.orgId);
+      throw new Error(`Extension ${input.extensionSlug} is already installed for organization ${input.orgId}`);
+    }
+    // Get extension from registry to validate
+    this.logger.debug('Fetching extension [%s] from registry', input.extensionSlug);
+    const registryExtension = await this.registryExtensionService.findExtension(input.extensionSlug);
+    if (!registryExtension) {
+      this.logger.error('Extension [%s] not found in registry', input.extensionSlug);
+      throw new Error(`Extension ${input.extensionSlug} not found in registry`);
+    }
+    this.logger.debug('Registry extension found [%j]', {
+      id: registryExtension.id,
+      version: registryExtension.version,
+      name: registryExtension.name
+    });
+    // Delegate to the internal install method (validation already done)
+    this.logger.debug('Delegating to doInstallExtension for [%s]', input.extensionSlug);
+    return this.doInstallExtension(input, registryExtension, tenantId);
+  }
+  /**
+   * Internal method to perform the actual installation after validation
+   */
+  async doInstallExtension(input, registryExtension, tenantId) {
+    this.logger.debug('doInstallExtension input [%j]', input);
+    this.logger.debug('doInstallExtension registryExtension [%j]', {
+      id: registryExtension.id,
+      version: registryExtension.version,
+      name: registryExtension.name
+    });
+    const versionToUse = input.version || registryExtension.version;
+    this.logger.debug('Version resolution: input.version=[%s], registryExtension.version=[%s], using=[%s]', input.version, registryExtension.version, versionToUse);
+    // Create the installed extension record with proper defaults
+    const installedExtension = await this.installedExtensionRepository.create({
+      organization: input.orgId,
+      extensionSlug: input.extensionSlug,
+      extension: registryExtension.id,
+      version: versionToUse,
+      installedVersion: registryExtension.version,
+      installedBy: input.installedBy,
+      policies: {
+        allowOrphanedExecution: false,
+        requireSecurityUpdates: true,
+        autoRemoveDeprecated: false,
+        deprecationGracePeriod: 30,
+        ...input.policies
+      },
+      settings: {
+        userEnabled: true,
+        systemEnabled: true,
+        ...input.settings
+      }
+    });
+    // Fire installation event
+    const event = {
+      extensionSlug: input.extensionSlug,
+      installedBy: input.installedBy,
+      installedVersion: installedExtension.installedVersion,
+      registryRef: registryExtension.id,
+      installedAt: new Date().toISOString(),
+      policies: input.policies,
+      settings: input.settings,
+      orgId: input.orgId,
+      tenantId
+    };
+    this.onExtensionInstalled.fire(event);
+    this.logger.info(`Successfully installed extension ${input.extensionSlug}`);
+    return installedExtension;
+  }
+  /**
+   * Uninstall an extension
+   */
+  async uninstallExtension(orgId, extensionSlug, uninstalledBy, tenantId) {
+    this.logger.debug('Uninstalling extension [%s] for org [%s] by user [%s] with tenantId [%s]', extensionSlug, orgId, uninstalledBy, tenantId);
+    this.logger.info('Uninstalling extension [%s] in org [%s]', extensionSlug, orgId);
+    this.logger.debug('Resolving extension slug [%s] to extension ID', extensionSlug);
+    const extensionId = await this.resolveExtensionSlug(extensionSlug);
+    this.logger.debug('Extension slug [%s] resolved to ID [%s]', extensionSlug, extensionId);
+    if (!extensionId) {
+      this.logger.error('Failed to resolve extension slug [%s] - not found in registry', extensionSlug);
+      throw new Error(`Extension ${extensionSlug} not found in registry`);
+    }
+    let extension = null;
+    if (extensionId) {
+      this.logger.debug('Finding extension by org [%s] and extension ID [%s]', orgId, extensionId);
+      // Try to find by extension ID first
+      extension = await this.installedExtensionRepository.findByOrgAndExtensionId(orgId, extensionId);
+      this.logger.debug('Extension found by ID lookup: [%s]', !!extension);
+    }
+    // If not found by extension ID, try alternative methods
+    if (!extension) {
+      this.logger.debug('Extension not found by ID, trying alternative lookup methods');
+      // Instead of complex lookups, let's search all installed extensions
+      // and match by checking if the registry extension has the matching slug
+      const allInstalled = await this.getInstalledExtensions({
+        orgId
+      });
+      this.logger.debug('Found [%d] installed extensions for org [%s]', allInstalled.length, orgId);
+      // For each installed extension, check if it matches our slug
+      for (const installed of allInstalled) {
+        this.logger.debug('Checking installed extension [%j]', {
+          id: installed.id,
+          extensionId: installed.extension
+        });
+        // Since we can't easily look up registry by ID, let's try a different approach
+        // Use the slug service to find if this matches
+        try {
+          // Get the extension slug from the registry extension directly if possible
+          if (installed.extension) {
+            // Try to resolve the extension ID back to slug for comparison
+            const extensionIdString = String(installed.extension);
+            // Check if this extension ID matches what we'd expect for this slug
+            const resolvedExtensionId = await this.resolveExtensionSlug(extensionSlug);
+            this.logger.debug('Comparing extension IDs: installed [%s] vs resolved [%s]', extensionIdString, resolvedExtensionId);
+            if (resolvedExtensionId && resolvedExtensionId === extensionIdString) {
+              this.logger.debug('Found matching extension via alternative lookup');
+              extension = installed;
+              break;
+            }
+          }
+        } catch (error) {
+          this.logger.warn('Error in alternative lookup for extension [%s]: [%s]', installed.id, error.message);
+        }
+      }
+    }
+    if (!extension) {
+      this.logger.error('Extension [%s] not found in org [%s] after all lookup attempts', extensionSlug, orgId);
+      throw new Error(`Extension ${extensionSlug} not found in org ${orgId}`);
+    }
+    this.logger.debug('Found extension to uninstall [%j]', {
+      id: extension.id,
+      extensionId: extension.extension,
+      slug: extension.extensionSlug
+    });
+    // Use the extension ID from the found extension record
+    const actualExtensionId = String(extension.extension);
+    this.logger.debug('Using actual extension ID [%s] for uninstall operations', actualExtensionId);
+    // Check dependencies - prevent uninstalling if other extensions depend on this
+    this.logger.debug('Checking dependency graph for org [%s]', orgId);
+    const dependencyGraph = await this.installedExtensionRepository.getDependencyGraph(orgId);
+    const extensionDeps = dependencyGraph.dependencies.find(dep => dep.extensionId === actualExtensionId);
+    if (extensionDeps && extensionDeps.dependents.length > 0) {
+      this.logger.warn('Cannot uninstall extension [%s]: required by dependents [%j]', extensionSlug, extensionDeps.dependents);
+      throw new Error(`Cannot uninstall ${extensionSlug}: Required by ${extensionDeps.dependents.join(', ')}`);
+    }
+    // Delete the extension using the installed extension's ID
+    this.logger.debug('Attempting to delete extension [%s] from org [%s]', actualExtensionId, orgId);
+    const deleted = await this.installedExtensionRepository.deleteExtension(orgId, actualExtensionId);
+    this.logger.debug('Extension deletion result: [%s]', deleted);
+    if (deleted) {
+      this.logger.debug('Creating uninstall event for extension [%s]', extensionSlug);
+      // Fire uninstallation event
+      const event = {
+        extensionSlug,
+        orgId,
+        tenantId,
+        // Using accountId as tenantId for backward compatibility in events
+        uninstalledBy,
+        uninstalledAt: new Date().toISOString(),
+        wasEnabled: extension.settings?.userEnabled || false,
+        dependencies: extension.dependencies || []
+      };
+      this.logger.debug('Firing uninstall event [%j]', event);
+      this.onExtensionUninstalled.fire(event);
+      this.logger.info('Successfully uninstalled extension [%s] ([%s])', extensionSlug, actualExtensionId);
+    } else {
+      this.logger.error('Failed to delete extension [%s] from database', actualExtensionId);
+    }
+    return deleted;
+  }
+  /**
+   * Update an installed extension's configuration or status
+   */
+  async updateInstalledExtension(orgId, extensionSlug, update, tenantId) {
+    // For now, use orgId as tenantId for backward compatibility until repository is updated
+    this.logger.info(`Updating installed extension ${extensionSlug} for org ${orgId}`);
+    const extensionId = await this.resolveExtensionSlug(extensionSlug);
+    const updatedExtension = await this.installedExtensionRepository.updateExtension(orgId, extensionId, {
+      ...update,
+      lastUpdatedBy: update.lastUpdatedBy
+    });
+    if (!updatedExtension) {
+      throw new Error(`Extension ${extensionId} not found for org ${orgId}`);
+    }
+    // Fire update event if status changed
+    if (update.status || update.settings) {
+      const event = {
+        extensionSlug,
+        tenantId,
+        updatedBy: update.lastUpdatedBy || 'system',
+        updatedAt: new Date().toISOString(),
+        changes: update
+      };
+      this.onExtensionUpdated.fire(event);
+    }
+    return updatedExtension;
+  }
+  /**
+   * Get a specific installed extension
+   */
+  async getInstalledExtension(orgId, extensionSlug) {
+    // For now, use accountId as tenantId for backward compatibility until repository is updated
+    const extensionId = await this.resolveExtensionSlug(extensionSlug);
+    const result = await this.installedExtensionRepository.findByOrgAndExtensionId(orgId, extensionId);
+    return result ? result : null;
+  }
+  /**
+   * Get all installed extensions for a tenant with optional filtering
+   */
+  async getInstalledExtensions(filter) {
+    const results = await this.installedExtensionRepository.findExtensions(filter);
+    return results;
+  }
+  /**
+   * Get all installed extensions for a specific extension by extensionSlug
+   * Useful for finding all organizations that have installed a specific extension
+   */
+  async getInstalledExtensionsBySlug(extensionSlug) {
+    const extensionId = await this.resolveExtensionSlug(extensionSlug);
+    if (!extensionId) {
+      this.logger.warn({
+        extensionSlug
+      }, 'Extension not found in registry');
+      return [];
+    }
+    const results = await this.installedExtensionRepository.findByExtensionId(extensionId);
+    return results;
+  }
+  /**
+   * Enable/disable an installed extension
+   */
+  async toggleExtension(orgId, extensionSlug, enabled, toggledBy, tenantId) {
+    const activationState = enabled ? ExtensionActivationState.Enabled : ExtensionActivationState.DisabledByUser;
+    const updatedExtension = await this.updateInstalledExtension(orgId, extensionSlug, {
+      settings: {
+        userEnabled: enabled
+      },
+      runtime: {
+        activationState,
+        ...(enabled ? {
+          lastActivated: new Date()
+        } : {
+          lastDeactivated: new Date()
+        })
+      },
+      lastUpdatedBy: toggledBy
+    }, tenantId);
+    // Fire toggle event
+    const event = enabled ? {
+      extensionSlug,
+      tenantId,
+      enabledBy: toggledBy,
+      enabledAt: new Date().toISOString(),
+      previousState: updatedExtension.runtime.activationState
+    } : {
+      extensionSlug,
+      tenantId,
+      disabledBy: toggledBy,
+      disabledAt: new Date().toISOString(),
+      reason: 'user'
+    };
+    // Fire status change event
+    if (enabled) {
+      this.onExtensionEnabled.fire(event);
+    } else {
+      this.onExtensionDisabled.fire(event);
+    }
+    return updatedExtension;
+  }
+  /**
+   * Update extension settings/configuration
+   */
+  async updateExtensionSettings(orgId, extensionSlug, userConfig, updatedBy, tenantId) {
+    const updatedExtension = await this.updateInstalledExtension(orgId, extensionSlug, {
+      settings: {
+        userConfig
+      },
+      lastUpdatedBy: updatedBy
+    }, tenantId);
+    // Fire configuration update event
+    const event = {
+      extensionSlug,
+      tenantId,
+      updatedBy,
+      updatedAt: new Date().toISOString(),
+      configType: 'user',
+      newConfig: userConfig
+      // configurationChanges: userConfig,
+      // previousConfiguration: updatedExtension.settings.userConfig,
+    };
+    // Fire configuration update event
+    this.onExtensionConfigurationUpdated.fire(event);
+    return updatedExtension;
+  }
+  /**
+   * Check for extension updates and return available updates
+   */
+  async checkForUpdates(orgId, extensionSlug) {
+    const query = {
+      orgId
+    };
+    if (extensionSlug) {
+      const extensionId = await this.resolveExtensionSlug(extensionSlug);
+      query.extension = extensionId;
+    }
+    const installedExtensions = await this.installedExtensionRepository.findExtensions(query);
+    const updates = [];
+    for (const installed of installedExtensions) {
+      const registryExtension = await this.registryExtensionService.findExtension(installed.extension?.toString());
+      if (registryExtension && registryExtension.version !== installed.installedVersion) {
+        updates.push({
+          extensionId: installed.extension?.toString(),
+          extensionSlug,
+          currentVersion: installed.installedVersion,
+          availableVersion: registryExtension.version,
+          isSecurityUpdate: this.isSecurityUpdate(installed.installedVersion, registryExtension.version)
+        });
+      }
+    }
+    return updates;
+  }
+  /**
+   * Update an extension to a newer version
+   */
+  async updateExtensionVersion(orgId, extensionSlug, targetVersion, updatedBy, tenantId) {
+    const extension = await this.getInstalledExtension(orgId, extensionSlug);
+    if (!extension) {
+      throw new Error(`Extension ${extensionSlug} not found for organization ${orgId}`);
+    }
+    // Validate target version exists in registry
+    const registryExtension = await this.registryExtensionService.findExtension(extensionSlug);
+    if (!registryExtension) {
+      throw new Error(`Extension ${extensionSlug} not found in registry`);
+    }
+    const updatedExtension = await this.updateInstalledExtension(orgId, extensionSlug, {
+      lastUpdatedBy: updatedBy
+      // Note: Version update should be handled at the model level, not through update input
+    }, tenantId);
+    // Fire version update event
+    const event = {
+      extensionSlug,
+      updatedBy,
+      fromVersion: extension.installedVersion,
+      toVersion: targetVersion,
+      updatedAt: new Date().toISOString(),
+      isSecurityUpdate: this.isSecurityUpdate(extension.installedVersion, targetVersion),
+      tenantId
+    };
+    // Fire version update event
+    this.onExtensionVersionUpdated.fire(event);
+    return updatedExtension;
+  }
+  /**
+   * Sync installed extensions with registry status
+   */
+  async syncWithRegistry(orgId, tenantId) {
+    this.logger.info(`Syncing installed extensions with registry for organization ${orgId}`);
+    const installedExtensions = await this.installedExtensionRepository.findExtensions({
+      orgId
+    });
+    const syncUpdates = [];
+    for (const installed of installedExtensions) {
+      const registryExtension = await this.registryExtensionService.findExtension(installed.extension?.toString());
+      if (!registryExtension) {
+        // Extension removed from registry
+        syncUpdates.push({
+          orgId,
+          extensionId: installed.extension?.toString(),
+          registryStatus: 'removed',
+          isOrphaned: true
+        });
+      } else {
+        syncUpdates.push({
+          extensionId: installed.extension?.toString(),
+          registryStatus: registryExtension.status || 'active',
+          latestVersion: registryExtension.version,
+          isOrphaned: false,
+          orgId
+        });
+      }
+    }
+    // For now, map to old format for repository compatibility
+    const repoCompatibleUpdates = syncUpdates.map(update => ({
+      orgId: update.orgId,
+      // Use orgId as tenantId for backward compatibility
+      extensionId: update.extensionId,
+      registryStatus: update.registryStatus,
+      latestVersion: update.latestVersion,
+      isOrphaned: update.isOrphaned
+    }));
+    await this.installedExtensionRepository.syncRegistryStatus(repoCompatibleUpdates);
+    // Fire sync completion event
+    const orphanedUpdates = syncUpdates.filter(u => u.isOrphaned);
+    syncUpdates.filter(u => u.registryStatus === 'deprecated');
+    const versionsUpdates = syncUpdates.filter(u => u.latestVersion);
+    const event = {
+      syncedAt: new Date().toISOString(),
+      extensionsChecked: syncUpdates.length,
+      // syncedExtensions: versionsUpdates.length,
+      extensionsOrphaned: orphanedUpdates.length,
+      extensionsUpdated: versionsUpdates.length,
+      tenantId,
+      errors: []
+      // orphanedExtensions: orphanedUpdates.map((u) => u.extensionId),
+      // deprecatedExtensions: deprecatedUpdates.map((u) => u.extensionId),
+      // updatedExtensions: versionsUpdates.map((u) => u.extensionId),
+    };
+    // Fire sync completed event
+    this.onExtensionSyncCompleted.fire(event);
+    this.logger.info(`Synced ${syncUpdates.length} extensions with registry`);
+  }
+  /**
+   * Get extensions that need attention
+   */
+  async getExtensionsNeedingAttention(orgId) {
+    const extensions = await this.getInstalledExtensions({
+      orgId
+    });
+    const filtered = extensions.filter(ext => {
+      // Check for conditions that need attention
+      const isOrphaned = ext.lifecycle?.isOrphaned;
+      const isDeprecated = ext.lifecycle?.registryStatus === 'deprecated';
+      const hasUpdates = ext.availableVersion && ext.availableVersion !== ext.installedVersion;
+      return isOrphaned || isDeprecated || hasUpdates;
+    });
+    return filtered;
+  }
+  /**
+   * Clean up deprecated or removed extensions based on policies
+   */
+  async cleanupExtensions(orgId, tenantId, dryRun) {
+    // For now, use accountId as tenantId for backward compatibility until repository is updated
+    const result = {
+      removed: [],
+      deprecated: [],
+      warnings: []
+    };
+    const extensions = await this.installedExtensionRepository.findExtensions({
+      orgId
+    });
+    for (const extension of extensions) {
+      const gracePeriodExpired = extension.policies.deprecationGracePeriod > 0 && extension.lifecycle.lastRegistryCheck && Date.now() - new Date(extension.lifecycle.lastRegistryCheck).getTime() > extension.policies.deprecationGracePeriod * 24 * 60 * 60 * 1000;
+      // Remove orphaned extensions
+      if (extension.lifecycle.isOrphaned && !extension.policies.allowOrphanedExecution) {
+        if (!dryRun) {
+          await this.uninstallExtension(orgId, extension.extension?.toString(), 'system-cleanup', tenantId);
+        }
+        result.removed.push(extension.extension?.toString());
+      }
+      // Remove deprecated extensions if auto-remove is enabled and grace period expired
+      else if (extension.lifecycle.registryStatus === 'deprecated' && extension.policies.autoRemoveDeprecated && gracePeriodExpired) {
+        if (!dryRun) {
+          await this.uninstallExtension(orgId, extension.extension?.toString(), 'system-cleanup', tenantId);
+        }
+        result.deprecated.push(extension.extension?.toString());
+      }
+      // Add warnings for extensions that need attention
+      else if (extension.lifecycle.registryStatus === 'deprecated' || extension.lifecycle.isOrphaned) {
+        result.warnings.push(extension.extension?.toString());
+      }
+    }
+    // Fire cleanup completion event
+    const event = {
+      tenantId,
+      cleanedAt: new Date().toISOString(),
+      // cleanupAt: new Date().toISOString(),
+      warnings: result.warnings,
+      dryRun: false,
+      extensionsDeprecated: result.deprecated,
+      extensionsRemoved: result.removed
+    };
+    // Fire cleanup completed event
+    this.onExtensionCleanupCompleted.fire(event);
+    return result;
+  }
+  /**
+   * Sync installed_extensions with system_extension registry
+   * Removes extensions from installed_extensions and configuration_registries
+   * if they are not present in system_extension registry
+   */
+  async cleanupOrphanedExtensions(orgId, tenantId, dryRun) {
+    const result = {
+      removed: [],
+      warnings: []
+    };
+    console.log('🔍 SYNC: Starting extension registry sync...');
+    console.log(`   OrgId: ${orgId}, TenantId: ${tenantId}, DryRun: ${dryRun}`);
+    // Get all installed extensions
+    const extensions = await this.installedExtensionRepository.findExtensions({
+      orgId
+    });
+    console.log(`   Found ${extensions.length} installed extensions`);
+    // Get system_extension document
+    const systemExtensionDoc = await this.broker.call('ConfigurationRegistryService.getConfigurationNodeRegistry', {
+      context: {
+        schemaId: 'configuration',
+        tenantId,
+        extensionName: 'system_extension'
+      }
+    });
+    // Get list of extensions in system_extension
+    const systemExtensionSlugs = new Set();
+    if (systemExtensionDoc && typeof systemExtensionDoc === 'object' && 'configurationNodes' in systemExtensionDoc) {
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const configNodes = systemExtensionDoc.configurationNodes || [];
+      // eslint-disable-next-line @typescript-eslint/no-explicit-any
+      const settingsNode = configNodes.find(node => node.id === 'settings');
+      if (settingsNode?.properties) {
+        Object.keys(settingsNode.properties).forEach(key => {
+          if (key.startsWith('extensions.')) {
+            const slug = key.replace('extensions.', '');
+            systemExtensionSlugs.add(slug);
+          }
+        });
+      }
+    }
+    console.log(`   Found ${systemExtensionSlugs.size} extensions in system_extension registry`);
+    console.log(`   System extensions:`, Array.from(systemExtensionSlugs));
+    // Check each installed extension
+    for (const extension of extensions) {
+      const extensionId = String(extension.extension);
+      // Get the registry extension to find its slug
+      let extensionSlug = null;
+      try {
+        const registryExtension = await this.registryExtensionService.get(extensionId);
+        if (registryExtension) {
+          extensionSlug = registryExtension.extensionSlug || extensionId;
+        }
+      } catch (error) {
+        this.logger.warn(`Failed to fetch registry extension ${extensionId}:`, error);
+      }
+      if (!extensionSlug) {
+        console.log(`⚠️ Could not determine slug for extension ID: ${extensionId}`);
+        result.warnings.push(`Could not determine slug for extension ID: ${extensionId}`);
+      } else if (!systemExtensionSlugs.has(extensionSlug)) {
+        // If extension is in installed_extensions but NOT in system_extension, it's orphaned
+        const orphanMsg = `⚠️ Found orphaned installed_extension: ${extensionSlug} (ID: ${extensionId}) (not in system_extension)`;
+        console.log(orphanMsg);
+        if (!dryRun) {
+          try {
+            // Remove from installed_extensions
+            await this.installedExtensionRepository.deleteExtension(orgId, extensionId);
+            console.log(`   ✅ Deleted from installed_extensions: ${extensionSlug}`);
+            // Remove uiLayout configuration from configuration_registries
+            await this.broker.call('ConfigurationRegistryService.removeConfigurationNodeRegistry', {
+              context: {
+                schemaId: 'uiLayout',
+                tenantId,
+                extensionName: extensionSlug
+              }
+            });
+            console.log(`   ✅ Deleted uiLayout config: ${extensionSlug}`);
+            result.removed.push(extensionSlug);
+          } catch (cleanupError) {
+            console.error(`   ❌ Failed to cleanup ${extensionSlug}:`, cleanupError);
+            result.warnings.push(`Failed to cleanup ${extensionSlug}: ${cleanupError.message}`);
+          }
+        } else {
+          console.log(`   [DRY RUN] Would remove: ${extensionSlug}`);
+          result.removed.push(extensionSlug);
+        }
+      } else {
+        console.log(`✅ Extension ${extensionSlug} is registered in system_extension`);
+      }
+    }
+    console.log('\n✅ SYNC COMPLETE');
+    console.log(`   Removed: ${result.removed.length} extensions`);
+    console.log(`   Warnings: ${result.warnings.length} items`);
+    return result;
+  }
+  /**
+   * Check if update is a security update (simplified logic)
+   */
+  isSecurityUpdate(_currentVersion, _targetVersion) {
+    // Simple heuristic - in a real implementation, this would check
+    // security advisories or version metadata
+    return false;
+  }
+};
+InstalledExtensionService = InstalledExtensionService_1 = __decorate([injectable(), __param(0, inject(SERVER_TYPES.IInstalledExtensionRepository)), __param(1, inject(SERVER_TYPES.IRegistryExtensionService)), __param(2, inject(SERVER_TYPES.SlugService)), __param(3, inject(CommonType.MOLECULER_BROKER)), __param(4, inject(CommonType.LOGGER)), __metadata("design:paramtypes", [Object, Object, Object, ServiceBroker, Object])], InstalledExtensionService);export{InstalledExtensionService};//# sourceMappingURL=installed-extension-service.js.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"installed-extension-service.js","sources":["../../src/services/installed-extension-service.ts"],"sourcesContent":[null],"names":[],"mappings":"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"}

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

@@ -0,0 +1 @@
+//# sourceMappingURL=installed-extension-service.test.d.ts.map

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

@@ -0,0 +1 @@
+{"version":3,"file":"installed-extension-service.test.d.ts","sourceRoot":"","sources":["../../src/services/installed-extension-service.test.ts"],"names":[],"mappings":""}