@nextclaw/service 0.1.1

package/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2026 NextClaw contributors
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/dist/cli/commands/agent/agent-runtime.utils.d.ts

@@ -0,0 +1,15 @@
+import { AgentRuntimeSessionTypeDescribeParams, AgentRuntimeSessionTypeOption } from "@nextclaw/kernel";
+
+//#region src/cli/commands/agent/agent-runtime.utils.d.ts
+type AgentRuntimeListEntry = AgentRuntimeSessionTypeOption & {
+  default: boolean;
+  source: "builtin" | "plugin";
+  pluginId?: string;
+};
+type AgentRuntimeListResult = {
+  defaultRuntime: string;
+  runtimes: AgentRuntimeListEntry[];
+};
+declare function listAvailableAgentRuntimes(params?: AgentRuntimeSessionTypeDescribeParams): Promise<AgentRuntimeListResult>;
+//#endregion
+export { AgentRuntimeListEntry, AgentRuntimeListResult, listAvailableAgentRuntimes };

package/dist/cli/commands/agent/agent-runtime.utils.js

@@ -0,0 +1,85 @@
+import { buildReservedPluginLoadOptions } from "../../../commands/plugin/plugin-command-utils.js";
+import { resolveDevFirstPartyPluginDir } from "../../../commands/plugin/development-source/first-party-plugin-load-paths.js";
+import { resolveDevPluginLoadingContext } from "../../../commands/plugin/development-source/dev-plugin-overrides.utils.js";
+import { toExtensionRegistry } from "../../../commands/plugin/plugin-extension-registry.js";
+import { logPluginDiagnostics } from "../../../commands/plugin/index.js";
+import { getWorkspacePath, loadConfig } from "@nextclaw/core";
+import { loadOpenClawPlugins } from "@nextclaw/openclaw-compat";
+import { AgentRuntimeRegistry, BuiltinNarpRuntimeRegistrationService, DEFAULT_AGENT_RUNTIME_ENTRY_ID, NARP_HTTP_RUNTIME_KIND, NARP_STDIO_RUNTIME_KIND, resolveAgentRuntimeEntries } from "@nextclaw/kernel";
+//#region src/cli/commands/agent/agent-runtime.utils.ts
+function createUnusedRuntime(_params) {
+	throw new Error("runtime creation is not available during runtime listing");
+}
+function loadRuntimeOnlyPluginRegistry(config, workspaceDir) {
+	const { configWithDevPluginOverrides, excludedRoots } = resolveDevPluginLoadingContext(config, resolveDevFirstPartyPluginDir(process.env.NEXTCLAW_DEV_FIRST_PARTY_PLUGIN_DIR));
+	return loadOpenClawPlugins({
+		config: configWithDevPluginOverrides,
+		workspaceDir,
+		includeBundled: false,
+		kinds: ["agent-runtime"],
+		excludeRoots: excludedRoots,
+		...buildReservedPluginLoadOptions(),
+		logger: {
+			info: (message) => console.log(message),
+			warn: (message) => console.warn(message),
+			error: (message) => console.error(message),
+			debug: (message) => console.debug(message)
+		}
+	});
+}
+async function listAvailableAgentRuntimes(params) {
+	const config = loadConfig();
+	const pluginRegistry = loadRuntimeOnlyPluginRegistry(config, getWorkspacePath(config.agents.defaults.workspace));
+	logPluginDiagnostics(pluginRegistry);
+	const extensionRegistry = toExtensionRegistry(pluginRegistry);
+	const runtimeRegistry = new AgentRuntimeRegistry();
+	const runtimeSourceByKind = /* @__PURE__ */ new Map();
+	const runtimeSourceByEntryId = /* @__PURE__ */ new Map();
+	runtimeRegistry.register({
+		kind: DEFAULT_AGENT_RUNTIME_ENTRY_ID,
+		label: "Native",
+		createRuntime: createUnusedRuntime
+	});
+	runtimeSourceByKind.set(DEFAULT_AGENT_RUNTIME_ENTRY_ID, { source: "builtin" });
+	new BuiltinNarpRuntimeRegistrationService(() => config).registerInto(runtimeRegistry);
+	runtimeSourceByKind.set("narp-http", { source: "builtin" });
+	runtimeSourceByKind.set("narp-stdio", { source: "builtin" });
+	for (const registration of extensionRegistry.ncpAgentRuntimes) {
+		const normalizedKind = registration.kind.trim().toLowerCase();
+		if (normalizedKind === NARP_HTTP_RUNTIME_KIND || normalizedKind === NARP_STDIO_RUNTIME_KIND) continue;
+		runtimeRegistry.register({
+			kind: registration.kind,
+			label: registration.label,
+			createRuntime: registration.createRuntime,
+			describeSessionType: registration.describeSessionType
+		});
+		runtimeSourceByKind.set(registration.kind, {
+			source: "plugin",
+			pluginId: registration.pluginId
+		});
+	}
+	const resolvedEntries = resolveAgentRuntimeEntries({
+		config,
+		providerKinds: runtimeRegistry.listProviderKinds()
+	});
+	runtimeRegistry.applyEntries(resolvedEntries);
+	for (const entry of resolvedEntries.entries) {
+		const source = runtimeSourceByKind.get(entry.type);
+		runtimeSourceByEntryId.set(entry.id, source ?? { source: entry.id === DEFAULT_AGENT_RUNTIME_ENTRY_ID ? "builtin" : "plugin" });
+	}
+	const listed = await runtimeRegistry.listSessionTypes(params);
+	return {
+		defaultRuntime: listed.defaultType,
+		runtimes: listed.options.map((runtime) => {
+			const source = runtimeSourceByEntryId.get(runtime.value);
+			return {
+				...runtime,
+				default: runtime.value === listed.defaultType,
+				source: source?.source ?? "plugin",
+				...source?.pluginId ? { pluginId: source.pluginId } : {}
+			};
+		})
+	};
+}
+//#endregion
+export { listAvailableAgentRuntimes };

package/dist/cli/commands/agent/cli-agent-runner.utils.d.ts

@@ -0,0 +1,21 @@
+import { AgentCommandOptions } from "../../../shared/types/cli.types.js";
+import { NextclawExtensionRegistry } from "../../../commands/plugin/plugin-extension-registry.js";
+import { Config } from "@nextclaw/core";
+import { LlmProviderRuntime, NextclawKernel } from "@nextclaw/kernel";
+
+//#region src/cli/commands/agent/cli-agent-runner.utils.d.ts
+declare function runCliAgentCommand(params: {
+  logo: string;
+  opts: AgentCommandOptions;
+  config: Config;
+  kernel: NextclawKernel;
+  providerManager: LlmProviderRuntime;
+  extensionRegistry: NextclawExtensionRegistry;
+  loadResolvedConfig: () => Config;
+  resolveMessageToolHints: (params: {
+    channel: string;
+    accountId?: string | null;
+  }) => string[];
+}): Promise<void>;
+//#endregion
+export { runCliAgentCommand };

package/dist/cli/commands/agent/cli-agent-runner.utils.js

@@ -0,0 +1,89 @@
+import { printAgentResponse, prompt } from "../../../shared/utils/cli.utils.js";
+import { join, resolve } from "node:path";
+import { getDataDir } from "@nextclaw/core";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { createInterface } from "node:readline";
+import { dispatchPromptOverNcp } from "@nextclaw/kernel";
+//#region src/cli/commands/agent/cli-agent-runner.utils.ts
+const EXIT_COMMANDS = new Set([
+	"exit",
+	"quit",
+	"/exit",
+	"/quit",
+	":q"
+]);
+function buildCliSharedMetadata(opts) {
+	return typeof opts.model === "string" && opts.model.trim() ? { model: opts.model.trim() } : {};
+}
+function createCliHistoryInterface() {
+	const historyFile = join(getDataDir(), "history", "cli_history");
+	mkdirSync(resolve(historyFile, ".."), { recursive: true });
+	const history = existsSync(historyFile) ? readFileSync(historyFile, "utf-8").split("\n").filter(Boolean) : [];
+	const rl = createInterface({
+		input: process.stdin,
+		output: process.stdout
+	});
+	rl.on("close", () => {
+		writeFileSync(historyFile, history.concat(rl.history ?? []).join("\n"));
+		process.exit(0);
+	});
+	return rl;
+}
+async function runCliInteractiveLoop(params) {
+	const { config, logo, metadata, ncpAgent, sessionKey, sessionManager } = params;
+	console.log(`${logo} Interactive mode (type exit or Ctrl+C to quit)\n`);
+	const rl = createCliHistoryInterface();
+	let running = true;
+	while (running) {
+		const trimmed = (await prompt(rl, "You: ")).trim();
+		if (!trimmed) continue;
+		if (EXIT_COMMANDS.has(trimmed.toLowerCase())) {
+			rl.close();
+			running = false;
+			break;
+		}
+		printAgentResponse(await dispatchPromptOverNcp({
+			config,
+			sessionManager,
+			resolveNcpAgent: () => ncpAgent,
+			sessionKey,
+			content: trimmed,
+			metadata
+		}));
+	}
+}
+async function runCliAgentCommand(params) {
+	const { config, extensionRegistry, kernel, logo, opts } = params;
+	const sessionManager = kernel.sessions;
+	kernel.extensions.loadExtensionRegistry(extensionRegistry);
+	await kernel.start();
+	const ncpAgent = kernel.agentRuntimeManager.currentHandle;
+	if (!ncpAgent) throw new Error("Kernel start completed without an agent runtime handle.");
+	try {
+		const sessionKey = opts.session ?? "cli:default";
+		const sharedMetadata = buildCliSharedMetadata(opts);
+		if (opts.message) {
+			printAgentResponse(await dispatchPromptOverNcp({
+				config,
+				sessionManager,
+				resolveNcpAgent: () => ncpAgent,
+				sessionKey,
+				content: opts.message,
+				metadata: sharedMetadata
+			}));
+			return;
+		}
+		await runCliInteractiveLoop({
+			logo,
+			config,
+			sessionManager,
+			ncpAgent,
+			sessionKey,
+			metadata: sharedMetadata
+		});
+	} finally {
+		await ncpAgent.dispose?.();
+	}
+}
+//#endregion
+export { runCliAgentCommand };

package/dist/cli/commands/agent/index.d.ts

@@ -0,0 +1,3 @@
+import { runCliAgentCommand } from "./cli-agent-runner.utils.js";
+import { AgentCommands } from "./services/agent-commands.service.js";
+export { AgentCommands, runCliAgentCommand };

package/dist/cli/commands/agent/index.js

@@ -0,0 +1,3 @@
+import { runCliAgentCommand } from "./cli-agent-runner.utils.js";
+import { AgentCommands } from "./services/agent-commands.service.js";
+export { AgentCommands, runCliAgentCommand };

package/dist/cli/commands/agent/services/agent-commands.service.d.ts

@@ -0,0 +1,17 @@
+import { AgentsListCommandOptions, AgentsNewCommandOptions, AgentsRemoveCommandOptions, AgentsRuntimesCommandOptions, AgentsUpdateCommandOptions } from "../../../../shared/types/cli.types.js";
+
+//#region src/cli/commands/agent/services/agent-commands.service.d.ts
+declare class AgentCommands {
+  private readonly deps;
+  constructor(deps: {
+    initializeAgentHomeDirectory: (homeDirectory: string) => void;
+  });
+  list: (opts?: AgentsListCommandOptions) => void;
+  runtimes: (opts?: AgentsRuntimesCommandOptions) => Promise<void>;
+  create: (agentId: string, opts?: AgentsNewCommandOptions) => Promise<void>;
+  update: (agentId: string, opts?: AgentsUpdateCommandOptions) => Promise<void>;
+  remove: (agentId: string, opts?: AgentsRemoveCommandOptions) => Promise<void>;
+  private toAgentListEntry;
+}
+//#endregion
+export { AgentCommands };

package/dist/cli/commands/agent/services/agent-commands.service.js

@@ -0,0 +1,112 @@
+import { listAvailableAgentRuntimes } from "../agent-runtime.utils.js";
+import { BUILTIN_MAIN_AGENT_ID, createAgentProfile, loadConfig, removeAgentProfile, resolveEffectiveAgentProfiles, updateAgentProfile } from "@nextclaw/core";
+//#region src/cli/commands/agent/services/agent-commands.service.ts
+var AgentCommands = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	list = (opts = {}) => {
+		const agents = resolveEffectiveAgentProfiles(loadConfig()).map((agent) => this.toAgentListEntry(agent));
+		if (opts.json) {
+			console.log(JSON.stringify(agents, null, 2));
+			return;
+		}
+		for (const agent of agents) {
+			const head = agent.builtIn ? `${agent.id} (built-in)` : agent.id;
+			console.log(head);
+			console.log(`  name: ${agent.displayName ?? "-"}`);
+			console.log(`  description: ${agent.description ?? "-"}`);
+			console.log(`  home: ${agent.workspace}`);
+			console.log(`  avatar: ${agent.avatar ?? "-"}`);
+			console.log(`  runtime: ${agent.runtime ?? "-"}`);
+		}
+	};
+	runtimes = async (opts = {}) => {
+		const describeMode = opts.probe ? "probe" : "observation";
+		const listed = await listAvailableAgentRuntimes({ describeMode });
+		if (opts.json) {
+			console.log(JSON.stringify({
+				defaultRuntime: listed.defaultRuntime,
+				describeMode,
+				runtimes: listed.runtimes
+			}, null, 2));
+			return;
+		}
+		for (const runtime of listed.runtimes) {
+			const head = runtime.default ? `${runtime.value} (default)` : runtime.value;
+			console.log(head);
+			console.log(`  label: ${runtime.label}`);
+			console.log(`  source: ${runtime.source}`);
+			if (runtime.pluginId) console.log(`  pluginId: ${runtime.pluginId}`);
+			console.log(`  ready: ${runtime.ready === false ? "no" : "yes"}`);
+			console.log(`  reason: ${runtime.reason ?? "-"}`);
+			console.log(`  reasonMessage: ${runtime.reasonMessage ?? "-"}`);
+			console.log(`  recommendedModel: ${runtime.recommendedModel ?? "-"}`);
+			console.log(`  supportedModels: ${runtime.supportedModels?.join(", ") ?? "-"}`);
+		}
+	};
+	create = async (agentId, opts = {}) => {
+		const created = createAgentProfile({
+			id: agentId,
+			displayName: opts.name,
+			description: opts.description,
+			avatar: opts.avatar,
+			home: opts.home,
+			runtime: opts.runtime
+		}, { initializeHomeDirectory: this.deps.initializeAgentHomeDirectory });
+		if (opts.json) {
+			console.log(JSON.stringify({ agent: created }, null, 2));
+			return;
+		}
+		console.log(`✓ Created agent ${created.id}`);
+		console.log(`  name: ${created.displayName ?? "-"}`);
+		console.log(`  description: ${created.description ?? "-"}`);
+		console.log(`  home: ${created.workspace}`);
+		console.log(`  avatar: ${created.avatar ?? "-"}`);
+		console.log(`  runtime: ${created.runtime ?? created.engine ?? "-"}`);
+	};
+	update = async (agentId, opts = {}) => {
+		const updated = updateAgentProfile({
+			id: agentId,
+			displayName: opts.name,
+			description: opts.description,
+			avatar: opts.avatar,
+			runtime: opts.runtime
+		});
+		if (opts.json) {
+			console.log(JSON.stringify({ agent: updated }, null, 2));
+			return;
+		}
+		console.log(`✓ Updated agent ${updated.id}`);
+		console.log(`  name: ${updated.displayName ?? "-"}`);
+		console.log(`  description: ${updated.description ?? "-"}`);
+		console.log(`  home: ${updated.workspace}`);
+		console.log(`  avatar: ${updated.avatar ?? "-"}`);
+		console.log(`  runtime: ${updated.runtime ?? updated.engine ?? "-"}`);
+	};
+	remove = async (agentId, opts = {}) => {
+		if (agentId.trim().toLowerCase() === BUILTIN_MAIN_AGENT_ID) throw new Error(`agent id '${BUILTIN_MAIN_AGENT_ID}' is reserved`);
+		if (!removeAgentProfile(agentId)) throw new Error(`agent '${agentId}' not found`);
+		if (opts.json) {
+			console.log(JSON.stringify({
+				removed: true,
+				agentId
+			}, null, 2));
+			return;
+		}
+		console.log(`✓ Removed agent ${agentId}`);
+	};
+	toAgentListEntry = (agent) => {
+		return {
+			id: agent.id,
+			displayName: agent.displayName ?? null,
+			description: agent.description ?? null,
+			avatar: agent.avatar ?? null,
+			workspace: agent.workspace,
+			runtime: agent.runtime ?? agent.engine ?? null,
+			builtIn: agent.builtIn === true
+		};
+	};
+};
+//#endregion
+export { AgentCommands };

package/dist/cli/commands/companion/index.d.ts

@@ -0,0 +1,15 @@
+import { CompanionDisableCommandOptions, CompanionEnableCommandOptions, CompanionStartCommandOptions, CompanionStatusCommandOptions, CompanionStopCommandOptions } from "../../../shared/types/cli.types.js";
+import { CompanionProcessService } from "./services/companion-process.service.js";
+
+//#region src/cli/commands/companion/index.d.ts
+declare class CompanionCommands {
+  private readonly companionProcessService;
+  constructor(companionProcessService?: CompanionProcessService);
+  readonly start: (options?: CompanionStartCommandOptions) => Promise<void>;
+  readonly enable: (options?: CompanionEnableCommandOptions) => Promise<void>;
+  readonly disable: (options?: CompanionDisableCommandOptions) => Promise<void>;
+  readonly status: (options?: CompanionStatusCommandOptions) => Promise<void>;
+  readonly stop: (options?: CompanionStopCommandOptions) => Promise<void>;
+}
+//#endregion
+export { CompanionCommands };

package/dist/cli/commands/companion/index.js

@@ -0,0 +1,24 @@
+import { CompanionProcessService } from "./services/companion-process.service.js";
+//#region src/cli/commands/companion/index.ts
+var CompanionCommands = class {
+	constructor(companionProcessService = new CompanionProcessService()) {
+		this.companionProcessService = companionProcessService;
+	}
+	start = async (options = {}) => {
+		await this.companionProcessService.start(options);
+	};
+	enable = async (options = {}) => {
+		await this.companionProcessService.enable(options);
+	};
+	disable = async (options = {}) => {
+		await this.companionProcessService.disable(options);
+	};
+	status = async (options = {}) => {
+		await this.companionProcessService.status(options);
+	};
+	stop = async (options = {}) => {
+		await this.companionProcessService.stop(options);
+	};
+};
+//#endregion
+export { CompanionCommands };

package/dist/cli/commands/companion/services/companion-process.service.d.ts

@@ -0,0 +1,17 @@
+import { CompanionDisableCommandOptions, CompanionEnableCommandOptions, CompanionStartCommandOptions, CompanionStatusCommandOptions, CompanionStopCommandOptions } from "../../../../shared/types/cli.types.js";
+import { CompanionRuntimeService } from "../../../../shared/services/ui/companion-runtime.service.js";
+
+//#region src/cli/commands/companion/services/companion-process.service.d.ts
+declare class CompanionProcessService {
+  private readonly runtimeService;
+  constructor(runtimeService?: CompanionRuntimeService);
+  readonly start: (options?: CompanionStartCommandOptions) => Promise<void>;
+  readonly status: (options?: CompanionStatusCommandOptions) => Promise<void>;
+  readonly stop: (options?: CompanionStopCommandOptions) => Promise<void>;
+  readonly enable: (options?: CompanionEnableCommandOptions) => Promise<void>;
+  readonly disable: (_options?: CompanionDisableCommandOptions) => Promise<void>;
+  private readonly resolveBaseUrl;
+  private readonly printConfigEnabled;
+}
+//#endregion
+export { CompanionProcessService };

package/dist/cli/commands/companion/services/companion-process.service.js

@@ -0,0 +1,49 @@
+import { companionRuntimeService } from "../../../../shared/services/ui/companion-runtime.service.js";
+import "@nextclaw/core";
+//#region src/cli/commands/companion/services/companion-process.service.ts
+var CompanionProcessService = class {
+	constructor(runtimeService = companionRuntimeService) {
+		this.runtimeService = runtimeService;
+	}
+	start = async (options = {}) => {
+		const state = await this.runtimeService.ensureStarted({ baseUrl: this.resolveBaseUrl(options) });
+		this.runtimeService.printStarted(state);
+	};
+	status = async (options = {}) => {
+		this.runtimeService.printStatus(options);
+	};
+	stop = async (options = {}) => {
+		const stopped = await this.runtimeService.ensureStopped(options);
+		this.runtimeService.printStopped(stopped);
+	};
+	enable = async (options = {}) => {
+		const nextConfig = await this.runtimeService.updateEnabled(true, options);
+		this.printConfigEnabled(nextConfig, options.baseUrl);
+	};
+	disable = async (_options = {}) => {
+		const nextConfig = await this.runtimeService.updateEnabled(false);
+		console.log(nextConfig.companion.enabled ? "Companion remains enabled." : "Companion feature disabled. It will stay off until you enable it again.");
+	};
+	resolveBaseUrl = (options) => {
+		const explicitBaseUrl = options.baseUrl?.trim();
+		if (explicitBaseUrl) return explicitBaseUrl.replace(/\/+$/, "");
+		const discoveredBaseUrl = this.runtimeService.resolveDiscoveredBaseUrl();
+		if (discoveredBaseUrl) return discoveredBaseUrl;
+		const runningState = this.runtimeService.getRunningState();
+		if (runningState) return runningState.baseUrl;
+		throw new Error("Cannot resolve NextClaw UI base URL. Start NextClaw first or pass --base-url.");
+	};
+	printConfigEnabled = (config, baseUrl) => {
+		if (this.runtimeService.getRunningState()) {
+			console.log("Companion feature enabled and companion started.");
+			return;
+		}
+		if (baseUrl?.trim()) {
+			console.log("Companion feature enabled.");
+			return;
+		}
+		console.log(config.companion.enabled ? "Companion feature enabled. It will auto-start the next time a local NextClaw runtime is available." : "Companion feature is not enabled.");
+	};
+};
+//#endregion
+export { CompanionProcessService };

package/dist/cli/commands/config/index.d.ts

@@ -0,0 +1,2 @@
+import { ConfigCommands } from "./services/config-commands.service.js";
+export { ConfigCommands };

package/dist/cli/commands/config/index.js

@@ -0,0 +1,2 @@
+import { ConfigCommands } from "./services/config-commands.service.js";
+export { ConfigCommands };

package/dist/cli/commands/config/services/config-commands.service.d.ts

@@ -0,0 +1,18 @@
+import { ConfigGetOptions, ConfigSetOptions, RequestRestartParams } from "../../../../shared/types/cli.types.js";
+
+//#region src/cli/commands/config/services/config-commands.service.d.ts
+declare class ConfigCommands {
+  private deps;
+  constructor(deps: {
+    requestRestart: (params: RequestRestartParams) => Promise<void>;
+  });
+  get: (pathExpr: string, opts?: ConfigGetOptions) => void;
+  set: (pathExpr: string, value: string, opts?: ConfigSetOptions) => Promise<void>;
+  unset: (pathExpr: string) => Promise<void>;
+  private resolveReadConfigView;
+  private resolveProjectedChannelContext;
+  private loadPluginChannelBindings;
+  private requestRestartForConfigDiff;
+}
+//#endregion
+export { ConfigCommands };

package/dist/cli/commands/config/services/config-commands.service.js

@@ -0,0 +1,133 @@
+import { getAtConfigPath, parseConfigSetValue, parseRequiredConfigPath, setAtConfigPath, unsetAtConfigPath } from "../../../../shared/utils/config-path.js";
+import { resolveChannelConfigView } from "../../../../commands/channel/channel-config-view.js";
+import { loadPluginRegistry, mergePluginConfigView } from "../../../../commands/plugin/index.js";
+import "../../../../commands/channel/index.js";
+import { buildReloadPlan, diffConfigPaths, getWorkspacePath, loadConfig, saveConfig } from "@nextclaw/core";
+import { getPluginChannelBindings } from "@nextclaw/openclaw-compat";
+//#region src/cli/commands/config/services/config-commands.service.ts
+var ConfigCommands = class {
+	constructor(deps) {
+		this.deps = deps;
+	}
+	get = (pathExpr, opts = {}) => {
+		let parsedPath;
+		try {
+			parsedPath = parseRequiredConfigPath(pathExpr);
+		} catch (error) {
+			console.error(String(error));
+			process.exit(1);
+			return;
+		}
+		const config = loadConfig();
+		const result = getAtConfigPath(this.resolveReadConfigView(config, parsedPath), parsedPath);
+		if (!result.found) {
+			console.error(`Config path not found: ${pathExpr}`);
+			process.exit(1);
+			return;
+		}
+		if (opts.json) {
+			console.log(JSON.stringify(result.value ?? null, null, 2));
+			return;
+		}
+		if (typeof result.value === "string" || typeof result.value === "number" || typeof result.value === "boolean") {
+			console.log(String(result.value));
+			return;
+		}
+		console.log(JSON.stringify(result.value ?? null, null, 2));
+	};
+	set = async (pathExpr, value, opts = {}) => {
+		let parsedPath;
+		try {
+			parsedPath = parseRequiredConfigPath(pathExpr);
+		} catch (error) {
+			console.error(String(error));
+			process.exit(1);
+			return;
+		}
+		let parsedValue;
+		try {
+			parsedValue = parseConfigSetValue(value, opts);
+		} catch (error) {
+			console.error(`Failed to parse config value: ${String(error)}`);
+			process.exit(1);
+			return;
+		}
+		const prevConfig = loadConfig();
+		const projectedContext = this.resolveProjectedChannelContext(prevConfig, parsedPath);
+		const nextConfigTarget = projectedContext ? structuredClone(projectedContext.view) : structuredClone(prevConfig);
+		try {
+			setAtConfigPath(nextConfigTarget, parsedPath, parsedValue);
+		} catch (error) {
+			console.error(String(error));
+			process.exit(1);
+			return;
+		}
+		const nextConfig = projectedContext ? mergePluginConfigView(prevConfig, nextConfigTarget, projectedContext.bindings) : nextConfigTarget;
+		saveConfig(nextConfig);
+		await this.requestRestartForConfigDiff({
+			prevConfig,
+			nextConfig,
+			reason: `config.set ${pathExpr}`,
+			manualMessage: `Updated ${pathExpr}. Restart the gateway to apply.`
+		});
+	};
+	unset = async (pathExpr) => {
+		let parsedPath;
+		try {
+			parsedPath = parseRequiredConfigPath(pathExpr);
+		} catch (error) {
+			console.error(String(error));
+			process.exit(1);
+			return;
+		}
+		const prevConfig = loadConfig();
+		const projectedContext = this.resolveProjectedChannelContext(prevConfig, parsedPath);
+		const nextConfigTarget = projectedContext ? structuredClone(projectedContext.view) : structuredClone(prevConfig);
+		if (!unsetAtConfigPath(nextConfigTarget, parsedPath)) {
+			console.error(`Config path not found: ${pathExpr}`);
+			process.exit(1);
+			return;
+		}
+		const nextConfig = projectedContext ? mergePluginConfigView(prevConfig, nextConfigTarget, projectedContext.bindings) : nextConfigTarget;
+		saveConfig(nextConfig);
+		await this.requestRestartForConfigDiff({
+			prevConfig,
+			nextConfig,
+			reason: `config.unset ${pathExpr}`,
+			manualMessage: `Removed ${pathExpr}. Restart the gateway to apply.`
+		});
+	};
+	resolveReadConfigView = (config, parsedPath) => {
+		if (parsedPath[0] !== "channels") return config;
+		const { bindings } = this.loadPluginChannelBindings(config);
+		return resolveChannelConfigView(config, bindings);
+	};
+	resolveProjectedChannelContext = (config, parsedPath) => {
+		if (parsedPath[0] !== "channels" || parsedPath.length < 2) return null;
+		const channelId = parsedPath[1];
+		const { bindings } = this.loadPluginChannelBindings(config);
+		if (!bindings.some((binding) => binding.channelId === channelId)) return null;
+		return {
+			bindings,
+			view: resolveChannelConfigView(config, bindings)
+		};
+	};
+	loadPluginChannelBindings = (config) => {
+		return { bindings: getPluginChannelBindings(loadPluginRegistry(config, getWorkspacePath(config.agents.defaults.workspace))) };
+	};
+	requestRestartForConfigDiff = async (params) => {
+		const { manualMessage, nextConfig, prevConfig, reason } = params;
+		const changedPaths = diffConfigPaths(prevConfig, nextConfig);
+		if (!changedPaths.length) return;
+		const plan = buildReloadPlan(changedPaths);
+		if (plan.restartRequired.length === 0) return;
+		await this.deps.requestRestart({
+			changedPaths: plan.restartRequired,
+			mode: "notify",
+			reason: `${reason} (${plan.restartRequired.join(", ")})`,
+			manualMessage
+		});
+	};
+};
+//#endregion
+export { ConfigCommands };

package/dist/cli/commands/cron/index.d.ts

@@ -0,0 +1,2 @@
+import { CronCommands } from "./services/cron-commands.service.js";
+export { CronCommands };

package/dist/cli/commands/cron/index.js

@@ -0,0 +1,2 @@
+import { CronCommands } from "./services/cron-commands.service.js";
+export { CronCommands };