@fastybird/smart-panel-backend 1.0.0-beta.3 → 1.1.0-alpha.1

package/dist/modules/extensions/services/managed-service-manager.service.d.ts

@@ -0,0 +1,57 @@
+import { OnApplicationBootstrap, OnModuleDestroy } from '@nestjs/common';
+import { ConfigService as NestConfigService } from '@nestjs/config';
+import { ConfigService } from '../../config/services/config.service';
+import { PluginConfigValidatorService } from '../../config/services/plugin-config-validator.service';
+import { NotificationsService } from '../../notifications/services/notifications.service';
+import { IManagedExtensionService, ManagedServiceOwnerKind, ServiceStatusExtended } from './managed-extension-service.interface';
+export declare class ManagedServiceManagerService implements OnApplicationBootstrap, OnModuleDestroy {
+    private readonly configService;
+    private readonly nestConfigService;
+    private readonly pluginConfigValidator;
+    private readonly notifications;
+    private readonly logger;
+    private readonly services;
+    private readonly runtimeInfo;
+    private readonly readinessRetries;
+    private readonly serviceStartPromises;
+    private readonly openIssues;
+    private readonly isCliMode;
+    private startupComplete;
+    private shutdownInProgress;
+    constructor(configService: ConfigService, nestConfigService: NestConfigService, pluginConfigValidator: PluginConfigValidatorService, notifications: NotificationsService);
+    register(service: IManagedExtensionService): void;
+    unregister(extensionKind: ManagedServiceOwnerKind, extensionType: string, serviceId: string): void;
+    onApplicationBootstrap(): Promise<void>;
+    stopAllServices(): Promise<void>;
+    onModuleDestroy(): Promise<void>;
+    handleConfigUpdated(payload?: {
+        source: string;
+        type: 'plugin' | 'module' | 'section';
+    }): Promise<void>;
+    getStatus(): Promise<ServiceStatusExtended[]>;
+    getServiceStatus(extensionKind: ManagedServiceOwnerKind, extensionType: string, serviceId: string): Promise<ServiceStatusExtended | null>;
+    restartService(extensionKind: ManagedServiceOwnerKind, extensionType: string, serviceId: string): Promise<boolean>;
+    startServiceManually(extensionKind: ManagedServiceOwnerKind, extensionType: string, serviceId: string): Promise<boolean>;
+    stopServiceManually(extensionKind: ManagedServiceOwnerKind, extensionType: string, serviceId: string): Promise<boolean>;
+    isRegistered(extensionKind: ManagedServiceOwnerKind, extensionType: string, serviceId: string): boolean;
+    getRegisteredServices(): string[];
+    private getServiceKey;
+    private startServiceIfDesired;
+    private startService;
+    private startServiceOnce;
+    private stopService;
+    private syncServiceState;
+    private scheduleReadinessRetry;
+    private clearReadinessRetryTimer;
+    private clearReadinessRetry;
+    private clearAllReadinessRetries;
+    private waitForState;
+    private getSortedServices;
+    private getServiceLevels;
+    private getRegistrationKey;
+    private getOwnerConfig;
+    private shouldBeRunning;
+    private isConfigChangeResult;
+    private raiseServiceError;
+    private resolveServiceError;
+}

package/dist/modules/extensions/services/{plugin-service-manager.service.js → managed-service-manager.service.js}

@@ -9,7 +9,7 @@ var __metadata = (this && this.__metadata) || function (k, v) {
     if (typeof Reflect === "object" && typeof Reflect.metadata === "function") return Reflect.metadata(k, v);
 };
 Object.defineProperty(exports, "__esModule", { value: true });
-exports.PluginServiceManagerService = void 0;
+exports.ManagedServiceManagerService = void 0;
 const common_1 = require("@nestjs/common");
 const config_1 = require("@nestjs/config");
 const event_emitter_1 = require("@nestjs/event-emitter");
@@ -18,30 +18,40 @@ const config_utils_1 = require("../../../common/utils/config.utils");
 const config_constants_1 = require("../../config/config.constants");
 const config_service_1 = require("../../config/services/config.service");
 const plugin_config_validator_service_1 = require("../../config/services/plugin-config-validator.service");
+const notifications_constants_1 = require("../../notifications/notifications.constants");
+const notifications_utils_1 = require("../../notifications/notifications.utils");
+const notifications_service_1 = require("../../notifications/services/notifications.service");
 const extensions_constants_1 = require("../extensions.constants");
-let PluginServiceManagerService = class PluginServiceManagerService {
-    constructor(configService, nestConfigService, pluginConfigValidator) {
+const READINESS_RETRY_INITIAL_DELAY_MS = 15_000;
+const READINESS_RETRY_MAX_ATTEMPTS = 3;
+let ManagedServiceManagerService = class ManagedServiceManagerService {
+    constructor(configService, nestConfigService, pluginConfigValidator, notifications) {
         this.configService = configService;
         this.nestConfigService = nestConfigService;
         this.pluginConfigValidator = pluginConfigValidator;
-        this.logger = (0, extension_logger_service_1.createExtensionLogger)(extensions_constants_1.EXTENSIONS_MODULE_NAME, 'PluginServiceManagerService');
+        this.notifications = notifications;
+        this.logger = (0, extension_logger_service_1.createExtensionLogger)(extensions_constants_1.EXTENSIONS_MODULE_NAME, 'ManagedServiceManagerService');
         this.services = new Map();
         this.runtimeInfo = new Map();
+        this.readinessRetries = new Map();
+        this.serviceStartPromises = new Map();
+        this.openIssues = new Set();
         this.startupComplete = false;
         this.shutdownInProgress = false;
         this.isCliMode = (0, config_utils_1.getEnvValue)(this.nestConfigService, 'FB_CLI', null) === 'on';
     }
     register(service) {
-        const key = this.getServiceKey(service.pluginName, service.serviceId);
+        const key = this.getServiceKey(service.owner.kind, service.owner.type, service.serviceId);
         if (this.services.has(key)) {
             this.logger.warn(`Service already registered: ${key}`);
-            return;
+            throw new Error(`Service already registered: ${key}`);
         }
         const priority = service.getPriority?.() ?? 100;
         this.services.set(key, {
             service,
-            pluginName: service.pluginName,
+            owner: { ...service.owner },
             serviceId: service.serviceId,
+            activationPolicy: service.activationPolicy ?? 'owner-enabled',
             priority,
         });
         this.runtimeInfo.set(key, {
@@ -49,19 +59,21 @@ let PluginServiceManagerService = class PluginServiceManagerService {
         });
         this.logger.log(`Registered service: ${key} (priority: ${priority})`);
         if (this.startupComplete && !this.isCliMode) {
-            const config = this.getPluginConfig(service.pluginName);
-            if (config?.enabled) {
-                void this.startService(this.services.get(key));
+            const registration = this.services.get(key);
+            if (registration && this.shouldBeRunning(registration)) {
+                void this.startService(registration);
             }
         }
     }
-    unregister(pluginName, serviceId) {
-        const key = this.getServiceKey(pluginName, serviceId);
+    unregister(extensionKind, extensionType, serviceId) {
+        const key = this.getServiceKey(extensionKind, extensionType, serviceId);
         if (!this.services.has(key)) {
             return;
         }
         this.services.delete(key);
         this.runtimeInfo.delete(key);
+        this.openIssues.delete(key);
+        this.clearReadinessRetry(key);
         this.logger.log(`Unregistered service: ${key}`);
     }
     async onApplicationBootstrap() {
@@ -78,13 +90,14 @@ let PluginServiceManagerService = class PluginServiceManagerService {
                 continue;
             }
             this.logger.log(`Starting level ${level} services (${levelServices.length} services)`);
-            await Promise.all(levelServices.map((registration) => this.startServiceIfEnabled(registration)));
+            await Promise.all(levelServices.map((registration) => this.startServiceIfDesired(registration)));
         }
         this.startupComplete = true;
         this.logger.log('All services startup complete');
     }
     async stopAllServices() {
         this.shutdownInProgress = true;
+        this.clearAllReadinessRetries();
         this.logger.log('Stopping all managed services for factory reset');
         const sorted = this.getSortedServices().reverse();
         for (const registration of sorted) {
@@ -105,6 +118,7 @@ let PluginServiceManagerService = class PluginServiceManagerService {
     }
     async onModuleDestroy() {
         this.shutdownInProgress = true;
+        this.clearAllReadinessRetries();
         this.logger.log('Stopping all managed services');
         const sorted = this.getSortedServices().reverse();
         for (const registration of sorted) {
@@ -127,11 +141,9 @@ let PluginServiceManagerService = class PluginServiceManagerService {
         if (this.shutdownInProgress || !this.startupComplete) {
             return;
         }
-        if (payload?.type === 'module') {
-            return;
-        }
         for (const registration of this.services.values()) {
-            if (payload?.type === 'plugin' && registration.pluginName !== payload.source) {
+            if ((payload?.type === 'plugin' || payload?.type === 'module') &&
+                (registration.owner.kind !== payload.type || registration.owner.type !== payload.source)) {
                 continue;
             }
             await this.syncServiceState(registration);
@@ -140,9 +152,11 @@ let PluginServiceManagerService = class PluginServiceManagerService {
     async getStatus() {
         const statuses = [];
         for (const [key, registration] of this.services) {
-            const config = this.getPluginConfig(registration.pluginName);
+            const config = this.getOwnerConfig(registration.owner);
+            const enabled = config?.enabled ?? false;
             const state = registration.service.getState();
             const runtime = this.runtimeInfo.get(key);
+            const desiredState = registration.activationPolicy === 'always' || enabled ? 'started' : 'stopped';
             let healthy;
             if (registration.service.isHealthy && state === 'started') {
                 try {
@@ -157,10 +171,13 @@ let PluginServiceManagerService = class PluginServiceManagerService {
                 uptimeMs = Date.now() - runtime.lastStartedAt.getTime();
             }
             statuses.push({
-                pluginName: registration.pluginName,
+                extensionKind: registration.owner.kind,
+                extensionType: registration.owner.type,
                 serviceId: registration.serviceId,
+                activationPolicy: registration.activationPolicy,
                 state,
-                enabled: config?.enabled ?? false,
+                desiredState,
+                enabled,
                 healthy,
                 lastStartedAt: runtime?.lastStartedAt?.toISOString(),
                 lastStoppedAt: runtime?.lastStoppedAt?.toISOString(),
@@ -171,13 +188,14 @@ let PluginServiceManagerService = class PluginServiceManagerService {
         }
         return statuses;
     }
-    async getServiceStatus(pluginName, serviceId) {
-        const key = this.getServiceKey(pluginName, serviceId);
+    async getServiceStatus(extensionKind, extensionType, serviceId) {
+        const key = this.getServiceKey(extensionKind, extensionType, serviceId);
         const registration = this.services.get(key);
         if (!registration) {
             return null;
         }
-        const config = this.getPluginConfig(pluginName);
+        const config = this.getOwnerConfig(registration.owner);
+        const enabled = config?.enabled ?? false;
         const runtime = this.runtimeInfo.get(key);
         const state = registration.service.getState();
         let healthy;
@@ -194,10 +212,13 @@ let PluginServiceManagerService = class PluginServiceManagerService {
             uptimeMs = Date.now() - runtime.lastStartedAt.getTime();
         }
         return {
-            pluginName,
+            extensionKind,
+            extensionType,
             serviceId,
+            activationPolicy: registration.activationPolicy,
             state,
-            enabled: config?.enabled ?? false,
+            desiredState: registration.activationPolicy === 'always' || enabled ? 'started' : 'stopped',
+            enabled,
             healthy,
             lastStartedAt: runtime?.lastStartedAt?.toISOString(),
             lastStoppedAt: runtime?.lastStoppedAt?.toISOString(),
@@ -206,90 +227,146 @@ let PluginServiceManagerService = class PluginServiceManagerService {
             uptimeMs,
         };
     }
-    async restartService(pluginName, serviceId) {
-        const key = this.getServiceKey(pluginName, serviceId);
+    async restartService(extensionKind, extensionType, serviceId) {
+        const key = this.getServiceKey(extensionKind, extensionType, serviceId);
         const registration = this.services.get(key);
         if (!registration) {
             this.logger.warn(`Service not found: ${key}`);
             return false;
         }
-        const config = this.getPluginConfig(pluginName);
-        if (!config?.enabled) {
-            this.logger.warn(`Cannot restart disabled service: ${key}`);
+        if (!this.shouldBeRunning(registration)) {
+            this.logger.warn(`Cannot restart service whose desired state is stopped: ${key}`);
+            return false;
+        }
+        const currentState = registration.service.getState();
+        if (currentState !== 'started' && currentState !== 'error') {
+            this.logger.warn(`Cannot restart service ${key} from state ${currentState}`);
             return false;
         }
         await this.stopService(registration);
+        if (registration.service.getState() !== 'stopped') {
+            this.logger.warn(`Cannot restart service ${key}: stop did not reach the stopped state`);
+            return false;
+        }
         await this.startService(registration);
-        return true;
+        const resultingState = registration.service.getState();
+        return resultingState === 'started' || resultingState === 'starting';
     }
-    async startServiceManually(pluginName, serviceId) {
-        const key = this.getServiceKey(pluginName, serviceId);
+    async startServiceManually(extensionKind, extensionType, serviceId) {
+        const key = this.getServiceKey(extensionKind, extensionType, serviceId);
         const registration = this.services.get(key);
         if (!registration) {
             this.logger.warn(`Service not found: ${key}`);
             return false;
         }
+        if (!this.shouldBeRunning(registration)) {
+            this.logger.warn(`Cannot start service whose desired state is stopped: ${key}`);
+            return false;
+        }
         const currentState = registration.service.getState();
-        if (currentState === 'started' || currentState === 'starting') {
-            this.logger.warn(`Service ${key} is already ${currentState}`);
+        if (currentState !== 'stopped' && currentState !== 'error') {
+            this.logger.warn(`Cannot start service ${key} from state ${currentState}`);
             return false;
         }
         await this.startService(registration);
-        return registration.service.getState() === 'started';
+        const resultingState = registration.service.getState();
+        return resultingState === 'started' || resultingState === 'starting';
     }
-    async stopServiceManually(pluginName, serviceId) {
-        const key = this.getServiceKey(pluginName, serviceId);
+    async stopServiceManually(extensionKind, extensionType, serviceId) {
+        const key = this.getServiceKey(extensionKind, extensionType, serviceId);
         const registration = this.services.get(key);
         if (!registration) {
             this.logger.warn(`Service not found: ${key}`);
             return false;
         }
+        this.clearReadinessRetry(key);
         const currentState = registration.service.getState();
-        if (currentState === 'stopped' || currentState === 'stopping') {
-            this.logger.warn(`Service ${key} is already ${currentState}`);
+        if (currentState !== 'started' && currentState !== 'starting' && currentState !== 'error') {
+            this.logger.warn(`Cannot stop service ${key} from state ${currentState}`);
             return false;
         }
         await this.stopService(registration);
         return registration.service.getState() === 'stopped';
     }
-    isRegistered(pluginName, serviceId) {
-        return this.services.has(this.getServiceKey(pluginName, serviceId));
+    isRegistered(extensionKind, extensionType, serviceId) {
+        return this.services.has(this.getServiceKey(extensionKind, extensionType, serviceId));
     }
     getRegisteredServices() {
         return Array.from(this.services.keys());
     }
-    getServiceKey(pluginName, serviceId) {
-        return `${pluginName}:${serviceId}`;
+    getServiceKey(extensionKind, extensionType, serviceId) {
+        return `${extensionKind}:${extensionType}:${serviceId}`;
     }
-    async startServiceIfEnabled(registration) {
-        const config = this.getPluginConfig(registration.pluginName);
-        if (!config?.enabled) {
+    async startServiceIfDesired(registration) {
+        if (!this.shouldBeRunning(registration)) {
             return;
         }
         await this.startService(registration);
     }
-    async startService(registration) {
-        const key = this.getServiceKey(registration.pluginName, registration.serviceId);
+    async startService(registration, requireDesiredState = true) {
+        const key = this.getRegistrationKey(registration);
+        const pendingStart = this.serviceStartPromises.get(key);
+        if (pendingStart !== undefined) {
+            await pendingStart;
+            return;
+        }
+        this.clearReadinessRetryTimer(key);
+        const startPromise = this.startServiceOnce(registration, key, requireDesiredState).finally(() => {
+            if (this.serviceStartPromises.get(key) === startPromise)
+                this.serviceStartPromises.delete(key);
+        });
+        this.serviceStartPromises.set(key, startPromise);
+        await startPromise;
+    }
+    async startServiceOnce(registration, key, requireDesiredState) {
         const currentState = registration.service.getState();
         if (currentState === 'started' || currentState === 'starting') {
             return;
         }
         this.logger.log(`Starting service: ${key}`);
-        if (this.pluginConfigValidator.hasValidator(registration.pluginName)) {
-            const config = this.getPluginConfig(registration.pluginName);
+        if (registration.owner.kind === 'plugin' &&
+            registration.activationPolicy === 'owner-enabled' &&
+            this.pluginConfigValidator.hasValidator(registration.owner.type)) {
+            const config = this.getOwnerConfig(registration.owner);
             if (config) {
-                const validationResult = await this.pluginConfigValidator.validate(registration.pluginName, config);
+                let validationResult;
+                try {
+                    validationResult = await this.pluginConfigValidator.validate(registration.owner.type, config);
+                }
+                catch {
+                    const warning = 'Configuration readiness check is temporarily unavailable';
+                    (0, extension_logger_service_1.createExtensionLogger)(registration.owner.type, 'ManagedServiceManagerService').warn(`Service ${registration.serviceId} is enabled but not started because its ${warning.toLowerCase()}.`);
+                    const runtime = this.runtimeInfo.get(key);
+                    if (runtime)
+                        runtime.lastError = warning;
+                    await this.scheduleReadinessRetry(registration);
+                    return;
+                }
+                if (!validationResult.valid && validationResult.transient) {
+                    const warning = 'Configuration readiness check is temporarily unavailable';
+                    (0, extension_logger_service_1.createExtensionLogger)(registration.owner.type, 'ManagedServiceManagerService').warn(`Service ${registration.serviceId} is enabled but not started because its ${warning.toLowerCase()}.`);
+                    const runtime = this.runtimeInfo.get(key);
+                    if (runtime)
+                        runtime.lastError = warning;
+                    await this.scheduleReadinessRetry(registration);
+                    return;
+                }
                 if (!validationResult.valid) {
                     const errors = (validationResult.errors ?? []).map((e) => e.message).join('; ');
-                    this.logger.warn(`Skipping service ${key}: config validation failed — ${errors}`);
+                    (0, extension_logger_service_1.createExtensionLogger)(registration.owner.type, 'ManagedServiceManagerService').warn(`Service ${registration.serviceId} is enabled but not started because configuration needs attention — ${errors}. Configure the plugin in the admin UI.`);
                     const runtime = this.runtimeInfo.get(key);
                     if (runtime) {
                         runtime.lastError = `Config validation failed: ${errors}`;
                     }
+                    this.clearReadinessRetry(key);
                     return;
                 }
             }
         }
+        if (requireDesiredState && (this.shutdownInProgress || !this.shouldBeRunning(registration))) {
+            this.clearReadinessRetry(key);
+            return;
+        }
         try {
             await registration.service.start();
             const runtime = this.runtimeInfo.get(key);
@@ -298,19 +375,26 @@ let PluginServiceManagerService = class PluginServiceManagerService {
                 runtime.startCount += 1;
                 runtime.lastError = undefined;
             }
+            this.clearReadinessRetry(key);
             this.logger.log(`Service started successfully: ${key}`);
+            await this.resolveServiceError(registration);
         }
         catch (error) {
             const err = error;
             const runtime = this.runtimeInfo.get(key);
+            const enteringError = runtime !== undefined && !this.openIssues.has(key);
             if (runtime) {
                 runtime.lastError = err.message;
             }
             this.logger.error(`Failed to start service ${key}: ${err.message}`, err.stack);
+            if (enteringError) {
+                this.openIssues.add(key);
+                await this.raiseServiceError(registration, err.message);
+            }
         }
     }
     async stopService(registration) {
-        const key = this.getServiceKey(registration.pluginName, registration.serviceId);
+        const key = this.getRegistrationKey(registration);
         const currentState = registration.service.getState();
         if (currentState === 'stopped' || currentState === 'stopping') {
             return;
@@ -334,17 +418,18 @@ let PluginServiceManagerService = class PluginServiceManagerService {
         }
     }
     async syncServiceState(registration) {
-        const key = this.getServiceKey(registration.pluginName, registration.serviceId);
-        const config = this.getPluginConfig(registration.pluginName);
+        const key = this.getRegistrationKey(registration);
         let currentState = registration.service.getState();
-        const shouldBeRunning = config?.enabled ?? false;
+        const shouldBeRunning = this.shouldBeRunning(registration);
+        if (!shouldBeRunning)
+            this.clearReadinessRetry(key);
         if (currentState === 'starting' || currentState === 'stopping') {
             const targetState = currentState === 'starting' ? 'started' : 'stopped';
             await this.waitForState(registration, targetState);
             currentState = registration.service.getState();
         }
         if (!shouldBeRunning && (currentState === 'starting' || currentState === 'stopping')) {
-            this.logger.log(`Plugin ${registration.pluginName} disabled while ${registration.serviceId} still in '${currentState}', forcing stop`);
+            this.logger.log(`Service ${key} should be stopped while still in '${currentState}', forcing stop`);
             try {
                 await registration.service.stop();
                 const runtime = this.runtimeInfo.get(key);
@@ -364,15 +449,15 @@ let PluginServiceManagerService = class PluginServiceManagerService {
             return;
         }
         if (shouldBeRunning && currentState === 'stopped') {
-            this.logger.log(`Plugin ${registration.pluginName} enabled, starting ${registration.serviceId}`);
+            this.logger.log(`Service ${key} should be running, starting it`);
             await this.startService(registration);
         }
         else if (shouldBeRunning && currentState === 'error') {
-            this.logger.log(`Plugin ${registration.pluginName} enabled but service in error, restarting ${registration.serviceId}`);
+            this.logger.log(`Service ${key} should be running but is in error, restarting it`);
             await this.startService(registration);
         }
         else if (!shouldBeRunning && currentState === 'started') {
-            this.logger.log(`Plugin ${registration.pluginName} disabled, stopping ${registration.serviceId}`);
+            this.logger.log(`Service ${key} should be stopped, stopping it`);
             await this.stopService(registration);
         }
         else if (!shouldBeRunning && currentState === 'error') {
@@ -393,6 +478,58 @@ let PluginServiceManagerService = class PluginServiceManagerService {
             }
         }
     }
+    async scheduleReadinessRetry(registration) {
+        const key = this.getRegistrationKey(registration);
+        if (this.shutdownInProgress || this.services.get(key) !== registration)
+            return;
+        const current = this.readinessRetries.get(key);
+        if (current?.timer)
+            return;
+        const attempt = (current?.attempt ?? 0) + 1;
+        if (attempt > READINESS_RETRY_MAX_ATTEMPTS) {
+            this.readinessRetries.delete(key);
+            this.logger.warn(`Readiness retries exhausted for service: ${key}`);
+            if (!this.openIssues.has(key)) {
+                this.openIssues.add(key);
+                const runtime = this.runtimeInfo.get(key);
+                await this.raiseServiceError(registration, runtime?.lastError ?? 'Readiness retries exhausted');
+            }
+            return;
+        }
+        const delayMs = READINESS_RETRY_INITIAL_DELAY_MS * 2 ** (attempt - 1);
+        const timer = setTimeout(() => {
+            const retry = this.readinessRetries.get(key);
+            if (!retry || retry.timer !== timer)
+                return;
+            retry.timer = null;
+            if (this.shutdownInProgress || this.services.get(key) !== registration || !this.shouldBeRunning(registration)) {
+                this.clearReadinessRetry(key);
+                return;
+            }
+            void this.startService(registration).catch((error) => {
+                const message = error instanceof Error ? error.message : 'Unknown error';
+                this.logger.error(`Readiness retry failed for service ${key}: ${message}`);
+            });
+        }, delayMs);
+        timer.unref();
+        this.readinessRetries.set(key, { attempt, timer });
+        this.logger.warn(`Scheduled readiness retry ${attempt}/${READINESS_RETRY_MAX_ATTEMPTS} for service ${key} in ${delayMs}ms`);
+    }
+    clearReadinessRetryTimer(key) {
+        const retry = this.readinessRetries.get(key);
+        if (!retry?.timer)
+            return;
+        clearTimeout(retry.timer);
+        retry.timer = null;
+    }
+    clearReadinessRetry(key) {
+        this.clearReadinessRetryTimer(key);
+        this.readinessRetries.delete(key);
+    }
+    clearAllReadinessRetries() {
+        for (const key of this.readinessRetries.keys())
+            this.clearReadinessRetry(key);
+    }
     waitForState(registration, targetState, timeoutMs = 10000) {
         return new Promise((resolve) => {
             const start = Date.now();
@@ -405,7 +542,7 @@ let PluginServiceManagerService = class PluginServiceManagerService {
                     return resolve();
                 }
                 if (Date.now() - start > timeoutMs) {
-                    this.logger.warn(`Timeout waiting for ${registration.pluginName}:${registration.serviceId} to reach ${targetState}`);
+                    this.logger.warn(`Timeout waiting for ${this.getRegistrationKey(registration)} to reach ${targetState}`);
                     return resolve();
                 }
                 setTimeout(check, 50);
@@ -420,7 +557,7 @@ let PluginServiceManagerService = class PluginServiceManagerService {
         const visited = new Set();
         const visiting = new Set();
         const visit = (reg) => {
-            const key = this.getServiceKey(reg.pluginName, reg.serviceId);
+            const key = this.getRegistrationKey(reg);
             if (visited.has(key)) {
                 return;
             }
@@ -450,7 +587,7 @@ let PluginServiceManagerService = class PluginServiceManagerService {
         const serviceLevels = new Map();
         const registrations = Array.from(this.services.values());
         const calculateLevel = (reg, visiting) => {
-            const key = this.getServiceKey(reg.pluginName, reg.serviceId);
+            const key = this.getRegistrationKey(reg);
             if (serviceLevels.has(key)) {
                 return serviceLevels.get(key);
             }
@@ -477,7 +614,7 @@ let PluginServiceManagerService = class PluginServiceManagerService {
             calculateLevel(reg, new Set());
         }
         for (const reg of registrations) {
-            const key = this.getServiceKey(reg.pluginName, reg.serviceId);
+            const key = this.getRegistrationKey(reg);
             const level = serviceLevels.get(key) ?? 0;
             while (levels.length <= level) {
                 levels.push([]);
@@ -489,29 +626,79 @@ let PluginServiceManagerService = class PluginServiceManagerService {
         }
         return levels;
     }
-    getPluginConfig(pluginName) {
+    getRegistrationKey(registration) {
+        return this.getServiceKey(registration.owner.kind, registration.owner.type, registration.serviceId);
+    }
+    getOwnerConfig(owner) {
         try {
-            return this.configService.getPluginConfig(pluginName);
+            return owner.kind === 'module'
+                ? this.configService.getModuleConfig(owner.type)
+                : this.configService.getPluginConfig(owner.type);
         }
         catch {
             return null;
         }
     }
+    shouldBeRunning(registration) {
+        return registration.activationPolicy === 'always' || (this.getOwnerConfig(registration.owner)?.enabled ?? false);
+    }
     isConfigChangeResult(result) {
         return result !== undefined && typeof result === 'object' && 'restartRequired' in result;
     }
+    async raiseServiceError(registration, lastError) {
+        const key = this.getRegistrationKey(registration);
+        await this.notifications.notify({
+            source: registration.owner.type,
+            kind: notifications_constants_1.NotificationKind.ISSUE,
+            key: `service:${key}`,
+            severity: notifications_constants_1.NotificationSeverity.ERROR,
+            title: `Service ${registration.serviceId} of ${registration.owner.type} failed`,
+            message: (0, notifications_utils_1.sanitizeErrorMessage)(lastError),
+            actions: [
+                {
+                    type: notifications_constants_1.NotificationActionType.SERVICE,
+                    label: 'Restart service',
+                    extension_kind: registration.owner.kind,
+                    extension_type: registration.owner.type,
+                    service_id: registration.serviceId,
+                    operation: 'restart',
+                    primary: true,
+                },
+                {
+                    type: notifications_constants_1.NotificationActionType.LINK,
+                    label: 'Open services',
+                    url: `/extensions?tab=services&kind=${registration.owner.kind}`,
+                },
+            ],
+        });
+    }
+    async resolveServiceError(registration) {
+        const key = this.getRegistrationKey(registration);
+        if (!this.openIssues.has(key)) {
+            return;
+        }
+        this.openIssues.delete(key);
+        try {
+            await this.notifications.resolve(registration.owner.type, `service:${key}`);
+        }
+        catch (error) {
+            const err = error;
+            this.logger.error(`Failed to resolve the service issue for ${key}: ${err.message}`, err.stack);
+        }
+    }
 };
-exports.PluginServiceManagerService = PluginServiceManagerService;
+exports.ManagedServiceManagerService = ManagedServiceManagerService;
 __decorate([
     (0, event_emitter_1.OnEvent)(config_constants_1.EventType.CONFIG_UPDATED),
     __metadata("design:type", Function),
     __metadata("design:paramtypes", [Object]),
     __metadata("design:returntype", Promise)
-], PluginServiceManagerService.prototype, "handleConfigUpdated", null);
-exports.PluginServiceManagerService = PluginServiceManagerService = __decorate([
+], ManagedServiceManagerService.prototype, "handleConfigUpdated", null);
+exports.ManagedServiceManagerService = ManagedServiceManagerService = __decorate([
     (0, common_1.Injectable)(),
     __metadata("design:paramtypes", [config_service_1.ConfigService,
         config_1.ConfigService,
-        plugin_config_validator_service_1.PluginConfigValidatorService])
-], PluginServiceManagerService);
-//# sourceMappingURL=plugin-service-manager.service.js.map
+        plugin_config_validator_service_1.PluginConfigValidatorService,
+        notifications_service_1.NotificationsService])
+], ManagedServiceManagerService);
+//# sourceMappingURL=managed-service-manager.service.js.map