@nextclaw/service 0.1.1

package/dist/shared/services/gateway/managers/gateway-plugin.manager.js

@@ -0,0 +1,218 @@
+import { toExtensionRegistry } from "../../../../commands/plugin/plugin-extension-registry.js";
+import { createEmptyPluginRegistry, discoverPluginRegistryStatus, loadPluginRegistryProgressively } from "../../../../commands/plugin/plugin-registry-loader.js";
+import { logPluginDiagnostics } from "../../../../commands/plugin/index.js";
+import { shouldRestartChannelsForPluginReload } from "../../../../commands/plugin/plugin-reload.js";
+import { logPluginGatewayDiagnostics, pluginGatewayLogger } from "../service-startup-support.service.js";
+import { getWorkspacePath } from "@nextclaw/core";
+import { eventKeys } from "@nextclaw/shared";
+import { getPluginChannelBindings, getPluginUiMetadataFromRegistry, toPluginConfigView } from "@nextclaw/openclaw-compat";
+//#region src/shared/services/gateway/managers/gateway-plugin.manager.ts
+function buildSnapshot(registry, extensionContributions) {
+	const extensionChannelIds = new Set(extensionContributions.channelBindings.map((binding) => binding.channelId));
+	const extensionPluginIds = new Set(extensionContributions.uiMetadata.map((metadata) => metadata.id));
+	return {
+		registry,
+		extensionRegistry: toExtensionRegistry(registry),
+		channelBindings: [...getPluginChannelBindings(registry).filter((binding) => !extensionChannelIds.has(binding.channelId)), ...extensionContributions.channelBindings],
+		uiMetadata: [...getPluginUiMetadataFromRegistry(registry).filter((metadata) => !extensionPluginIds.has(metadata.id)), ...extensionContributions.uiMetadata]
+	};
+}
+function countEnabledPlugins(config, workspaceDir) {
+	return discoverPluginRegistryStatus(config, workspaceDir).plugins.filter((plugin) => plugin.enabled).length;
+}
+var GatewayPluginManager = class {
+	extensionContributions = {
+		channelBindings: [],
+		uiMetadata: []
+	};
+	snapshot = buildSnapshot(createEmptyPluginRegistry(), this.extensionContributions);
+	gatewayHandles = [];
+	constructor(gateway) {
+		this.gateway = gateway;
+	}
+	getRegistry = () => this.snapshot.registry;
+	getExtensionRegistry = () => this.snapshot.extensionRegistry;
+	getChannelBindings = () => this.snapshot.channelBindings;
+	getUiMetadata = () => this.snapshot.uiMetadata;
+	load = async () => {
+		const config = this.gateway.configManager.loadConfig();
+		const workspace = getWorkspacePath(config.agents.defaults.workspace);
+		const totalPluginCount = countEnabledPlugins(config, workspace);
+		let loadedPluginCount = 0;
+		this.gateway.bootstrapStatus.markPluginHydrationRunning({ totalPluginCount });
+		this.gateway.bootstrapStatus.markChannelsPending();
+		try {
+			const registry = await loadPluginRegistryProgressively(config, workspace, { onPluginProcessed: ({ loadedPluginCount: nextCount }) => {
+				loadedPluginCount = nextCount;
+				this.gateway.bootstrapStatus.markPluginHydrationProgress({
+					loadedPluginCount: nextCount,
+					totalPluginCount
+				});
+			} });
+			this.extensionContributions = await this.gateway.extensions.loadContributions();
+			const shouldRebuildChannels = this.replaceSnapshot(registry, []);
+			this.loadKernelExtensionContributions(registry);
+			logPluginDiagnostics(registry);
+			if (shouldRebuildChannels) await this.gateway.configManager.rebuildChannels(config, { start: false });
+			this.publishConfigChanges();
+			this.gateway.bootstrapStatus.markPluginHydrationReady({
+				loadedPluginCount: loadedPluginCount || totalPluginCount,
+				totalPluginCount
+			});
+		} catch (error) {
+			this.gateway.bootstrapStatus.markPluginHydrationError(error instanceof Error ? error.message : String(error));
+			throw error;
+		}
+	};
+	reloadForConfigChange = async (params) => {
+		const workspace = getWorkspacePath(params.config.agents.defaults.workspace);
+		const registry = await loadPluginRegistryProgressively(params.config, workspace);
+		this.extensionContributions = await this.gateway.extensions.loadContributions();
+		const restartChannels = this.replaceSnapshot(registry, params.changedPaths);
+		this.loadKernelExtensionContributions(registry);
+		logPluginDiagnostics(registry);
+		if (restartChannels) await this.restartGateways();
+		this.publishConfigChanges();
+		return { restartChannels };
+	};
+	reloadForDevHotReload = async (changedPaths) => {
+		const config = this.gateway.configManager.loadConfig();
+		if ((await this.reloadForConfigChange({
+			config,
+			changedPaths
+		})).restartChannels) await this.gateway.configManager.rebuildChannels(config, { start: true });
+	};
+	startGateways = async () => {
+		const config = this.gateway.configManager.loadConfig();
+		const diagnostics = [];
+		const handles = [];
+		const configView = toPluginConfigView(config, this.snapshot.channelBindings);
+		for (const binding of this.snapshot.channelBindings) {
+			if (!this.isChannelEnabled(binding.channelId, configView)) continue;
+			await this.startChannelGateways({
+				binding,
+				configView,
+				diagnostics,
+				handles
+			});
+		}
+		this.gatewayHandles = handles;
+		logPluginGatewayDiagnostics(diagnostics);
+	};
+	publishConfigChanges = () => {
+		this.gateway.appEventBus.emit(eventKeys.configUpdated, { path: "channels" }, {
+			emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			source: "backend"
+		});
+		this.gateway.appEventBus.emit(eventKeys.configUpdated, { path: "plugins" }, {
+			emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			source: "backend"
+		});
+	};
+	restartGateways = async () => {
+		await this.stopGateways();
+		await this.startGateways();
+	};
+	stopGateways = async () => {
+		for (const handle of this.gatewayHandles) try {
+			handle.abort?.();
+			await handle.stop?.();
+		} catch {}
+		this.gatewayHandles = [];
+	};
+	startChannelGateways = async (params) => {
+		const { binding, configView, diagnostics, handles } = params;
+		const gateway = binding.channel.gateway;
+		if (!gateway?.startAccount) return;
+		const accountIds = this.resolveGatewayAccountIds(binding, configView);
+		for (const accountId of accountIds) {
+			const abortController = new AbortController();
+			let stopGateway;
+			const startTask = Promise.resolve().then(async () => await gateway.startAccount?.({
+				accountId,
+				channelId: binding.channelId,
+				cfg: configView,
+				abortSignal: abortController.signal,
+				runtime: {
+					log: pluginGatewayLogger.info,
+					info: pluginGatewayLogger.info,
+					warn: pluginGatewayLogger.warn,
+					error: pluginGatewayLogger.error,
+					debug: pluginGatewayLogger.debug
+				},
+				setStatus: () => void 0,
+				log: pluginGatewayLogger
+			})).then((started) => {
+				if (started && typeof started === "object" && "stop" in started && typeof started.stop === "function") stopGateway = started.stop.bind(started);
+			}).catch((error) => {
+				if (abortController.signal.aborted) return;
+				this.reportGatewayStartFailure({
+					accountId,
+					binding,
+					diagnostics,
+					error
+				});
+			});
+			handles.push({
+				pluginId: binding.pluginId,
+				channelId: binding.channelId,
+				accountId,
+				abort: () => abortController.abort(),
+				stop: async () => {
+					abortController.abort();
+					await startTask;
+					await stopGateway?.();
+				}
+			});
+		}
+	};
+	resolveGatewayAccountIds = (binding, configView) => {
+		const accountIdsRaw = binding.channel.config?.listAccountIds?.(configView) ?? [binding.channel.config?.defaultAccountId?.(configView) ?? "default"];
+		const accountIds = Array.from(new Set(accountIdsRaw.map((id) => typeof id === "string" ? id.trim() : "").filter(Boolean)));
+		return accountIds.length > 0 ? accountIds : ["default"];
+	};
+	reportGatewayStartFailure = (params) => {
+		const { accountId, binding, diagnostics, error } = params;
+		const raw = String(error);
+		const lower = raw.toLowerCase();
+		const level = lower.includes("required") || lower.includes("not configured") || lower.includes("missing") ? "warn" : "error";
+		const message = `failed to start channel gateway for ${binding.channelId}/${accountId}: ${raw}`;
+		diagnostics.push({
+			level,
+			pluginId: binding.pluginId,
+			message
+		});
+		if (level === "error") {
+			pluginGatewayLogger.error(message);
+			return;
+		}
+		pluginGatewayLogger.warn(message);
+	};
+	isChannelEnabled = (channelId, configView) => {
+		const channelConfig = (configView.channels && typeof configView.channels === "object" && !Array.isArray(configView.channels) ? configView.channels : {})[channelId];
+		if (!channelConfig || typeof channelConfig !== "object" || Array.isArray(channelConfig)) return false;
+		return channelConfig.enabled === true;
+	};
+	replaceSnapshot = (registry, changedPaths) => {
+		const nextSnapshot = buildSnapshot(registry, this.extensionContributions);
+		const shouldRestartChannels = shouldRestartChannelsForPluginReload({
+			changedPaths,
+			currentPluginChannelBindings: this.snapshot.channelBindings,
+			nextPluginChannelBindings: nextSnapshot.channelBindings,
+			currentExtensionChannels: this.snapshot.extensionRegistry.channels,
+			nextExtensionChannels: nextSnapshot.extensionRegistry.channels
+		});
+		this.snapshot = nextSnapshot;
+		return shouldRestartChannels;
+	};
+	loadKernelExtensionContributions = (registry) => {
+		this.gateway.kernel.extensions.loadContributions({
+			registry,
+			extensionRegistry: this.snapshot.extensionRegistry,
+			channelBindings: this.snapshot.channelBindings,
+			uiMetadata: this.snapshot.uiMetadata
+		});
+	};
+};
+//#endregion
+export { GatewayPluginManager };

package/dist/shared/services/gateway/managers/gateway-remote.manager.d.ts

@@ -0,0 +1,20 @@
+import { createManagedRemoteModuleForUi } from "../../runtime/service-remote-runtime.service.js";
+import { GatewayRuntimeDeps } from "../nextclaw-gateway-runtime.service.js";
+import { Config } from "@nextclaw/core";
+import { UiRemoteAccessHost } from "@nextclaw/server";
+import { ConfigManager } from "@nextclaw/kernel";
+
+//#region src/shared/services/gateway/managers/gateway-remote.manager.d.ts
+type RemoteServiceModule = ReturnType<typeof createManagedRemoteModuleForUi>;
+declare class GatewayRemoteManager {
+  readonly remoteModule: RemoteServiceModule;
+  readonly remoteAccess: UiRemoteAccessHost;
+  constructor(params: {
+    deps: GatewayRuntimeDeps;
+    configManager: ConfigManager;
+    uiConfig: Config["ui"];
+  });
+  stop: () => Promise<void>;
+}
+//#endregion
+export { GatewayRemoteManager };

package/dist/shared/services/gateway/managers/gateway-remote.manager.js

@@ -0,0 +1,25 @@
+import { createRemoteAccessHost } from "../../ui/service-remote-access.service.js";
+import { createManagedRemoteModuleForUi } from "../../runtime/service-remote-runtime.service.js";
+//#region src/shared/services/gateway/managers/gateway-remote.manager.ts
+var GatewayRemoteManager = class {
+	remoteModule;
+	remoteAccess;
+	constructor(params) {
+		const { configManager, deps, uiConfig } = params;
+		this.remoteModule = createManagedRemoteModuleForUi({
+			loadConfig: configManager.loadConfig,
+			uiConfig
+		});
+		this.remoteAccess = createRemoteAccessHost({
+			serviceCommands: deps,
+			requestRestart: deps.requestRestart,
+			uiConfig,
+			remoteModule: this.remoteModule
+		});
+	}
+	stop = async () => {
+		await this.remoteModule?.stop();
+	};
+};
+//#endregion
+export { GatewayRemoteManager };

package/dist/shared/services/gateway/nextclaw-app.service.d.ts

@@ -0,0 +1,22 @@
+import { DeferredUiNcpAgentController } from "../session/service-deferred-ncp-agent.service.js";
+import { NextclawGatewayRuntime } from "./nextclaw-gateway-runtime.service.js";
+import { NextclawKernel } from "@nextclaw/kernel";
+
+//#region src/shared/services/gateway/nextclaw-app.service.d.ts
+type UiStartupHandle = {
+  deferredNcpAgent: DeferredUiNcpAgentController;
+  endpoint: string;
+};
+type NextclawAppKernel = Pick<NextclawKernel, "agentRuntimeManager" | "start">;
+declare class NextclawApp {
+  private readonly gateway;
+  private readonly kernel;
+  private kernelReady;
+  constructor(gateway: NextclawGatewayRuntime, kernel?: NextclawAppKernel);
+  start: () => Promise<void>;
+  bootstrapKernel: () => Promise<void>;
+  warmDerivedCapabilities: () => Promise<void>;
+  private readonly handleKernelStartupError;
+}
+//#endregion
+export { NextclawApp, UiStartupHandle };

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

@@ -0,0 +1,53 @@
+import { logStartupTrace, measureStartupAsync } from "../../utils/startup-trace.js";
+//#region src/shared/services/gateway/nextclaw-app.service.ts
+var NextclawApp = class {
+	kernel;
+	kernelReady = false;
+	constructor(gateway, kernel) {
+		this.gateway = gateway;
+		this.kernel = kernel ?? gateway.kernel;
+	}
+	start = async () => {
+		logStartupTrace("service.deferred_startup.begin");
+		try {
+			await this.bootstrapKernel();
+		} catch (error) {
+			this.handleKernelStartupError(error);
+		}
+		await this.warmDerivedCapabilities();
+		console.log("✓ Deferred startup: plugin gateways and channels settled");
+		logStartupTrace("service.deferred_startup.end");
+	};
+	bootstrapKernel = async () => {
+		this.gateway.bootstrapStatus.markNcpAgentRunning();
+		await measureStartupAsync("service.deferred_startup.bootstrap_kernel", async () => await this.kernel.start());
+		const ncpAgent = this.kernel.agentRuntimeManager.currentHandle;
+		if (!ncpAgent) throw new Error("Kernel start completed without an agent runtime handle.");
+		this.gateway.activateAgentRuntime(ncpAgent);
+		this.kernelReady = true;
+		if (this.gateway.uiConfig.enabled) {
+			console.log("✓ UI NCP agent: ready");
+			return;
+		}
+		console.log("✓ Service NCP agent: ready");
+	};
+	warmDerivedCapabilities = async () => {
+		await measureStartupAsync("service.deferred_startup.load_plugins", this.gateway.plugins.load);
+		await measureStartupAsync("service.deferred_startup.start_plugin_gateways", this.gateway.plugins.startGateways);
+		await measureStartupAsync("service.deferred_startup.start_extensions", this.gateway.extensions.start);
+		await measureStartupAsync("service.deferred_startup.start_channels", this.gateway.startDeferredChannels);
+		await measureStartupAsync("service.deferred_startup.wake_restart_sentinel", this.gateway.restartWake.wakeFromRestartSentinel);
+		if (!this.kernelReady) return;
+		setTimeout(() => {
+			measureStartupAsync("service.deferred_startup.warm_ncp_capabilities", async () => await this.kernel.agentRuntimeManager.warmDerivedCapabilities()).catch((error) => {
+				console.warn(`UI NCP derived capability warmup failed: ${error instanceof Error ? error.message : String(error)}`);
+			});
+		}, 0).unref?.();
+	};
+	handleKernelStartupError = (error) => {
+		this.gateway.bootstrapStatus.markNcpAgentError(error instanceof Error ? error.message : String(error));
+		console.error(`UI NCP agent startup failed: ${error instanceof Error ? error.message : String(error)}`);
+	};
+};
+//#endregion
+export { NextclawApp };

package/dist/shared/services/gateway/nextclaw-gateway-runtime.service.d.ts

@@ -0,0 +1,89 @@
+import { RequestRestartParams } from "../../types/cli.types.js";
+import { GatewayControllerImpl } from "../../controllers/gateway.controller.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 { UiStartupHandle } from "./nextclaw-app.service.js";
+import { ServiceBootstrapStatusStore } from "./service-bootstrap-status.js";
+import { ServiceFileWatcherRegistry } from "./service-startup-support.service.js";
+import { ServiceExtensionRuntime } from "../extensions/service-extension-runtime.service.js";
+import * as NextclawCore from "@nextclaw/core";
+import { MarketplaceApiConfig, UiNcpAgent, UiRuntimeControlHost, UiRuntimeUpdateHost } from "@nextclaw/server";
+import { EventBus, Ingress } from "@nextclaw/shared";
+import { AgentRuntimeHandle, AutomationManager, ConfigManager, LlmProviderManager, NextclawKernel } from "@nextclaw/kernel";
+
+//#region src/shared/services/gateway/nextclaw-gateway-runtime.service.d.ts
+type Config$1 = NextclawCore.Config;
+type MessageBus$1 = NextclawCore.MessageBus;
+type SessionManager$1 = NextclawCore.SessionManager;
+type GatewayRuntimeOptions = {
+  uiOverrides?: Partial<Config$1["ui"]>;
+  uiStaticDir?: string | null;
+};
+type GatewayRuntimeDeps = {
+  requestRestart: (params: RequestRestartParams) => Promise<void>;
+  initializeAgentHomeDirectory: (homeDirectory: string) => void;
+  startService: (options: {
+    uiOverrides: Record<string, unknown>;
+    open: boolean;
+  }) => Promise<void>;
+  stopService: () => Promise<void>;
+  runCliSubcommand: (args: string[]) => Promise<string>;
+  installBuiltinMarketplaceSkill: (slug: string, force: boolean | undefined) => {
+    message: string;
+    output?: string;
+  } | null;
+};
+declare class NextclawGatewayRuntime {
+  private readonly deps;
+  private readonly options;
+  readonly kernel: NextclawKernel;
+  readonly appEventBus: EventBus;
+  readonly messageBus: MessageBus$1;
+  readonly sessionManager: SessionManager$1;
+  readonly automation: AutomationManager;
+  readonly runtimeControl: UiRuntimeControlHost;
+  readonly runtimeUpdate: UiRuntimeUpdateHost | null;
+  readonly ingress: Ingress;
+  readonly productVersion: string;
+  readonly providerManager: LlmProviderManager;
+  readonly gatewayController: GatewayControllerImpl;
+  readonly configManager: ConfigManager;
+  readonly uiConfig: Config$1["ui"];
+  readonly uiStaticDir: string | null;
+  readonly workspace: string;
+  readonly remoteManager: GatewayRemoteManager;
+  readonly marketplace: MarketplaceApiConfig;
+  readonly plugins: GatewayPluginManager;
+  readonly restartWake: GatewayRestartWakeService;
+  bootstrapStatus: ServiceBootstrapStatusStore;
+  uiStartup: UiStartupHandle;
+  readonly extensions: ServiceExtensionRuntime;
+  liveAgentRuntime: AgentRuntimeHandle | null;
+  readonly fileWatchers: ServiceFileWatcherRegistry;
+  private deferredChannelStarter;
+  constructor(deps: GatewayRuntimeDeps, options?: GatewayRuntimeOptions);
+  start: () => Promise<void>;
+  private reset;
+  get ncpAgent(): UiNcpAgent;
+  activateAgentRuntime: (ncpAgent: AgentRuntimeHandle) => void;
+  private createBootstrapStatus;
+  private createDisabledUiStartup;
+  private startUiRuntime;
+  private createUiRouterOptions;
+  private runRuntimeLoop;
+  private startDeferredRuntime;
+  readonly startDeferredChannels: () => Promise<void>;
+  private installChannelDevHotReload;
+  private readonly startChannels;
+  private createMarketplace;
+  private cleanup;
+  private markUiRuntimeReady;
+  private createGatewayController;
+  private startSupportServices;
+  private configurePluginRuntime;
+  private installConfigRuntimeHooks;
+  private configureIngressHandlers;
+}
+//#endregion
+export { GatewayRuntimeDeps, NextclawGatewayRuntime };