@nextclaw/service 0.1.1

package/dist/shared/services/gateway/nextclaw-gateway-runtime.service.js

@@ -0,0 +1,337 @@
+import { getPackageVersion as getPackageVersion$1 } from "../../utils/package/package-manifest.utils.js";
+import { openBrowser, resolveUiConfig, resolveUiStaticDir } from "../../utils/cli.utils.js";
+import { localUiRuntimeStore } from "../../stores/local-ui-runtime.store.js";
+import { managedServiceStateStore } from "../../stores/managed-service-state.store.js";
+import { logStartupTrace, measureStartupAsync, measureStartupSync } from "../../utils/startup-trace.js";
+import { GatewayControllerImpl } from "../../controllers/gateway.controller.js";
+import { companionRuntimeService } from "../ui/companion-runtime.service.js";
+import { createRuntimeControlHost } from "../ui/runtime-control-host.service.js";
+import { NpmRuntimeUpdateHost } from "../ui/npm-runtime-update-host.service.js";
+import { ServiceMarketplaceInstaller } from "../marketplace/service-marketplace-installer.service.js";
+import { resolveChannelConfigView } from "../../../commands/channel/channel-config-view.js";
+import { ServiceExtensionRuntime } from "../extensions/service-extension-runtime.service.js";
+import { ServiceFileWatcherRegistry, markLocalUiRuntimeIfStarted, startGatewayRuntimeSupport, watchServiceConfigFile } from "./service-startup-support.service.js";
+import { GatewayPluginManager } from "./managers/gateway-plugin.manager.js";
+import { GatewayRemoteManager } from "./managers/gateway-remote.manager.js";
+import { GatewayRestartWakeService } from "./gateway-restart-wake.service.js";
+import { createCronJobHandler } from "./cron-job-handler.service.js";
+import { handleGatewayDeferredStartupError } from "./utils/gateway-runtime-lifecycle.utils.js";
+import { NextclawApp } from "./nextclaw-app.service.js";
+import { ServiceBootstrapStatusStore } from "./service-bootstrap-status.js";
+import { createDeferredUiNcpAgent } from "../session/service-deferred-ncp-agent.service.js";
+import { installPluginRuntimeBridge } from "../plugin/utils/plugin-runtime-bridge.utils.js";
+import { wrapStartChannelsWithDevPluginHotReload } from "../plugin/utils/plugin-dev-hot-reload.utils.js";
+import { resolve } from "node:path";
+import * as NextclawCore from "@nextclaw/core";
+import { startUiServer } from "@nextclaw/server";
+import { setPluginRuntimeBridge } from "@nextclaw/openclaw-compat";
+import { NextclawKernel, runGatewayInboundLoop } from "@nextclaw/kernel";
+import { setImmediate } from "node:timers/promises";
+//#region src/shared/services/gateway/nextclaw-gateway-runtime.service.ts
+const { getConfigPath: getConfigPath$1, getDataDir: getDataDir$1, getWorkspacePath: getWorkspacePath$1, saveConfig: saveConfig$1 } = NextclawCore;
+const DEV_PLUGIN_HOT_RELOAD_STARTUP_SETTLE_MS = 5e3;
+function resolveApplyRestartMode(uiPort) {
+	const serviceState = managedServiceStateStore.read();
+	if (serviceState?.pid === process.pid) return "managed-service-restart";
+	if (process.env.NEXTCLAW_RUNTIME_BUNDLE_CHILD === "1" && typeof serviceState?.uiPort === "number" && serviceState.uiPort === uiPort) return "managed-service-restart";
+	return "manual-process-restart";
+}
+var NextclawGatewayRuntime = class {
+	kernel;
+	appEventBus;
+	messageBus;
+	sessionManager;
+	automation;
+	runtimeControl;
+	runtimeUpdate;
+	ingress;
+	productVersion;
+	providerManager;
+	gatewayController;
+	configManager;
+	uiConfig;
+	uiStaticDir;
+	workspace;
+	remoteManager;
+	marketplace;
+	plugins;
+	restartWake;
+	bootstrapStatus;
+	uiStartup;
+	extensions;
+	liveAgentRuntime = null;
+	fileWatchers = new ServiceFileWatcherRegistry();
+	deferredChannelStarter;
+	constructor(deps, options = {}) {
+		this.deps = deps;
+		this.options = options;
+		const configPath = getConfigPath$1();
+		this.kernel = measureStartupSync("service.gateway.kernel", () => new NextclawKernel({
+			homeDir: getDataDir$1(),
+			configPath
+		}));
+		this.configManager = this.kernel.configManager;
+		const config = this.configManager.config;
+		this.uiConfig = resolveUiConfig(config, options.uiOverrides);
+		this.uiStaticDir = options.uiStaticDir === void 0 ? resolveUiStaticDir() : options.uiStaticDir;
+		this.workspace = getWorkspacePath$1(config.agents.defaults.workspace);
+		this.appEventBus = this.kernel.eventBus;
+		this.ingress = this.kernel.ingress;
+		this.messageBus = this.kernel.messageBus;
+		this.sessionManager = this.kernel.sessions;
+		this.automation = this.kernel.automation;
+		this.productVersion = getPackageVersion$1();
+		this.plugins = new GatewayPluginManager(this);
+		this.providerManager = this.kernel.llmProviders;
+		this.installConfigRuntimeHooks();
+		this.restartWake = new GatewayRestartWakeService(this);
+		this.bootstrapStatus = this.createBootstrapStatus();
+		this.uiStartup = this.createDisabledUiStartup();
+		this.extensions = new ServiceExtensionRuntime(this);
+		this.remoteManager = new GatewayRemoteManager({
+			deps: this.deps,
+			configManager: this.configManager,
+			uiConfig: this.uiConfig
+		});
+		this.marketplace = this.createMarketplace();
+		this.runtimeControl = createRuntimeControlHost({
+			serviceCommands: this.deps,
+			requestRestart: this.deps.requestRestart,
+			uiConfig: this.uiConfig
+		});
+		this.runtimeUpdate = process.env.NEXTCLAW_DISABLE_RUNTIME_UPDATE_HOST === "1" ? null : new NpmRuntimeUpdateHost({
+			eventBus: this.appEventBus,
+			applyRestartMode: resolveApplyRestartMode(this.uiConfig.port),
+			requestRestart: this.deps.requestRestart,
+			uiConfig: this.uiConfig
+		});
+		this.gatewayController = this.createGatewayController();
+		this.kernel.agentRuntimeManager.connectGatewayController(this.gatewayController);
+		this.deferredChannelStarter = this.startChannels;
+		this.automation.onJob = createCronJobHandler({
+			resolveNcpAgent: () => this.liveAgentRuntime,
+			bus: this.messageBus
+		});
+	}
+	start = async () => {
+		logStartupTrace("service.start_gateway.begin");
+		await this.reset();
+		this.configureIngressHandlers();
+		this.uiStartup = await this.startUiRuntime();
+		await companionRuntimeService.applyConfig(this.configManager.config);
+		await this.markUiRuntimeReady();
+		await this.startSupportServices();
+		this.installChannelDevHotReload();
+		await this.runRuntimeLoop();
+		await companionRuntimeService.ensureStopped();
+		logStartupTrace("service.start_gateway.end");
+	};
+	reset = async () => {
+		await this.fileWatchers.clear();
+		this.bootstrapStatus = this.createBootstrapStatus();
+		this.uiStartup = this.createDisabledUiStartup();
+		this.deferredChannelStarter = this.startChannels;
+		this.liveAgentRuntime = null;
+	};
+	get ncpAgent() {
+		return this.uiStartup.deferredNcpAgent.agent;
+	}
+	activateAgentRuntime = (ncpAgent) => {
+		this.liveAgentRuntime = ncpAgent;
+		if (this.uiConfig.enabled) this.uiStartup.deferredNcpAgent.activate(ncpAgent);
+		this.bootstrapStatus.markNcpAgentReady();
+	};
+	createBootstrapStatus = () => {
+		const bootstrapStatus = new ServiceBootstrapStatusStore();
+		bootstrapStatus.markNcpAgentPending();
+		bootstrapStatus.markPluginHydrationPending();
+		bootstrapStatus.markChannelsPending();
+		bootstrapStatus.setRemoteState(this.configManager.config.remote.enabled ? "pending" : "disabled");
+		return bootstrapStatus;
+	};
+	createDisabledUiStartup = () => ({
+		deferredNcpAgent: createDeferredUiNcpAgent(),
+		endpoint: ""
+	});
+	startUiRuntime = async () => {
+		const uiStartup = await measureStartupAsync("service.start_ui_runtime", async () => {
+			logStartupTrace("service.start_ui_runtime.begin");
+			if (!this.uiConfig.enabled) return this.createDisabledUiStartup();
+			const deferredNcpAgent = this.uiStartup.deferredNcpAgent;
+			const uiServer = await startUiServer(this.createUiRouterOptions());
+			const uiUrl = NextclawCore.resolveLocalUiBaseUrl({
+				host: uiServer.host,
+				port: uiServer.port
+			});
+			console.log(`✓ UI API: ${uiUrl}/api`);
+			if (this.uiStaticDir) console.log(`✓ UI frontend: ${uiUrl}`);
+			if (this.uiConfig.open) openBrowser(uiUrl);
+			logStartupTrace("service.start_ui_runtime.ready", {
+				host: uiServer.host,
+				port: uiServer.port
+			});
+			return {
+				deferredNcpAgent,
+				endpoint: uiUrl
+			};
+		});
+		markLocalUiRuntimeIfStarted({
+			uiStartup: this.uiConfig.enabled ? uiStartup : null,
+			uiConfig: this.uiConfig
+		});
+		return uiStartup;
+	};
+	createUiRouterOptions = () => ({
+		configPath: this.configManager.configPath,
+		appEventBus: this.appEventBus,
+		ingress: this.ingress,
+		uiConfig: this.uiConfig,
+		uiStaticDir: this.uiStaticDir,
+		productVersion: this.productVersion,
+		applyLiveConfigReload: this.configManager.applyLiveConfigReload,
+		initializeAgentHomeDirectory: this.deps.initializeAgentHomeDirectory,
+		marketplace: this.marketplace,
+		cron: this.automation,
+		ncpAgent: this.ncpAgent,
+		sessions: this.kernel.ncpSessionApi,
+		remoteAccess: this.remoteManager.remoteAccess,
+		runtimeControl: this.runtimeControl,
+		...this.runtimeUpdate ? { runtimeUpdate: this.runtimeUpdate } : {},
+		bootstrapStatus: this.bootstrapStatus,
+		plugins: this.plugins,
+		providers: this.providerManager
+	});
+	runRuntimeLoop = async () => {
+		logStartupTrace("service.start_gateway.runtime_loop_begin");
+		let startupTask = null;
+		try {
+			const runtimeLoopTask = runGatewayInboundLoop(this);
+			startupTask = this.startDeferredRuntime();
+			startupTask.catch((error) => handleGatewayDeferredStartupError({
+				bootstrapStatus: this.bootstrapStatus,
+				error
+			}));
+			await runtimeLoopTask;
+		} finally {
+			if (startupTask) await startupTask.catch(() => void 0);
+			await this.cleanup();
+		}
+	};
+	startDeferredRuntime = async () => {
+		await new NextclawApp(this).start();
+	};
+	startDeferredChannels = async () => {
+		await this.deferredChannelStarter();
+	};
+	installChannelDevHotReload = () => {
+		this.deferredChannelStarter = wrapStartChannelsWithDevPluginHotReload({
+			startChannels: this.startChannels,
+			watcherRegistry: this.fileWatchers,
+			isRuntimeActive: () => true,
+			reloadPlugins: async (pluginIds) => {
+				await this.plugins.reloadForDevHotReload(pluginIds.map((pluginId) => `plugins.entries.${pluginId}.source`));
+			},
+			startupSettleMs: DEV_PLUGIN_HOT_RELOAD_STARTUP_SETTLE_MS
+		});
+	};
+	startChannels = async () => {
+		await this.kernel.channels.start();
+		const enabledChannels = this.kernel.channels.enabledChannels;
+		if (enabledChannels.length > 0) console.log(`✓ Channels enabled: ${enabledChannels.join(", ")}`);
+		else console.log("Warning: No channels enabled");
+		this.bootstrapStatus.markChannelsReady(enabledChannels);
+		this.bootstrapStatus.markReady();
+	};
+	createMarketplace = () => ({
+		apiBaseUrl: process.env.NEXTCLAW_MARKETPLACE_API_BASE,
+		installer: new ServiceMarketplaceInstaller({
+			applyLiveConfigReload: this.configManager.applyLiveConfigReload,
+			runCliSubcommand: this.deps.runCliSubcommand,
+			installBuiltinSkill: this.deps.installBuiltinMarketplaceSkill
+		}).createInstaller()
+	});
+	cleanup = async () => {
+		localUiRuntimeStore.clearIfOwnedByProcess();
+		await this.fileWatchers.clear();
+		this.liveAgentRuntime = null;
+		await this.uiStartup.deferredNcpAgent.close();
+		await this.extensions.stop();
+		await this.remoteManager.stop();
+		await this.plugins.stopGateways();
+		setPluginRuntimeBridge(null);
+	};
+	markUiRuntimeReady = async () => {
+		this.bootstrapStatus.markShellReady();
+		await setImmediate();
+	};
+	createGatewayController = () => {
+		return measureStartupSync("service.gateway.gateway_controller", () => new GatewayControllerImpl({
+			configManager: this.configManager,
+			channels: this.kernel.channels,
+			cron: this.automation,
+			sessionManager: this.sessionManager,
+			getConfigPath: getConfigPath$1,
+			saveConfig: saveConfig$1,
+			requestRestart: async (options) => {
+				await this.deps.requestRestart({
+					reason: options?.reason ?? "gateway tool restart",
+					manualMessage: "Restart the gateway to apply changes.",
+					strategy: "background-service-or-exit",
+					delayMs: options?.delayMs,
+					silentOnServiceRestart: true
+				});
+			}
+		}));
+	};
+	startSupportServices = async () => {
+		this.plugins.publishConfigChanges();
+		this.configurePluginRuntime();
+		await measureStartupAsync("service.start_gateway_support_services", async () => await startGatewayRuntimeSupport({
+			automation: this.automation,
+			remoteModule: this.remoteManager.remoteModule,
+			watchConfigFile: () => watchServiceConfigFile({
+				configPath: resolve(getConfigPath$1()),
+				watcherRegistry: this.fileWatchers,
+				scheduleReload: (reason) => this.configManager.scheduleReload(reason)
+			}),
+			watcherRegistry: this.fileWatchers
+		}));
+	};
+	configurePluginRuntime = () => {
+		installPluginRuntimeBridge(this);
+	};
+	installConfigRuntimeHooks = () => {
+		this.configManager.installRuntimeHooks({
+			resolveChannelConfig: (nextConfig) => resolveChannelConfigView(nextConfig, this.kernel.extensions.getChannelBindings()),
+			getExtensionChannels: () => this.kernel.extensions.getExtensionRegistry().channels,
+			reloadCompanion: async ({ config: nextConfig }) => {
+				await companionRuntimeService.applyConfig(nextConfig);
+			},
+			reloadPlugins: async ({ config: nextConfig, changedPaths }) => {
+				const result = await this.plugins.reloadForConfigChange({
+					config: nextConfig,
+					changedPaths
+				});
+				if (result.restartChannels) console.log("Config reload: plugin channel gateways restarted.");
+				return { restartChannels: result.restartChannels };
+			},
+			reloadMcp: async ({ config: nextConfig }) => {
+				await this.liveAgentRuntime?.applyMcpConfig?.(nextConfig);
+			},
+			onRestartRequired: (paths) => {
+				this.deps.requestRestart({
+					changedPaths: paths,
+					manualMessage: `已保存以下改动，等待你手动重启后生效：${paths.join(", ")}`,
+					mode: "notify",
+					reason: `config reload requires restart: ${paths.join(", ")}`,
+					strategy: "background-service-or-manual"
+				});
+			}
+		});
+	};
+	configureIngressHandlers = () => {
+		this.extensions.registerIngressHandlers(this.ingress);
+	};
+};
+//#endregion
+export { NextclawGatewayRuntime };

package/dist/shared/services/gateway/service-bootstrap-status.d.ts

@@ -0,0 +1,33 @@
+import { BootstrapRemoteState, BootstrapStatusView } from "@nextclaw/server";
+
+//#region src/shared/services/gateway/service-bootstrap-status.d.ts
+declare class ServiceBootstrapStatusStore {
+  private state;
+  getStatus(): BootstrapStatusView;
+  markShellReady(): void;
+  markNcpAgentPending(): void;
+  markNcpAgentRunning(): void;
+  markNcpAgentReady(): void;
+  markNcpAgentError(error: string): void;
+  markPluginHydrationPending(): void;
+  markPluginHydrationRunning(params: {
+    totalPluginCount: number;
+  }): void;
+  markPluginHydrationProgress(params: {
+    loadedPluginCount: number;
+    totalPluginCount?: number;
+  }): void;
+  markPluginHydrationReady(params: {
+    loadedPluginCount: number;
+    totalPluginCount: number;
+  }): void;
+  markPluginHydrationError(error: string): void;
+  markChannelsPending(): void;
+  markChannelsReady(enabled: string[]): void;
+  markChannelsError(error: string): void;
+  setRemoteState(state: BootstrapRemoteState, message?: string): void;
+  markReady(): void;
+  markError(error: string): void;
+}
+//#endregion
+export { ServiceBootstrapStatusStore };

package/dist/shared/services/gateway/service-bootstrap-status.js

@@ -0,0 +1,152 @@
+//#region src/shared/services/gateway/service-bootstrap-status.ts
+function now() {
+	return (/* @__PURE__ */ new Date()).toISOString();
+}
+var ServiceBootstrapStatusStore = class {
+	state = {
+		phase: "kernel-starting",
+		ncpAgent: { state: "pending" },
+		pluginHydration: {
+			state: "pending",
+			loadedPluginCount: 0,
+			totalPluginCount: 0
+		},
+		channels: {
+			state: "pending",
+			enabled: []
+		},
+		remote: { state: "pending" }
+	};
+	getStatus() {
+		return {
+			...this.state,
+			ncpAgent: { ...this.state.ncpAgent },
+			pluginHydration: { ...this.state.pluginHydration },
+			channels: {
+				...this.state.channels,
+				enabled: [...this.state.channels.enabled]
+			},
+			remote: { ...this.state.remote }
+		};
+	}
+	markShellReady() {
+		this.state.phase = "shell-ready";
+		this.state.shellReadyAt = this.state.shellReadyAt ?? now();
+	}
+	markNcpAgentPending() {
+		this.state.ncpAgent = { state: "pending" };
+	}
+	markNcpAgentRunning() {
+		this.state.ncpAgent = {
+			state: "running",
+			startedAt: this.state.ncpAgent.startedAt ?? now(),
+			completedAt: void 0,
+			error: void 0
+		};
+	}
+	markNcpAgentReady() {
+		this.state.ncpAgent = {
+			state: "ready",
+			startedAt: this.state.ncpAgent.startedAt ?? now(),
+			completedAt: now(),
+			error: void 0
+		};
+	}
+	markNcpAgentError(error) {
+		this.state.ncpAgent = {
+			state: "error",
+			startedAt: this.state.ncpAgent.startedAt ?? now(),
+			completedAt: now(),
+			error
+		};
+	}
+	markPluginHydrationPending() {
+		this.state.pluginHydration = {
+			...this.state.pluginHydration,
+			state: "pending",
+			loadedPluginCount: 0,
+			totalPluginCount: 0
+		};
+	}
+	markPluginHydrationRunning(params) {
+		this.state.phase = "hydrating-capabilities";
+		this.state.pluginHydration = {
+			...this.state.pluginHydration,
+			state: "running",
+			loadedPluginCount: 0,
+			totalPluginCount: params.totalPluginCount,
+			startedAt: this.state.pluginHydration.startedAt ?? now(),
+			completedAt: void 0,
+			error: void 0
+		};
+	}
+	markPluginHydrationProgress(params) {
+		this.state.pluginHydration = {
+			...this.state.pluginHydration,
+			state: "running",
+			loadedPluginCount: params.loadedPluginCount,
+			totalPluginCount: params.totalPluginCount ?? this.state.pluginHydration.totalPluginCount
+		};
+	}
+	markPluginHydrationReady(params) {
+		this.state.pluginHydration = {
+			...this.state.pluginHydration,
+			state: "ready",
+			loadedPluginCount: params.loadedPluginCount,
+			totalPluginCount: params.totalPluginCount,
+			completedAt: now(),
+			error: void 0
+		};
+	}
+	markPluginHydrationError(error) {
+		this.state.phase = "error";
+		this.state.lastError = error;
+		this.state.pluginHydration = {
+			...this.state.pluginHydration,
+			state: "error",
+			completedAt: now(),
+			error
+		};
+	}
+	markChannelsPending() {
+		this.state.channels = {
+			state: "pending",
+			enabled: []
+		};
+	}
+	markChannelsReady(enabled) {
+		this.state.channels = {
+			state: "ready",
+			enabled: [...enabled]
+		};
+		if (this.state.pluginHydration.state === "ready") {
+			this.state.phase = "ready";
+			this.state.lastError = void 0;
+		}
+	}
+	markChannelsError(error) {
+		this.state.phase = "error";
+		this.state.lastError = error;
+		this.state.channels = {
+			state: "error",
+			enabled: [...this.state.channels.enabled],
+			error
+		};
+	}
+	setRemoteState(state, message) {
+		this.state.remote = {
+			state,
+			...message ? { message } : {}
+		};
+	}
+	markReady() {
+		this.state.phase = "ready";
+		this.state.lastError = void 0;
+	}
+	markError(error) {
+		this.state.phase = "error";
+		this.state.lastError = error;
+	}
+};
+//#endregion
+export { ServiceBootstrapStatusStore };

package/dist/shared/services/gateway/service-startup-support.service.d.ts

@@ -0,0 +1,42 @@
+import { Config } from "@nextclaw/core";
+import { RemoteServiceModule } from "@nextclaw/remote";
+import { PluginDiagnostic } from "@nextclaw/openclaw-compat";
+import { AutomationManager } from "@nextclaw/kernel";
+import { FSWatcher } from "chokidar";
+
+//#region src/shared/services/gateway/service-startup-support.service.d.ts
+declare const pluginGatewayLogger: {
+  info: (message: string) => void;
+  warn: (message: string) => void;
+  error: (message: string) => void;
+  debug: (message: string) => void;
+};
+declare function logPluginGatewayDiagnostics(diagnostics: PluginDiagnostic[]): void;
+declare function startGatewaySupportServices(params: {
+  automation: AutomationManager;
+  remoteModule: RemoteServiceModule | null;
+  watchConfigFile: () => void;
+}): Promise<void>;
+declare function watchCronStoreFile(automation: AutomationManager): FSWatcher;
+declare function watchServiceConfigFile(params: {
+  configPath: string;
+  watcherRegistry: ServiceFileWatcherRegistry;
+  scheduleReload: (reason: string) => void;
+}): void;
+declare class ServiceFileWatcherRegistry {
+  private readonly watchers;
+  readonly remember: (watcher: FSWatcher) => void;
+  readonly clear: () => Promise<void>;
+}
+declare function markLocalUiRuntimeIfStarted(params: {
+  uiStartup: unknown | null | undefined;
+  uiConfig: Pick<Config["ui"], "host" | "port">;
+}): void;
+declare function startGatewayRuntimeSupport(params: {
+  automation: AutomationManager;
+  remoteModule: RemoteServiceModule | null;
+  watchConfigFile: () => void;
+  watcherRegistry: ServiceFileWatcherRegistry;
+}): Promise<void>;
+//#endregion
+export { ServiceFileWatcherRegistry, logPluginGatewayDiagnostics, markLocalUiRuntimeIfStarted, pluginGatewayLogger, startGatewayRuntimeSupport, startGatewaySupportServices, watchCronStoreFile, watchServiceConfigFile };

package/dist/shared/services/gateway/service-startup-support.service.js

@@ -0,0 +1,96 @@
+import { localUiRuntimeStore } from "../../stores/local-ui-runtime.store.js";
+import { resolve } from "node:path";
+import chokidar from "chokidar";
+//#region src/shared/services/gateway/service-startup-support.service.ts
+const pluginGatewayLogger = {
+	info: (message) => console.log(`[plugins] ${message}`),
+	warn: (message) => console.warn(`[plugins] ${message}`),
+	error: (message) => console.error(`[plugins] ${message}`),
+	debug: (message) => console.debug(`[plugins] ${message}`)
+};
+function logPluginGatewayDiagnostics(diagnostics) {
+	for (const diag of diagnostics) {
+		const text = `${diag.pluginId ? `${diag.pluginId}: ` : ""}${diag.message}`;
+		if (diag.level === "error") console.error(`[plugins] ${text}`);
+		else console.warn(`[plugins] ${text}`);
+	}
+}
+async function startGatewaySupportServices(params) {
+	const { automation, remoteModule, watchConfigFile } = params;
+	const cronJobs = automation.status().jobs;
+	if (cronJobs > 0) console.log(`✓ Cron: ${cronJobs} scheduled jobs`);
+	remoteModule?.start();
+	watchConfigFile();
+	await automation.start();
+}
+function watchCronStoreFile(automation) {
+	const cronStorePath = resolve(automation.storePath);
+	const watcher = chokidar.watch(cronStorePath, {
+		ignoreInitial: true,
+		awaitWriteFinish: {
+			stabilityThreshold: 200,
+			pollInterval: 50
+		}
+	});
+	watcher.on("all", (event, changedPath) => {
+		if (resolve(changedPath) !== cronStorePath) return;
+		if (event === "add" || event === "change" || event === "unlink") try {
+			automation.reloadFromStore();
+		} catch (error) {
+			console.error(`Cron store reload failed (${event}): ${String(error)}`);
+		}
+	});
+	return watcher;
+}
+function watchServiceConfigFile(params) {
+	const configPath = resolve(params.configPath);
+	const watcher = chokidar.watch(configPath, {
+		ignoreInitial: true,
+		awaitWriteFinish: {
+			stabilityThreshold: 200,
+			pollInterval: 50
+		}
+	});
+	params.watcherRegistry.remember(watcher);
+	watcher.on("all", (event, changedPath) => {
+		if (resolve(changedPath) !== configPath) return;
+		if (event === "add") {
+			params.scheduleReload("config add");
+			return;
+		}
+		if (event === "change") {
+			params.scheduleReload("config change");
+			return;
+		}
+		if (event === "unlink") params.scheduleReload("config unlink");
+	});
+}
+var ServiceFileWatcherRegistry = class {
+	watchers = [];
+	remember = (watcher) => {
+		this.watchers.push(watcher);
+	};
+	clear = async () => {
+		const watchers = this.watchers.splice(0);
+		await Promise.allSettled(watchers.map(async (watcher) => {
+			try {
+				await watcher.close();
+			} catch {}
+		}));
+	};
+};
+function markLocalUiRuntimeIfStarted(params) {
+	const { uiConfig, uiStartup } = params;
+	if (uiStartup) localUiRuntimeStore.writeCurrentProcess(uiConfig);
+}
+async function startGatewayRuntimeSupport(params) {
+	const { automation, remoteModule, watchConfigFile, watcherRegistry } = params;
+	await startGatewaySupportServices({
+		automation,
+		remoteModule,
+		watchConfigFile
+	});
+	watcherRegistry.remember(watchCronStoreFile(automation));
+}
+//#endregion
+export { ServiceFileWatcherRegistry, logPluginGatewayDiagnostics, markLocalUiRuntimeIfStarted, pluginGatewayLogger, startGatewayRuntimeSupport, startGatewaySupportServices, watchCronStoreFile, watchServiceConfigFile };

package/dist/shared/services/gateway/utils/gateway-runtime-lifecycle.utils.d.ts

@@ -0,0 +1,9 @@
+import { ServiceBootstrapStatusStore } from "../service-bootstrap-status.js";
+
+//#region src/shared/services/gateway/utils/gateway-runtime-lifecycle.utils.d.ts
+declare function handleGatewayDeferredStartupError(params: {
+  bootstrapStatus: ServiceBootstrapStatusStore;
+  error: unknown;
+}): void;
+//#endregion
+export { handleGatewayDeferredStartupError };

package/dist/shared/services/gateway/utils/gateway-runtime-lifecycle.utils.js

@@ -0,0 +1,10 @@
+//#region src/shared/services/gateway/utils/gateway-runtime-lifecycle.utils.ts
+function handleGatewayDeferredStartupError(params) {
+	const { bootstrapStatus, error } = params;
+	const message = error instanceof Error ? error.message : String(error);
+	bootstrapStatus.markError(message);
+	if (bootstrapStatus.getStatus().pluginHydration.state === "running") bootstrapStatus.markPluginHydrationError(message);
+	console.error(`Deferred startup failed: ${message}`);
+}
+//#endregion
+export { handleGatewayDeferredStartupError };