@nextclaw/service 0.1.1

package/dist/shared/services/extensions/service-extension-runtime.service.js

@@ -0,0 +1,338 @@
+import { resolveDevFirstPartyPluginDir } from "../../../commands/plugin/development-source/first-party-plugin-load-paths.js";
+import { ExtensionLifecycleService, ExtensionManifestDiscoveryService } from "./extension-lifecycle.service.js";
+import { createRequire } from "node:module";
+import { fileURLToPath } from "node:url";
+import { dirname, join, resolve } from "node:path";
+import { getDataPath } from "@nextclaw/core";
+import { existsSync, readFileSync, readdirSync } from "node:fs";
+import { randomUUID } from "node:crypto";
+//#region src/shared/services/extensions/service-extension-runtime.service.ts
+const EXTENSION_CONFIG_GET_INGRESS_TYPE = "extension.channel.config.get";
+const EXTENSION_MESSAGE_SUBMIT_INGRESS_TYPE = "extension.channel.message.submit";
+const EXTENSION_REQUEST_EVENT_TYPE = "extension.request";
+const EXTENSION_RESPONSE_INGRESS_TYPE = "extension.response";
+const serviceRequire = createRequire(import.meta.url);
+const EXTENSION_REQUEST_TIMEOUT_MS = 6e4;
+var ExtensionChannelAuthClient = class {
+	constructor(params) {
+		this.params = params;
+	}
+	login = async ({ accountId, baseUrl, verbose }) => await this.params.request({
+		extensionId: this.params.extensionId,
+		kind: "channel.auth.login",
+		payload: {
+			channelId: this.params.channelId,
+			accountId,
+			baseUrl,
+			verbose
+		}
+	});
+	start = async ({ accountId, baseUrl }) => await this.params.request({
+		extensionId: this.params.extensionId,
+		kind: "channel.auth.start",
+		payload: {
+			channelId: this.params.channelId,
+			accountId,
+			baseUrl
+		}
+	});
+	poll = async ({ sessionId }) => await this.params.request({
+		extensionId: this.params.extensionId,
+		kind: "channel.auth.poll",
+		payload: {
+			channelId: this.params.channelId,
+			sessionId
+		}
+	});
+};
+function uniquePaths(paths) {
+	const seen = /* @__PURE__ */ new Set();
+	const unique = [];
+	for (const path of paths) {
+		const normalized = resolve(path);
+		if (seen.has(normalized)) continue;
+		seen.add(normalized);
+		unique.push(normalized);
+	}
+	return unique;
+}
+function findExtensionManifestRoot(startPath) {
+	let current = resolve(startPath);
+	while (true) {
+		if (existsSync(join(current, "nextclaw.extension.json"))) return current;
+		const parent = dirname(current);
+		if (parent === current) return;
+		current = parent;
+	}
+}
+function readBuiltinExtensionPackages() {
+	const packageJsonPath = resolve(dirname(fileURLToPath(import.meta.url)), "../../../..", "package.json");
+	try {
+		const packages = JSON.parse(readFileSync(packageJsonPath, "utf-8")).nextclaw?.builtinExtensions;
+		return Array.isArray(packages) ? packages.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [];
+	} catch {
+		return [];
+	}
+}
+function readPackageName(packageJsonPath) {
+	try {
+		const packageJson = JSON.parse(readFileSync(packageJsonPath, "utf-8"));
+		return typeof packageJson.name === "string" ? packageJson.name : void 0;
+	} catch {
+		return;
+	}
+}
+function readDirectoryNames(root) {
+	try {
+		return readdirSync(root, { withFileTypes: true }).filter((entry) => entry.isDirectory()).map((entry) => String(entry.name));
+	} catch {
+		return [];
+	}
+}
+function findWorkspacePackageRoot(packageName) {
+	const roots = [
+		resolve(process.cwd(), "packages", "extensions"),
+		resolve(process.cwd(), "packages"),
+		resolve(process.cwd(), "apps"),
+		resolve(process.cwd(), "workers")
+	];
+	for (const root of roots) for (const name of readDirectoryNames(root)) {
+		const candidateRoot = join(root, name);
+		if (readPackageName(join(candidateRoot, "package.json")) === packageName && existsSync(join(candidateRoot, "nextclaw.extension.json"))) return candidateRoot;
+	}
+}
+function resolveBuiltinExtensionManifestRoots() {
+	const roots = [];
+	for (const packageName of readBuiltinExtensionPackages()) {
+		try {
+			const root = findExtensionManifestRoot(dirname(serviceRequire.resolve(packageName)));
+			if (root) roots.push(root);
+		} catch {}
+		const workspaceRoot = findWorkspacePackageRoot(packageName);
+		if (workspaceRoot) roots.push(workspaceRoot);
+	}
+	return uniquePaths(roots);
+}
+function readRecord(value) {
+	return value && typeof value === "object" && !Array.isArray(value) ? value : {};
+}
+function readRequiredString(value, name) {
+	if (typeof value !== "string" || !value.trim()) throw new Error(`${name} is required`);
+	return value.trim();
+}
+function readTextContent(value) {
+	const content = readRecord(value);
+	if (content.type !== "text" || typeof content.text !== "string") throw new Error("only text channel messages are supported by the first ingress bridge");
+	return content.text;
+}
+function readOptionalString(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function readOptionalNumber(value) {
+	return typeof value === "number" && Number.isFinite(value) ? value : void 0;
+}
+function readInboundAttachments(value) {
+	if (!Array.isArray(value)) return [];
+	return value.filter((entry) => Boolean(entry && typeof entry === "object" && !Array.isArray(entry))).map((entry) => ({
+		...readOptionalString(entry.id) ? { id: readOptionalString(entry.id) } : {},
+		...readOptionalString(entry.name) ? { name: readOptionalString(entry.name) } : {},
+		...readOptionalString(entry.path) ? { path: readOptionalString(entry.path) } : {},
+		...readOptionalString(entry.url) ? { url: readOptionalString(entry.url) } : {},
+		...readOptionalString(entry.assetUri) ? { assetUri: readOptionalString(entry.assetUri) } : {},
+		...readOptionalString(entry.mimeType) ? { mimeType: readOptionalString(entry.mimeType) } : {},
+		...readOptionalNumber(entry.size) !== void 0 ? { size: readOptionalNumber(entry.size) } : {},
+		...readOptionalString(entry.source) ? { source: readOptionalString(entry.source) } : {},
+		...entry.status === "ready" || entry.status === "remote-only" ? { status: entry.status } : {},
+		...readOptionalString(entry.errorCode) ? { errorCode: readOptionalString(entry.errorCode) } : {}
+	}));
+}
+function toInboundMessage(payload) {
+	const metadata = readRecord(payload.metadata);
+	return {
+		channel: readRequiredString(payload.channelId, "channelId"),
+		chatId: readRequiredString(payload.conversationId, "conversationId"),
+		senderId: readRequiredString(payload.senderId, "senderId"),
+		content: readTextContent(payload.content),
+		timestamp: /* @__PURE__ */ new Date(),
+		attachments: readInboundAttachments(payload.attachments),
+		metadata
+	};
+}
+function resolveExtensionManifestRoots(params) {
+	const devExtensionsDir = resolveDevFirstPartyPluginDir(process.env.NEXTCLAW_DEV_FIRST_PARTY_PLUGIN_DIR);
+	return uniquePaths([
+		join(getDataPath(), "extensions"),
+		join(params.workspace, ".nextclaw", "extensions"),
+		...devExtensionsDir ? [devExtensionsDir] : [],
+		...resolveBuiltinExtensionManifestRoots(),
+		...params.config.plugins.load?.paths ?? []
+	]);
+}
+async function startDiscoveredExtensions(params) {
+	const { config, discovery: providedDiscovery, endpoint, lifecycle: providedLifecycle, token, workspace } = params;
+	const discovery = providedDiscovery ?? new ExtensionManifestDiscoveryService();
+	const lifecycle = providedLifecycle ?? new ExtensionLifecycleService({
+		endpoint,
+		token
+	});
+	const manifests = await discovery.discover(resolveExtensionManifestRoots({
+		config,
+		workspace
+	}));
+	return {
+		lifecycle,
+		running: await lifecycle.startAll(manifests)
+	};
+}
+var ServiceExtensionRuntime = class {
+	token = randomUUID();
+	lifecycle = null;
+	manifests = [];
+	pendingRequests = /* @__PURE__ */ new Map();
+	constructor(gateway) {
+		this.gateway = gateway;
+	}
+	registerIngressHandlers = (ingress) => {
+		ingress.addHandler(EXTENSION_CONFIG_GET_INGRESS_TYPE, this.handleChannelConfigGet);
+		ingress.addHandler(EXTENSION_MESSAGE_SUBMIT_INGRESS_TYPE, this.handleChannelMessageSubmit);
+		ingress.addHandler(EXTENSION_RESPONSE_INGRESS_TYPE, this.handleExtensionResponse);
+	};
+	loadContributions = async () => {
+		this.manifests = await this.discoverManifests();
+		return this.toContributions(this.manifests);
+	};
+	start = async () => {
+		const endpoint = this.gateway.uiStartup.endpoint || null;
+		if (!endpoint) return;
+		const lifecycle = this.lifecycle ?? new ExtensionLifecycleService({
+			endpoint,
+			token: this.token
+		});
+		const manifests = this.manifests.length > 0 ? this.manifests : await this.discoverManifests();
+		const running = await lifecycle.startAll(manifests);
+		this.lifecycle = lifecycle;
+		if (running.length > 0) console.log(`✓ Extensions started: ${running.map((entry) => entry.manifest.id).join(", ")}`);
+	};
+	stop = async () => {
+		await this.lifecycle?.stopAll();
+		this.lifecycle = null;
+		for (const [requestId, request] of this.pendingRequests) {
+			clearTimeout(request.timeout);
+			request.reject(/* @__PURE__ */ new Error(`Extension request cancelled: ${requestId}`));
+		}
+		this.pendingRequests.clear();
+	};
+	handleChannelConfigGet = (envelope, context) => {
+		this.assertAuthorized(context);
+		const channelId = readRequiredString(readRecord(envelope.payload).channelId, "channelId");
+		return { config: this.gateway.configManager.loadConfig().channels[channelId] ?? {} };
+	};
+	handleChannelMessageSubmit = async (envelope, context) => {
+		this.assertAuthorized(context);
+		await this.gateway.messageBus.publishInbound(toInboundMessage(readRecord(envelope.payload)));
+		return { accepted: true };
+	};
+	handleExtensionResponse = (envelope, context) => {
+		this.assertAuthorized(context);
+		const payload = readRecord(envelope.payload);
+		const requestId = readRequiredString(payload.requestId, "requestId");
+		const pending = this.pendingRequests.get(requestId);
+		if (!pending) return { accepted: false };
+		this.pendingRequests.delete(requestId);
+		clearTimeout(pending.timeout);
+		if (payload.ok === false) {
+			const error = readRecord(payload.error);
+			const message = typeof error.message === "string" && error.message.trim() ? error.message.trim() : "Extension request failed";
+			pending.reject(new Error(message));
+			return { accepted: true };
+		}
+		pending.resolve(payload.data);
+		return { accepted: true };
+	};
+	discoverManifests = async () => {
+		return await new ExtensionManifestDiscoveryService().discover(resolveExtensionManifestRoots({
+			config: this.gateway.configManager.loadConfig(),
+			workspace: this.gateway.workspace
+		}));
+	};
+	toContributions = (manifests) => {
+		const channelBindings = [];
+		const uiMetadata = [];
+		for (const manifest of manifests) {
+			const channels = manifest.contributes?.channels ?? [];
+			for (const channel of channels) {
+				const channelId = readOptionalString(channel.id);
+				if (!channelId) continue;
+				const configUiHints = this.readConfigUiHints(channel.configUiHints);
+				channelBindings.push({
+					pluginId: manifest.id,
+					channelId,
+					channel: {
+						id: channelId,
+						meta: {
+							label: channel.name ?? channelId,
+							selectionLabel: channel.name ?? channelId,
+							...channel.description ? { blurb: channel.description } : {},
+							...channel.meta ?? {}
+						},
+						...channel.configSchema ? { configSchema: {
+							schema: channel.configSchema,
+							...configUiHints ? { uiHints: configUiHints } : {}
+						} } : {},
+						...channel.auth ? { auth: this.createChannelAuth(manifest.id, channelId) } : {}
+					}
+				});
+				uiMetadata.push({
+					id: manifest.id,
+					configSchema: channel.configSchema,
+					...configUiHints ? { configUiHints } : {}
+				});
+			}
+		}
+		return {
+			channelBindings,
+			uiMetadata
+		};
+	};
+	readConfigUiHints = (value) => {
+		if (!value || typeof value !== "object" || Array.isArray(value)) return;
+		return value;
+	};
+	createChannelAuth = (extensionId, channelId) => new ExtensionChannelAuthClient({
+		extensionId,
+		channelId,
+		request: this.requestExtension
+	});
+	requestExtension = async (params) => {
+		const requestId = randomUUID();
+		const result = new Promise((resolvePromise, rejectPromise) => {
+			const timeout = setTimeout(() => {
+				this.pendingRequests.delete(requestId);
+				rejectPromise(/* @__PURE__ */ new Error(`Extension request timed out: ${params.kind}`));
+			}, EXTENSION_REQUEST_TIMEOUT_MS);
+			this.pendingRequests.set(requestId, {
+				resolve: (value) => resolvePromise(value),
+				reject: rejectPromise,
+				timeout
+			});
+		});
+		this.gateway.appEventBus.emitEnvelope({
+			type: EXTENSION_REQUEST_EVENT_TYPE,
+			payload: {
+				requestId,
+				extensionId: params.extensionId,
+				kind: params.kind,
+				payload: params.payload
+			},
+			emittedAt: (/* @__PURE__ */ new Date()).toISOString(),
+			source: "backend"
+		});
+		return await result;
+	};
+	assertAuthorized = (context) => {
+		if (context.token !== this.token) throw new Error("Unauthorized ingress token");
+	};
+};
+//#endregion
+export { ServiceExtensionRuntime, resolveBuiltinExtensionManifestRoots, resolveExtensionManifestRoots, startDiscoveredExtensions };

package/dist/shared/services/gateway/cron-job-handler.service.d.ts

@@ -0,0 +1,26 @@
+import { MessageBus } from "@nextclaw/core";
+import { NcpAgentRunApi } from "@nextclaw/ncp";
+
+//#region src/shared/services/gateway/cron-job-handler.service.d.ts
+type CronJobLike = {
+  id: string;
+  name: string;
+  payload: {
+    message: string;
+    agentId?: string | null;
+    sessionId?: string | null;
+    deliver?: boolean;
+    channel?: string | null;
+    to?: string | null;
+    accountId?: string | null;
+  };
+};
+type BackgroundNcpAgent = {
+  runApi: NcpAgentRunApi;
+};
+declare function createCronJobHandler(params: {
+  resolveNcpAgent: () => BackgroundNcpAgent | null;
+  bus: MessageBus;
+}): (job: CronJobLike) => Promise<string>;
+//#endregion
+export { createCronJobHandler };

package/dist/shared/services/gateway/cron-job-handler.service.js

@@ -0,0 +1,100 @@
+import { NcpEventType } from "@nextclaw/ncp";
+//#region src/shared/services/gateway/cron-job-handler.service.ts
+function normalizeOptionalString(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+function buildCronSessionMetadata(params) {
+	const { job, agentId, accountId } = params;
+	const channel = normalizeOptionalString(job.payload.channel) ?? "cli";
+	const chatId = normalizeOptionalString(job.payload.to) ?? "direct";
+	const metadata = {
+		agentId,
+		agent_id: agentId,
+		channel,
+		chatId,
+		chat_id: chatId,
+		label: job.name,
+		cron_job_id: job.id,
+		cron_job_name: job.name,
+		session_origin: "cron"
+	};
+	if (accountId) {
+		metadata.accountId = accountId;
+		metadata.account_id = accountId;
+	}
+	return metadata;
+}
+function buildCronUserMessage(params) {
+	const { sessionId, content, metadata } = params;
+	const timestamp = (/* @__PURE__ */ new Date()).toISOString();
+	return {
+		id: `${sessionId}:user:cron:${timestamp}`,
+		sessionId,
+		role: "user",
+		status: "final",
+		timestamp,
+		parts: [{
+			type: "text",
+			text: content
+		}],
+		metadata: structuredClone(metadata)
+	};
+}
+function extractMessageText(message) {
+	return message.parts.flatMap((part) => {
+		if (part.type === "text" || part.type === "rich-text") return [part.text];
+		return [];
+	}).map((text) => text.trim()).filter((text) => text.length > 0).join("\n\n");
+}
+async function runJobOverNcp(params) {
+	const { agent, sessionId, message, metadata, missingCompletedMessageError, runErrorMessage } = params;
+	let completedMessage;
+	for await (const event of agent.runApi.send({
+		sessionId,
+		message,
+		metadata
+	})) {
+		if (event.type === NcpEventType.MessageFailed) throw new Error(event.payload.error.message);
+		if (event.type === NcpEventType.RunError) throw new Error(event.payload.error ?? runErrorMessage);
+		if (event.type === NcpEventType.MessageCompleted) completedMessage = event.payload.message;
+	}
+	if (!completedMessage) throw new Error(missingCompletedMessageError);
+	return extractMessageText(completedMessage);
+}
+function createCronJobHandler(params) {
+	return async (job) => {
+		const ncpAgent = params.resolveNcpAgent();
+		if (!ncpAgent) throw new Error("NCP agent is not ready for cron execution.");
+		const accountId = normalizeOptionalString(job.payload.accountId);
+		const agentId = normalizeOptionalString(job.payload.agentId) ?? "main";
+		const sessionId = normalizeOptionalString(job.payload.sessionId) ?? `cron:${job.id}`;
+		const metadata = buildCronSessionMetadata({
+			job,
+			agentId,
+			accountId
+		});
+		const response = await runJobOverNcp({
+			agent: ncpAgent,
+			sessionId,
+			message: buildCronUserMessage({
+				sessionId,
+				content: job.payload.message,
+				metadata
+			}),
+			metadata,
+			missingCompletedMessageError: "cron job completed without a final assistant message",
+			runErrorMessage: "cron job failed"
+		});
+		if (job.payload.deliver && job.payload.to) await params.bus.publishOutbound({
+			channel: job.payload.channel ?? "cli",
+			chatId: job.payload.to,
+			content: response,
+			media: [],
+			metadata
+		});
+		return response;
+	};
+}
+//#endregion
+export { createCronJobHandler };

package/dist/shared/services/gateway/gateway-restart-wake.service.d.ts

@@ -0,0 +1,12 @@
+import { NextclawGatewayRuntime } from "./nextclaw-gateway-runtime.service.js";
+
+//#region src/shared/services/gateway/gateway-restart-wake.service.d.ts
+declare class GatewayRestartWakeService {
+  private readonly gateway;
+  constructor(gateway: NextclawGatewayRuntime);
+  wakeFromRestartSentinel: () => Promise<void>;
+  private resolveMostRecentRoutableSessionKey;
+  private buildRestartWakePrompt;
+}
+//#endregion
+export { GatewayRestartWakeService };

package/dist/shared/services/gateway/gateway-restart-wake.service.js

@@ -0,0 +1,91 @@
+import { consumeRestartSentinel, formatRestartSentinelMessage, parseSessionKey } from "../restart/restart-sentinel.service.js";
+import { resolveSessionRouteCandidate } from "../runtime/service-managed-startup.service.js";
+import { parseAgentScopedSessionKey } from "@nextclaw/core";
+//#region src/shared/services/gateway/gateway-restart-wake.service.ts
+function normalizeOptionalString(value) {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+}
+var GatewayRestartWakeService = class {
+	constructor(gateway) {
+		this.gateway = gateway;
+	}
+	wakeFromRestartSentinel = async () => {
+		const sentinel = await consumeRestartSentinel();
+		if (!sentinel) return;
+		await new Promise((resolvePromise) => setTimeout(resolvePromise, 750));
+		const payload = sentinel.payload;
+		const summary = formatRestartSentinelMessage(payload);
+		const sentinelSessionKey = normalizeOptionalString(payload.sessionKey);
+		const fallbackSessionKey = sentinelSessionKey ? void 0 : this.resolveMostRecentRoutableSessionKey();
+		if (!sentinelSessionKey && fallbackSessionKey) console.warn(`Warning: restart sentinel missing sessionKey; fallback to ${fallbackSessionKey}.`);
+		const sessionKey = sentinelSessionKey ?? fallbackSessionKey ?? "cli:default";
+		const parsedSession = parseSessionKey(sessionKey);
+		const parsedAgentSession = parseAgentScopedSessionKey(sessionKey);
+		const parsedSessionRoute = parsedSession && parsedSession.channel !== "agent" ? parsedSession : null;
+		const context = payload.deliveryContext;
+		const channel = normalizeOptionalString(context?.channel) ?? parsedSessionRoute?.channel ?? normalizeOptionalString((this.gateway.sessionManager.getIfExists(sessionKey)?.metadata ?? {}).last_channel);
+		const chatId = normalizeOptionalString(context?.chatId) ?? parsedSessionRoute?.chatId ?? normalizeOptionalString((this.gateway.sessionManager.getIfExists(sessionKey)?.metadata ?? {}).last_to);
+		const replyTo = normalizeOptionalString(context?.replyTo);
+		const accountId = normalizeOptionalString(context?.accountId);
+		if (!channel || !chatId) {
+			console.warn(`Warning: restart sentinel cannot resolve route for session ${sessionKey}.`);
+			return;
+		}
+		await this.gateway.messageBus.publishInbound({
+			channel: "system",
+			senderId: "restart-sentinel",
+			chatId: `${channel}:${chatId}`,
+			content: this.buildRestartWakePrompt({
+				summary,
+				reason: normalizeOptionalString(payload.stats?.reason),
+				note: normalizeOptionalString(payload.message),
+				...replyTo ? { replyTo } : {}
+			}),
+			timestamp: /* @__PURE__ */ new Date(),
+			attachments: [],
+			metadata: {
+				source: "restart-sentinel",
+				restart_summary: summary,
+				session_key_override: sessionKey,
+				...replyTo ? { reply_to: replyTo } : {},
+				...parsedAgentSession ? { target_agent_id: parsedAgentSession.agentId } : {},
+				...accountId ? {
+					account_id: accountId,
+					accountId
+				} : {}
+			}
+		});
+	};
+	resolveMostRecentRoutableSessionKey = () => {
+		let best = null;
+		for (const session of this.gateway.sessionManager.listSessions()) {
+			const candidate = resolveSessionRouteCandidate({
+				session,
+				normalizeOptionalString
+			});
+			if (!candidate) continue;
+			if (!best || candidate.updatedAt >= best.updatedAt) best = candidate;
+		}
+		return best?.key;
+	};
+	buildRestartWakePrompt = (params) => {
+		const { note, reason, replyTo, summary } = params;
+		const lines = [
+			"System event: the gateway has restarted successfully.",
+			"Please send one short confirmation to the user that you are back online.",
+			"Do not call any tools.",
+			"Use the same language as the user's recent conversation.",
+			`Reference summary: ${summary}`
+		];
+		const normalizedReason = normalizeOptionalString(reason);
+		if (normalizedReason) lines.push(`Restart reason: ${normalizedReason}`);
+		const normalizedNote = normalizeOptionalString(note);
+		if (normalizedNote) lines.push(`Extra note: ${normalizedNote}`);
+		const normalizedReplyTo = normalizeOptionalString(replyTo);
+		if (normalizedReplyTo) lines.push(`Reply target message id: ${normalizedReplyTo}. If suitable, include [[reply_to:${normalizedReplyTo}]].`);
+		return lines.join("\n");
+	};
+};
+//#endregion
+export { GatewayRestartWakeService };

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

@@ -0,0 +1,37 @@
+import { NextclawExtensionRegistry } from "../../../../commands/plugin/plugin-extension-registry.js";
+import { NextclawGatewayRuntime } from "../nextclaw-gateway-runtime.service.js";
+import { Config } from "@nextclaw/core";
+import { PluginChannelBinding, PluginRegistry, PluginUiMetadata } from "@nextclaw/openclaw-compat";
+
+//#region src/shared/services/gateway/managers/gateway-plugin.manager.d.ts
+declare class GatewayPluginManager {
+  private readonly gateway;
+  private extensionContributions;
+  private snapshot;
+  private gatewayHandles;
+  constructor(gateway: NextclawGatewayRuntime);
+  getRegistry: () => PluginRegistry;
+  getExtensionRegistry: () => NextclawExtensionRegistry;
+  getChannelBindings: () => PluginChannelBinding[];
+  getUiMetadata: () => PluginUiMetadata[];
+  load: () => Promise<void>;
+  reloadForConfigChange: (params: {
+    config: Config;
+    changedPaths: string[];
+  }) => Promise<{
+    restartChannels: boolean;
+  }>;
+  reloadForDevHotReload: (changedPaths: string[]) => Promise<void>;
+  startGateways: () => Promise<void>;
+  publishConfigChanges: () => void;
+  restartGateways: () => Promise<void>;
+  stopGateways: () => Promise<void>;
+  private startChannelGateways;
+  private resolveGatewayAccountIds;
+  private reportGatewayStartFailure;
+  private isChannelEnabled;
+  private replaceSnapshot;
+  private loadKernelExtensionContributions;
+}
+//#endregion
+export { GatewayPluginManager };