@nextclaw/service 0.1.1

package/dist/commands/plugin/development-source/first-party-plugin-load-paths.js

@@ -0,0 +1,183 @@
+import { fileURLToPath } from "node:url";
+import path from "node:path";
+import { getDataPath } from "@nextclaw/core";
+import fs from "node:fs";
+//#region src/commands/plugin/development-source/first-party-plugin-load-paths.ts
+const readJsonFile = (filePath) => {
+	try {
+		const raw = fs.readFileSync(filePath, "utf-8");
+		const parsed = JSON.parse(raw);
+		return parsed && typeof parsed === "object" && !Array.isArray(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+};
+const readString = (value) => {
+	if (typeof value !== "string") return;
+	return value.trim() || void 0;
+};
+const toPluginIdFromPackageName = (packageName) => {
+	const trimmed = packageName.trim();
+	if (!trimmed) return "";
+	return trimmed.includes("/") ? trimmed.split("/").pop() ?? trimmed : trimmed;
+};
+const normalizeInstallRecordPath = (value) => {
+	const filePath = readString(value);
+	return filePath ? path.resolve(filePath) : void 0;
+};
+const resolveDevFirstPartyPluginDir = (explicitDir, moduleDir = path.dirname(fileURLToPath(import.meta.url))) => {
+	const configured = explicitDir?.trim();
+	if (configured) return configured;
+	const inferred = path.resolve(moduleDir, "../../../../../extensions");
+	return fs.existsSync(inferred) ? inferred : void 0;
+};
+const hasOpenClawExtensions = (pkg) => {
+	const openclaw = pkg.openclaw;
+	if (!openclaw || typeof openclaw !== "object" || Array.isArray(openclaw)) return false;
+	const extensions = openclaw.extensions;
+	return Array.isArray(extensions) && extensions.some((entry) => typeof entry === "string" && entry.trim().length > 0);
+};
+const hasOpenClawDevelopmentExtensions = (pkg) => {
+	const openclaw = pkg.openclaw;
+	if (!openclaw || typeof openclaw !== "object" || Array.isArray(openclaw)) return false;
+	const development = openclaw.development;
+	if (!development || typeof development !== "object" || Array.isArray(development)) return false;
+	const extensions = development.extensions;
+	return Array.isArray(extensions) && extensions.some((entry) => typeof entry === "string" && entry.trim().length > 0);
+};
+const normalizePackageSpec = (spec) => {
+	const trimmed = spec.trim();
+	if (!trimmed) return;
+	if (trimmed.startsWith("@")) {
+		const slashIndex = trimmed.indexOf("/");
+		if (slashIndex < 0) return;
+		const secondAtIndex = trimmed.indexOf("@", slashIndex + 1);
+		return secondAtIndex < 0 ? trimmed : trimmed.slice(0, secondAtIndex);
+	}
+	const versionIndex = trimmed.indexOf("@");
+	return versionIndex < 0 ? trimmed : trimmed.slice(0, versionIndex);
+};
+const readWorkspacePluginPackages = (workspaceExtensionsDir) => {
+	if (!workspaceExtensionsDir.trim() || !fs.existsSync(workspaceExtensionsDir)) return [];
+	const entries = fs.readdirSync(workspaceExtensionsDir, { withFileTypes: true });
+	const packages = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const packageDir = path.join(workspaceExtensionsDir, entry.name);
+		const pkg = readJsonFile(path.join(packageDir, "package.json"));
+		if (!pkg || !hasOpenClawExtensions(pkg)) continue;
+		const packageName = readString(pkg.name);
+		if (!packageName?.startsWith("@nextclaw/")) continue;
+		packages.push({
+			pluginId: toPluginIdFromPackageName(packageName),
+			packageName,
+			dir: packageDir,
+			supportsDevelopmentSource: hasOpenClawDevelopmentExtensions(pkg)
+		});
+	}
+	return packages;
+};
+const readInstalledFirstPartyPluginMatches = (workspaceExtensionsDir) => {
+	const workspacePackages = readWorkspacePluginPackages(workspaceExtensionsDir);
+	if (workspacePackages.length === 0) return [];
+	const globalExtensionsDir = path.join(getDataPath(), "extensions");
+	if (!fs.existsSync(globalExtensionsDir)) return [];
+	const workspacePackageByName = new Map(workspacePackages.map((entry) => [entry.packageName, entry]));
+	const entries = fs.readdirSync(globalExtensionsDir, { withFileTypes: true });
+	const matches = [];
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		const packageDir = path.join(globalExtensionsDir, entry.name);
+		const packageName = readString(readJsonFile(path.join(packageDir, "package.json"))?.name);
+		if (!packageName) continue;
+		const workspacePackage = workspacePackageByName.get(packageName);
+		if (!workspacePackage) continue;
+		matches.push({
+			packageName,
+			workspaceDir: workspacePackage.dir,
+			installPath: packageDir
+		});
+	}
+	return matches;
+};
+const mergeLoadPaths = (existingLoadPaths, devLoadPaths) => {
+	const mergedLoadPaths = [...devLoadPaths];
+	for (const entry of existingLoadPaths) if (!mergedLoadPaths.includes(entry)) mergedLoadPaths.push(entry);
+	return mergedLoadPaths;
+};
+const findWorkspacePackageForInstallRecord = (installRecord, workspacePackages, packageByName) => {
+	const packageName = normalizePackageSpec(readString(installRecord.spec) ?? "");
+	if (packageName) {
+		const matchedByPackageName = packageByName.get(packageName);
+		if (matchedByPackageName) return matchedByPackageName;
+	}
+	const installPathCandidates = new Set([installRecord.sourcePath, installRecord.installPath].map(normalizeInstallRecordPath).filter((entry) => Boolean(entry)));
+	if (installPathCandidates.size === 0) return;
+	return workspacePackages.find((workspacePackage) => installPathCandidates.has(path.resolve(workspacePackage.dir)));
+};
+const resolveDevFirstPartyPluginLoadPaths = (config, workspaceExtensionsDir) => {
+	const rootDir = resolveDevFirstPartyPluginDir(workspaceExtensionsDir);
+	if (!rootDir) return [];
+	const workspacePackages = readWorkspacePluginPackages(rootDir);
+	if (workspacePackages.length === 0) return [];
+	const installedPluginMatches = readInstalledFirstPartyPluginMatches(rootDir);
+	const packageDirByName = new Map(workspacePackages.map((entry) => [entry.packageName, entry.dir]));
+	const packageByName = new Map(workspacePackages.map((entry) => [entry.packageName, entry]));
+	const loadPaths = [];
+	const installs = config.plugins.installs ?? {};
+	for (const installRecord of Object.values(installs)) {
+		const matchedWorkspacePackage = findWorkspacePackageForInstallRecord(installRecord, workspacePackages, packageByName);
+		const packageDir = matchedWorkspacePackage ? matchedWorkspacePackage.dir : packageDirByName.get(normalizePackageSpec(readString(installRecord.spec) ?? "") ?? "");
+		if (!packageDir || loadPaths.includes(packageDir)) continue;
+		loadPaths.push(packageDir);
+	}
+	for (const installedPlugin of installedPluginMatches) {
+		if (loadPaths.includes(installedPlugin.workspaceDir)) continue;
+		loadPaths.push(installedPlugin.workspaceDir);
+	}
+	return loadPaths;
+};
+const resolveDevFirstPartyPluginInstallRoots = (config, workspaceExtensionsDir) => {
+	const rootDir = resolveDevFirstPartyPluginDir(workspaceExtensionsDir);
+	if (!rootDir) return [];
+	const workspacePackages = readWorkspacePluginPackages(rootDir);
+	if (workspacePackages.length === 0) return [];
+	const packageNames = new Set(workspacePackages.map((entry) => entry.packageName));
+	const packageByName = new Map(workspacePackages.map((entry) => [entry.packageName, entry]));
+	const installRoots = [];
+	const installedPluginMatches = readInstalledFirstPartyPluginMatches(rootDir);
+	for (const installedPlugin of installedPluginMatches) {
+		if (installRoots.includes(installedPlugin.installPath)) continue;
+		installRoots.push(installedPlugin.installPath);
+	}
+	for (const installRecord of Object.values(config.plugins.installs ?? {})) {
+		const workspacePackage = findWorkspacePackageForInstallRecord(installRecord, workspacePackages, packageByName);
+		const packageName = normalizePackageSpec(readString(installRecord.spec) ?? "");
+		if (!workspacePackage && (!packageName || !packageNames.has(packageName))) continue;
+		const installPath = readString(installRecord.installPath);
+		if (!installPath || installRoots.includes(installPath)) continue;
+		if (workspacePackage && path.resolve(installPath) === path.resolve(workspacePackage.dir)) continue;
+		installRoots.push(installPath);
+	}
+	return installRoots;
+};
+const applyDevFirstPartyPluginLoadPaths = (config, workspaceExtensionsDir) => {
+	const rootDir = resolveDevFirstPartyPluginDir(workspaceExtensionsDir);
+	if (!rootDir) return config;
+	if (readWorkspacePluginPackages(rootDir).length === 0) return config;
+	const devLoadPaths = resolveDevFirstPartyPluginLoadPaths(config, rootDir);
+	if (devLoadPaths.length === 0) return config;
+	const mergedLoadPaths = mergeLoadPaths(Array.isArray(config.plugins.load?.paths) ? config.plugins.load.paths.filter((entry) => typeof entry === "string" && entry.trim().length > 0) : [], devLoadPaths);
+	return {
+		...config,
+		plugins: {
+			...config.plugins,
+			load: {
+				...config.plugins.load,
+				paths: mergedLoadPaths
+			}
+		}
+	};
+};
+//#endregion
+export { applyDevFirstPartyPluginLoadPaths, resolveDevFirstPartyPluginDir, resolveDevFirstPartyPluginInstallRoots, resolveDevFirstPartyPluginLoadPaths };

package/dist/commands/plugin/index.d.ts

@@ -0,0 +1,30 @@
+import { PluginsInfoOptions, PluginsInstallOptions, PluginsListOptions, PluginsUninstallOptions } from "../../shared/types/cli.types.js";
+import { NextclawExtensionRegistry, toExtensionRegistry } from "./plugin-extension-registry.js";
+import { createEmptyPluginRegistry } from "./plugin-registry-loader.js";
+import { Config } from "@nextclaw/core";
+import { PluginRegistry, mergePluginConfigView, toPluginConfigView } from "@nextclaw/openclaw-compat";
+
+//#region src/commands/plugin/index.d.ts
+declare function loadPluginRegistry(config: Config, workspaceDir: string): PluginRegistry;
+declare function logPluginDiagnostics(registry: PluginRegistry): void;
+declare class PluginCommands {
+  list: (opts?: PluginsListOptions) => void;
+  info: (id: string, opts?: PluginsInfoOptions) => void;
+  enable: (id: string) => Promise<void>;
+  disable: (id: string) => Promise<void>;
+  uninstall: (id: string, opts?: PluginsUninstallOptions) => Promise<void>;
+  install: (pathOrSpec: string, opts?: PluginsInstallOptions) => Promise<void>;
+  doctor: () => void;
+  private confirmYesNo;
+  private confirmUninstall;
+  private runUninstallMutation;
+  private loadStatusReport;
+  private buildPluginInfoLines;
+  private buildPluginSummaryLines;
+  private pushOptionalLine;
+  private assertPluginCanUninstall;
+  private buildUninstallPreview;
+  private buildUninstallConfigPreview;
+}
+//#endregion
+export { type NextclawExtensionRegistry, PluginCommands, createEmptyPluginRegistry, loadPluginRegistry, logPluginDiagnostics, mergePluginConfigView, toExtensionRegistry, toPluginConfigView };

package/dist/commands/plugin/index.js

@@ -0,0 +1,266 @@
+import { appendPluginCapabilityLines, buildReservedPluginLoadOptions } from "./plugin-command-utils.js";
+import { disablePluginMutation, enablePluginMutation, installPluginMutation, uninstallPluginMutation } from "./plugin-mutation-actions.js";
+import { resolveDevFirstPartyPluginDir } from "./development-source/first-party-plugin-load-paths.js";
+import { resolveDevPluginLoadingContext } from "./development-source/dev-plugin-overrides.utils.js";
+import { toExtensionRegistry } from "./plugin-extension-registry.js";
+import { createEmptyPluginRegistry } from "./plugin-registry-loader.js";
+import { resolve } from "node:path";
+import { getWorkspacePath, loadConfig } from "@nextclaw/core";
+import { createInterface } from "node:readline";
+import { buildPluginStatusReport, loadOpenClawPlugins, mergePluginConfigView, resolveUninstallDirectoryTargets, toPluginConfigView } from "@nextclaw/openclaw-compat";
+//#region src/commands/plugin/index.ts
+function loadPluginRegistry(config, workspaceDir) {
+	const { configWithDevPluginOverrides, excludedRoots } = resolveDevPluginLoadingContext(config, resolveDevFirstPartyPluginDir(process.env.NEXTCLAW_DEV_FIRST_PARTY_PLUGIN_DIR));
+	return loadOpenClawPlugins({
+		config: configWithDevPluginOverrides,
+		workspaceDir,
+		excludeRoots: excludedRoots,
+		...buildReservedPluginLoadOptions(),
+		logger: {
+			info: (message) => console.log(message),
+			warn: (message) => console.warn(message),
+			error: (message) => console.error(message),
+			debug: (message) => console.debug(message)
+		}
+	});
+}
+function logPluginDiagnostics(registry) {
+	for (const diag of registry.diagnostics) {
+		const text = `${diag.pluginId ? `${diag.pluginId}: ` : ""}${diag.message}`;
+		if (diag.level === "error") console.error(`[plugins] ${text}`);
+		else console.warn(`[plugins] ${text}`);
+	}
+}
+var PluginCommands = class {
+	list = (opts = {}) => {
+		const { report, workspaceDir } = this.loadStatusReport();
+		const list = opts.enabled ? report.plugins.filter((plugin) => plugin.status === "loaded") : report.plugins;
+		if (opts.json) {
+			console.log(JSON.stringify({
+				workspaceDir,
+				plugins: list,
+				diagnostics: report.diagnostics
+			}, null, 2));
+			return;
+		}
+		if (list.length === 0) {
+			console.log("No plugins discovered.");
+			return;
+		}
+		for (const plugin of list) {
+			const status = plugin.status === "loaded" ? "loaded" : plugin.status === "disabled" ? "disabled" : "error";
+			const title = plugin.name && plugin.name !== plugin.id ? `${plugin.name} (${plugin.id})` : plugin.id;
+			if (!opts.verbose) {
+				const desc = plugin.description ? plugin.description.length > 80 ? `${plugin.description.slice(0, 77)}...` : plugin.description : "(no description)";
+				console.log(`${title} ${status} - ${desc}`);
+				continue;
+			}
+			console.log(`${title} ${status}`);
+			console.log(`  source: ${plugin.source}`);
+			console.log(`  origin: ${plugin.origin}`);
+			if (plugin.version) console.log(`  version: ${plugin.version}`);
+			const capabilityLines = [];
+			appendPluginCapabilityLines(capabilityLines, plugin);
+			for (const line of capabilityLines) console.log(`  ${line.toLowerCase()}`);
+			if (plugin.error) console.log(`  error: ${plugin.error}`);
+			console.log("");
+		}
+	};
+	info = (id, opts = {}) => {
+		const { config, report } = this.loadStatusReport();
+		const plugin = report.plugins.find((entry) => entry.id === id || entry.name === id);
+		if (!plugin) {
+			console.error(`Plugin not found: ${id}`);
+			process.exit(1);
+		}
+		if (opts.json) {
+			console.log(JSON.stringify(plugin, null, 2));
+			return;
+		}
+		console.log(this.buildPluginInfoLines(plugin, config).join("\n"));
+	};
+	enable = async (id) => {
+		try {
+			const result = await enablePluginMutation(id);
+			console.log(result.message);
+		} catch (error) {
+			console.error(error instanceof Error ? error.message : String(error));
+			process.exit(1);
+		}
+		console.log("If gateway is running, plugin changes are hot-applied automatically.");
+	};
+	disable = async (id) => {
+		try {
+			const result = await disablePluginMutation(id);
+			console.log(result.message);
+		} catch (error) {
+			console.error(error instanceof Error ? error.message : String(error));
+			process.exit(1);
+		}
+		console.log("If gateway is running, plugin changes are hot-applied automatically.");
+	};
+	uninstall = async (id, opts = {}) => {
+		if (opts.keepConfig) console.log("`--keep-config` is deprecated, use `--keep-files`.");
+		const { config, report } = this.loadStatusReport();
+		const keepFiles = Boolean(opts.keepFiles || opts.keepConfig);
+		const plugin = report.plugins.find((entry) => entry.id === id || entry.name === id);
+		const pluginId = plugin?.id ?? id;
+		const hasEntry = pluginId in (config.plugins.entries ?? {});
+		const hasInstall = pluginId in (config.plugins.installs ?? {});
+		this.assertPluginCanUninstall(id, pluginId, plugin, hasEntry, hasInstall);
+		const install = config.plugins.installs?.[pluginId];
+		const preview = this.buildUninstallPreview({
+			config,
+			hasEntry,
+			hasInstall,
+			install,
+			keepFiles,
+			pluginId
+		});
+		const pluginName = plugin?.name || pluginId;
+		const pluginTitle = pluginName !== pluginId ? `${pluginName} (${pluginId})` : pluginName;
+		console.log(`Plugin: ${pluginTitle}`);
+		console.log(`Will remove: ${preview.length > 0 ? preview.join(", ") : "(nothing)"}`);
+		if (opts.dryRun) {
+			console.log("Dry run, no changes made.");
+			return;
+		}
+		if (!await this.confirmUninstall(pluginId, opts)) return;
+		await this.runUninstallMutation(id, opts);
+		console.log("If gateway is running, plugin changes are hot-applied automatically.");
+	};
+	install = async (pathOrSpec, opts = {}) => {
+		try {
+			const result = await installPluginMutation(pathOrSpec, opts);
+			console.log(result.message);
+		} catch (error) {
+			console.error(error instanceof Error ? error.message : String(error));
+			process.exit(1);
+		}
+		console.log("If gateway is running, plugin changes are hot-applied automatically.");
+	};
+	doctor = () => {
+		const { report } = this.loadStatusReport();
+		const pluginErrors = report.plugins.filter((plugin) => plugin.status === "error");
+		const diagnostics = report.diagnostics.filter((diag) => diag.level === "error");
+		if (pluginErrors.length === 0 && diagnostics.length === 0) {
+			console.log("No plugin issues detected.");
+			return;
+		}
+		if (pluginErrors.length > 0) {
+			console.log("Plugin errors:");
+			for (const entry of pluginErrors) console.log(`- ${entry.id}: ${entry.error ?? "failed to load"} (${entry.source})`);
+		}
+		if (diagnostics.length > 0) {
+			if (pluginErrors.length > 0) console.log("");
+			console.log("Diagnostics:");
+			for (const diag of diagnostics) {
+				const prefix = diag.pluginId ? `${diag.pluginId}: ` : "";
+				console.log(`- ${prefix}${diag.message}`);
+			}
+		}
+	};
+	confirmYesNo = async (question) => {
+		const rl = createInterface({
+			input: process.stdin,
+			output: process.stdout
+		});
+		const answer = await new Promise((resolve) => {
+			rl.question(`${question} [y/N] `, (line) => resolve(line));
+		});
+		rl.close();
+		const normalized = answer.trim().toLowerCase();
+		return normalized === "y" || normalized === "yes";
+	};
+	confirmUninstall = async (pluginId, opts) => {
+		if (opts.force) return true;
+		const confirmed = await this.confirmYesNo(`Uninstall plugin "${pluginId}"?`);
+		if (!confirmed) console.log("Cancelled.");
+		return confirmed;
+	};
+	runUninstallMutation = async (id, opts) => {
+		try {
+			const result = await uninstallPluginMutation(id, opts);
+			for (const warning of result.warnings) console.warn(warning);
+			console.log(result.message);
+		} catch (error) {
+			console.error(error instanceof Error ? error.message : String(error));
+			process.exit(1);
+		}
+	};
+	loadStatusReport = () => {
+		const config = loadConfig();
+		const workspaceDir = getWorkspacePath(config.agents.defaults.workspace);
+		return {
+			config,
+			workspaceDir,
+			report: buildPluginStatusReport({
+				config,
+				workspaceDir,
+				...buildReservedPluginLoadOptions()
+			})
+		};
+	};
+	buildPluginInfoLines = (plugin, config) => {
+		const install = config.plugins.installs?.[plugin.id];
+		const lines = this.buildPluginSummaryLines(plugin);
+		if (install) {
+			lines.push("");
+			lines.push(`Install: ${install.source}`);
+			this.pushOptionalLine(lines, "Spec", install.spec);
+			this.pushOptionalLine(lines, "Source path", install.sourcePath);
+			this.pushOptionalLine(lines, "Install path", install.installPath);
+			this.pushOptionalLine(lines, "Recorded version", install.version);
+			this.pushOptionalLine(lines, "Installed at", install.installedAt);
+		}
+		return lines;
+	};
+	buildPluginSummaryLines = (plugin) => {
+		const lines = [plugin.name || plugin.id];
+		if (plugin.name && plugin.name !== plugin.id) lines.push(`id: ${plugin.id}`);
+		if (plugin.description) lines.push(plugin.description);
+		lines.push("", `Status: ${plugin.status}`, `Source: ${plugin.source}`, `Origin: ${plugin.origin}`);
+		this.pushOptionalLine(lines, "Version", plugin.version);
+		appendPluginCapabilityLines(lines, plugin);
+		this.pushOptionalLine(lines, "Error", plugin.error);
+		return lines;
+	};
+	pushOptionalLine = (lines, label, value) => {
+		if (value) lines.push(`${label}: ${value}`);
+	};
+	assertPluginCanUninstall = (requestedId, pluginId, plugin, hasEntry, hasInstall) => {
+		if (hasEntry || hasInstall) return;
+		if (plugin) console.error(`Plugin "${pluginId}" is not managed by plugins config/install records and cannot be uninstalled.`);
+		else console.error(`Plugin not found: ${requestedId}`);
+		process.exit(1);
+	};
+	buildUninstallPreview = (params) => {
+		const { config, hasEntry, hasInstall, install, keepFiles, pluginId } = params;
+		const preview = this.buildUninstallConfigPreview({
+			config,
+			hasEntry,
+			hasInstall,
+			install,
+			pluginId
+		});
+		if (!keepFiles) for (const deleteTarget of resolveUninstallDirectoryTargets({
+			config,
+			pluginId,
+			hasInstall,
+			installRecord: install
+		})) preview.push(`directory: ${deleteTarget}`);
+		return preview;
+	};
+	buildUninstallConfigPreview = (params) => {
+		const { config, hasEntry, hasInstall, install, pluginId } = params;
+		const preview = [];
+		const isLinked = install?.source === "path" && (!install.installPath || !install.sourcePath || resolve(install.installPath) === resolve(install.sourcePath));
+		if (hasEntry) preview.push("config entry");
+		if (hasInstall) preview.push("install record");
+		if (config.plugins.allow?.includes(pluginId)) preview.push("allowlist entry");
+		if (isLinked && install?.sourcePath && config.plugins.load?.paths?.includes(install.sourcePath)) preview.push("load path");
+		return preview;
+	};
+};
+//#endregion
+export { PluginCommands, createEmptyPluginRegistry, loadPluginRegistry, logPluginDiagnostics, mergePluginConfigView, toExtensionRegistry, toPluginConfigView };

package/dist/commands/plugin/plugin-command-utils.d.ts

@@ -0,0 +1,13 @@
+import { PluginRegistry } from "@nextclaw/openclaw-compat";
+
+//#region src/commands/plugin/plugin-command-utils.d.ts
+declare const RESERVED_PROVIDER_IDS: string[];
+declare function buildReservedPluginLoadOptions(): {
+  reservedToolNames: ("cron" | "read_file" | "write_file" | "edit_file" | "list_dir" | "exec" | "web_search" | "web_fetch" | "message" | "spawn" | "sessions_list" | "sessions_history" | "memory_search" | "memory_get" | "subagents" | "gateway")[];
+  reservedChannelIds: string[];
+  reservedProviderIds: string[];
+  reservedNcpAgentRuntimeKinds: string[];
+};
+declare function appendPluginCapabilityLines(lines: string[], plugin: PluginRegistry["plugins"][number]): void;
+//#endregion
+export { RESERVED_PROVIDER_IDS, appendPluginCapabilityLines, buildReservedPluginLoadOptions };

package/dist/commands/plugin/plugin-command-utils.js

@@ -0,0 +1,37 @@
+import { builtinProviderIds } from "@nextclaw/runtime";
+//#region src/commands/plugin/plugin-command-utils.ts
+const RESERVED_PROVIDER_IDS = builtinProviderIds();
+const RESERVED_TOOL_NAMES = [
+	"read_file",
+	"write_file",
+	"edit_file",
+	"list_dir",
+	"exec",
+	"web_search",
+	"web_fetch",
+	"message",
+	"spawn",
+	"sessions_list",
+	"sessions_history",
+	"memory_search",
+	"memory_get",
+	"subagents",
+	"gateway",
+	"cron"
+];
+function buildReservedPluginLoadOptions() {
+	return {
+		reservedToolNames: [...RESERVED_TOOL_NAMES],
+		reservedChannelIds: [],
+		reservedProviderIds: RESERVED_PROVIDER_IDS,
+		reservedNcpAgentRuntimeKinds: ["native"]
+	};
+}
+function appendPluginCapabilityLines(lines, plugin) {
+	if (plugin.toolNames.length > 0) lines.push(`Tools: ${plugin.toolNames.join(", ")}`);
+	if (plugin.channelIds.length > 0) lines.push(`Channels: ${plugin.channelIds.join(", ")}`);
+	if (plugin.providerIds.length > 0) lines.push(`Providers: ${plugin.providerIds.join(", ")}`);
+	if (plugin.ncpAgentRuntimeKinds.length > 0) lines.push(`NCP runtimes: ${plugin.ncpAgentRuntimeKinds.join(", ")}`);
+}
+//#endregion
+export { RESERVED_PROVIDER_IDS, appendPluginCapabilityLines, buildReservedPluginLoadOptions };

package/dist/commands/plugin/plugin-extension-registry.d.ts

@@ -0,0 +1,10 @@
+import { ExtensionRegistry } from "@nextclaw/core";
+import { PluginNcpAgentRuntimeRegistration, PluginRegistry } from "@nextclaw/openclaw-compat";
+
+//#region src/commands/plugin/plugin-extension-registry.d.ts
+type NextclawExtensionRegistry = ExtensionRegistry & {
+  ncpAgentRuntimes: PluginNcpAgentRuntimeRegistration[];
+};
+declare function toExtensionRegistry(pluginRegistry: PluginRegistry): NextclawExtensionRegistry;
+//#endregion
+export { NextclawExtensionRegistry, toExtensionRegistry };

package/dist/commands/plugin/plugin-extension-registry.js

@@ -0,0 +1,35 @@
+//#region src/commands/plugin/plugin-extension-registry.ts
+function toExtensionRegistry(pluginRegistry) {
+	return {
+		tools: pluginRegistry.tools.map((tool) => ({
+			extensionId: tool.pluginId,
+			factory: tool.factory,
+			names: tool.names,
+			optional: tool.optional,
+			source: tool.source
+		})),
+		channels: pluginRegistry.channels.map((channel) => ({
+			extensionId: channel.pluginId,
+			channel: channel.channel,
+			source: channel.source
+		})),
+		ncpAgentRuntimes: pluginRegistry.ncpAgentRuntimes.map((runtime) => ({
+			pluginId: runtime.pluginId,
+			kind: runtime.kind,
+			label: runtime.label,
+			createRuntime: runtime.createRuntime,
+			createRuntimeForEntry: runtime.createRuntimeForEntry,
+			describeSessionType: runtime.describeSessionType,
+			describeSessionTypeForEntry: runtime.describeSessionTypeForEntry,
+			source: runtime.source
+		})),
+		diagnostics: pluginRegistry.diagnostics.map((diag) => ({
+			level: diag.level,
+			message: diag.message,
+			extensionId: diag.pluginId,
+			source: diag.source
+		}))
+	};
+}
+//#endregion
+export { toExtensionRegistry };

package/dist/commands/plugin/plugin-mutation-actions.d.ts

@@ -0,0 +1,15 @@
+import { PluginsInstallOptions, PluginsUninstallOptions } from "../../shared/types/cli.types.js";
+
+//#region src/commands/plugin/plugin-mutation-actions.d.ts
+type PluginMutationResult = {
+  message: string;
+};
+type PluginUninstallMutationResult = PluginMutationResult & {
+  warnings: string[];
+};
+declare function enablePluginMutation(id: string): Promise<PluginMutationResult>;
+declare function disablePluginMutation(id: string): Promise<PluginMutationResult>;
+declare function uninstallPluginMutation(id: string, opts?: PluginsUninstallOptions): Promise<PluginUninstallMutationResult>;
+declare function installPluginMutation(pathOrSpec: string, opts?: PluginsInstallOptions): Promise<PluginMutationResult>;
+//#endregion
+export { PluginMutationResult, PluginUninstallMutationResult, disablePluginMutation, enablePluginMutation, installPluginMutation, uninstallPluginMutation };