@nextclaw/service 0.1.1

package/dist/service-runtime.service.js

@@ -0,0 +1,392 @@
+import { getPackageVersion as getPackageVersion$1 } from "./shared/utils/package/package-manifest.utils.js";
+import { isProcessRunning } from "./shared/utils/cli.utils.js";
+import { NpmRuntimeLauncher } from "./launcher/npm-runtime-launcher.service.js";
+import { NpmRuntimeUpdateCommandService } from "./launcher/npm-runtime-update-command.service.js";
+import { managedServiceStateStore } from "./shared/stores/managed-service-state.store.js";
+import { logStartupTrace, measureStartupSync } from "./shared/utils/startup-trace.js";
+import { createTopLevelNextclawCommandEnv } from "./shared/utils/top-level-nextclaw-command-env.utils.js";
+import { writeRestartSentinel } from "./shared/services/restart/restart-sentinel.service.js";
+import { hasRunningNextclawManagedService } from "./commands/remote/services/remote-runtime-support.service.js";
+import { RemoteCommands } from "./commands/remote/index.js";
+import { PlatformAuthCommands } from "./commands/platform-auth/services/platform-auth-commands.service.js";
+import "./commands/platform-auth/index.js";
+import { WorkspaceManager } from "./shared/services/workspace/workspace-manager.service.js";
+import { toExtensionRegistry } from "./commands/plugin/plugin-extension-registry.js";
+import { PluginCommands, loadPluginRegistry, logPluginDiagnostics, mergePluginConfigView, toPluginConfigView as toPluginConfigView$1 } from "./commands/plugin/index.js";
+import { RuntimeCommandService } from "./shared/services/runtime/runtime-command.service.js";
+import { initializeConfigIfMissing } from "./shared/services/runtime/runtime-config-init.service.js";
+import { RuntimeRestartRequestService } from "./shared/services/restart/runtime-restart-request.service.js";
+import { RestartCoordinator } from "./shared/services/restart/restart-coordinator.service.js";
+import { UiCommands } from "./cli/commands/ui/index.js";
+import { ChannelCommands } from "./commands/channel/index.js";
+import { ConfigCommands } from "./cli/commands/config/services/config-commands.service.js";
+import "./cli/commands/config/index.js";
+import { SecretsCommands } from "./cli/commands/secrets/index.js";
+import { StartCommands } from "./cli/commands/start/index.js";
+import { StopCommands } from "./cli/commands/stop/index.js";
+import { LlmUsageCommandService } from "./cli/commands/usage/services/llm-usage-command.service.js";
+import "./cli/commands/usage/index.js";
+import { runCliAgentCommand } from "./cli/commands/agent/cli-agent-runner.utils.js";
+import { AgentCommands } from "./cli/commands/agent/services/agent-commands.service.js";
+import "./cli/commands/agent/index.js";
+import { McpCommands } from "./cli/commands/mcp/index.js";
+import { RestartCommands } from "./cli/commands/restart/index.js";
+import { LogsCommands } from "./cli/commands/logs/index.js";
+import { DiagnosticsCommands } from "./cli/commands/diagnostics/services/diagnostics-commands.service.js";
+import "./cli/commands/diagnostics/index.js";
+import { SkillsCommands } from "./cli/commands/skills/index.js";
+import { ServeCommands } from "./cli/commands/serve/index.js";
+import { GatewayCommands } from "./cli/commands/gateway/index.js";
+import { CronCommands } from "./cli/commands/cron/services/cron-commands.service.js";
+import "./cli/commands/cron/index.js";
+import { CompanionCommands } from "./cli/commands/companion/index.js";
+import { ServiceCommands } from "./commands/service/index.js";
+import { spawn } from "node:child_process";
+import { fileURLToPath } from "node:url";
+import { join } from "node:path";
+import { APP_NAME, DEFAULT_WORKSPACE_DIR, DEFAULT_WORKSPACE_PATH, expandHome, getConfigPath, getDataDir, getWorkspacePath, loadConfig, resolveConfigSecrets, saveConfig } from "@nextclaw/core";
+import { existsSync, mkdirSync } from "node:fs";
+import { RemoteRuntimeActions } from "@nextclaw/remote";
+import { getPluginChannelBindings, resolvePluginChannelMessageToolHints, setPluginRuntimeBridge } from "@nextclaw/openclaw-compat";
+import { NextclawKernel } from "@nextclaw/kernel";
+//#region src/service-runtime.service.ts
+const FORCED_PUBLIC_UI_HOST = "0.0.0.0";
+var NextclawServiceRuntime = class {
+	logo;
+	restartCoordinator;
+	serviceRestartTask = null;
+	selfRelaunchArmed = false;
+	restartRequestService;
+	workspaceManager;
+	runtimeCommandService;
+	platformAuthCommands;
+	remoteCommands;
+	account;
+	commands;
+	constructor(options = {}) {
+		logStartupTrace("cli.runtime.constructor.begin");
+		this.logo = options.logo ?? "🤖";
+		this.workspaceManager = measureStartupSync("cli.runtime.workspace_manager", () => new WorkspaceManager(this.logo));
+		this.runtimeCommandService = measureStartupSync("cli.runtime.runtime_command_service", () => new RuntimeCommandService({
+			requestRestart: (params) => this.requestRestart(params),
+			initializeAgentHomeDirectory: (homeDirectory) => this.workspaceManager.createWorkspaceTemplates(homeDirectory)
+		}));
+		this.commands = this.createCommands();
+		this.restartCoordinator = measureStartupSync("cli.runtime.restart_coordinator", () => new RestartCoordinator({
+			readServiceState: managedServiceStateStore.read,
+			isProcessRunning,
+			currentPid: () => process.pid,
+			restartBackgroundService: async (reason) => this.restartBackgroundService(reason),
+			scheduleProcessExit: (delayMs, reason) => this.scheduleProcessExit(delayMs, reason)
+		}));
+		this.restartRequestService = new RuntimeRestartRequestService({
+			armManagedServiceRelaunch: (params) => this.armManagedServiceRelaunch(params),
+			requestRestartFromCoordinator: async (params) => await this.restartCoordinator.requestRestart(params)
+		});
+		this.account = {
+			status: async (opts = {}) => {
+				await this.init({
+					source: "account status",
+					auto: true
+				});
+				await this.platformAuthCommands.accountStatus(opts);
+			},
+			setUsername: async (username, opts = {}) => {
+				await this.init({
+					source: "account set-username",
+					auto: true
+				});
+				await this.platformAuthCommands.accountSetUsername({
+					apiBase: opts.apiBase,
+					json: opts.json,
+					username
+				});
+			}
+		};
+		logStartupTrace("cli.runtime.constructor.end");
+	}
+	createCommands = () => {
+		const start = measureStartupSync("cli.runtime.start_commands", () => new StartCommands({
+			runtimeCommandService: this.runtimeCommandService,
+			forcedPublicHost: FORCED_PUBLIC_UI_HOST,
+			init: (params) => this.init(params)
+		}));
+		this.platformAuthCommands = measureStartupSync("cli.runtime.platform_auth_commands", () => new PlatformAuthCommands());
+		this.remoteCommands = measureStartupSync("cli.runtime.remote_commands", () => new RemoteCommands());
+		return {
+			remote: measureStartupSync("cli.runtime.remote_runtime_actions", () => new RemoteRuntimeActions({
+				appName: APP_NAME,
+				initAuto: (source) => this.init({
+					source,
+					auto: true
+				}),
+				remoteCommands: this.remoteCommands,
+				restartBackgroundService: (reason) => this.restartBackgroundService(reason),
+				hasRunningManagedService: hasRunningNextclawManagedService
+			})),
+			skills: measureStartupSync("cli.runtime.skills_commands", () => new SkillsCommands()),
+			service: measureStartupSync("cli.runtime.service_commands", () => new ServiceCommands()),
+			config: measureStartupSync("cli.runtime.config_commands", () => new ConfigCommands({ requestRestart: (params) => this.requestRestart(params) })),
+			mcp: measureStartupSync("cli.runtime.mcp_commands", () => new McpCommands()),
+			secrets: measureStartupSync("cli.runtime.secrets_commands", () => new SecretsCommands({ requestRestart: (params) => this.requestRestart(params) })),
+			plugins: measureStartupSync("cli.runtime.plugin_commands", () => new PluginCommands()),
+			agents: measureStartupSync("cli.runtime.agent_commands", () => new AgentCommands({ initializeAgentHomeDirectory: (homeDirectory) => this.workspaceManager.createWorkspaceTemplates(homeDirectory) })),
+			channels: measureStartupSync("cli.runtime.channel_commands", () => new ChannelCommands({
+				logo: this.logo,
+				getBridgeDir: () => this.workspaceManager.getBridgeDir(),
+				requestRestart: (params) => this.requestRestart(params)
+			})),
+			cron: measureStartupSync("cli.runtime.cron_commands", () => new CronCommands()),
+			diagnostics: measureStartupSync("cli.runtime.diagnostics_commands", () => new DiagnosticsCommands({ logo: this.logo })),
+			logs: measureStartupSync("cli.runtime.logs_commands", () => new LogsCommands()),
+			gateway: measureStartupSync("cli.runtime.gateway_commands", () => new GatewayCommands({
+				runtimeCommandService: this.runtimeCommandService,
+				forcedPublicHost: FORCED_PUBLIC_UI_HOST
+			})),
+			ui: measureStartupSync("cli.runtime.ui_commands", () => new UiCommands({
+				runtimeCommandService: this.runtimeCommandService,
+				forcedPublicHost: FORCED_PUBLIC_UI_HOST
+			})),
+			start,
+			restart: measureStartupSync("cli.runtime.restart_commands", () => new RestartCommands({
+				runtimeCommandService: this.runtimeCommandService,
+				startCommands: start,
+				forcedPublicHost: FORCED_PUBLIC_UI_HOST,
+				writeRestartSentinelFromExecContext: (reason) => this.writeRestartSentinelFromExecContext(reason)
+			})),
+			serve: measureStartupSync("cli.runtime.serve_commands", () => new ServeCommands({
+				runtimeCommandService: this.runtimeCommandService,
+				forcedPublicHost: FORCED_PUBLIC_UI_HOST
+			})),
+			stop: measureStartupSync("cli.runtime.stop_commands", () => new StopCommands({ runtimeCommandService: this.runtimeCommandService })),
+			companion: measureStartupSync("cli.runtime.companion_commands", () => new CompanionCommands()),
+			usage: measureStartupSync("cli.runtime.usage_commands", () => new LlmUsageCommandService())
+		};
+	};
+	get version() {
+		return getPackageVersion$1();
+	}
+	scheduleProcessExit = (delayMs, reason) => {
+		console.warn(`Gateway restart requested (${reason}).`);
+		setTimeout(() => {
+			process.exit(0);
+		}, delayMs);
+	};
+	restartBackgroundService = async (reason) => {
+		if (this.serviceRestartTask) return this.serviceRestartTask;
+		this.serviceRestartTask = (async () => {
+			const state = managedServiceStateStore.read();
+			if (!state || !isProcessRunning(state.pid) || state.pid === process.pid) return false;
+			const uiHost = FORCED_PUBLIC_UI_HOST;
+			const uiPort = typeof state.uiPort === "number" && Number.isFinite(state.uiPort) ? state.uiPort : 55667;
+			console.log(`Applying changes (${reason}): restarting ${APP_NAME} background service...`);
+			await this.runtimeCommandService.stopService();
+			await this.runtimeCommandService.startService({
+				uiOverrides: {
+					enabled: true,
+					host: uiHost,
+					port: uiPort
+				},
+				open: false
+			});
+			return true;
+		})();
+		try {
+			return await this.serviceRestartTask;
+		} finally {
+			this.serviceRestartTask = null;
+		}
+	};
+	armManagedServiceRelaunch = (params) => {
+		const { delayMs: requestedDelayMs, reason, strategy: requestedStrategy } = params;
+		const strategy = requestedStrategy ?? "background-service-or-manual";
+		if (strategy !== "background-service-or-exit" && strategy !== "exit-process") return;
+		if (this.selfRelaunchArmed) return;
+		const state = managedServiceStateStore.read();
+		if (!state || state.pid !== process.pid) return;
+		const uiPort = typeof state.uiPort === "number" && Number.isFinite(state.uiPort) ? state.uiPort : 55667;
+		const delayMs = typeof requestedDelayMs === "number" && Number.isFinite(requestedDelayMs) ? Math.max(0, Math.floor(requestedDelayMs)) : 100;
+		const startArgs = [
+			process.env.NEXTCLAW_SELF_RELAUNCH_CLI?.trim() || fileURLToPath(new URL("./index.js", import.meta.url)),
+			"start",
+			"--ui-port",
+			String(uiPort)
+		];
+		const serviceStatePath = managedServiceStateStore.path;
+		const helperScript = [
+			"const { spawnSync } = require(\"node:child_process\");",
+			"const { readFileSync } = require(\"node:fs\");",
+			`const parentPid = ${process.pid};`,
+			`const delayMs = ${delayMs};`,
+			"const maxWaitMs = 120000;",
+			"const retryIntervalMs = 1000;",
+			"const startTimeoutMs = 60000;",
+			`const nodePath = ${JSON.stringify(process.execPath)};`,
+			`const startArgs = ${JSON.stringify(startArgs)};`,
+			`const serviceStatePath = ${JSON.stringify(serviceStatePath)};`,
+			"function isRunning(pid) {",
+			"  try {",
+			"    process.kill(pid, 0);",
+			"    return true;",
+			"  } catch {",
+			"    return false;",
+			"  }",
+			"}",
+			"function hasReplacementService() {",
+			"  try {",
+			"    const raw = readFileSync(serviceStatePath, \"utf-8\");",
+			"    const state = JSON.parse(raw);",
+			"    const pid = Number(state?.pid);",
+			"    return Number.isFinite(pid) && pid > 0 && pid !== parentPid && isRunning(pid);",
+			"  } catch {",
+			"    return false;",
+			"  }",
+			"}",
+			"function tryStart() {",
+			"  spawnSync(nodePath, startArgs, {",
+			"    stdio: \"ignore\",",
+			"    env: process.env,",
+			"    timeout: startTimeoutMs",
+			"  });",
+			"}",
+			"setTimeout(() => {",
+			"  const startedAt = Date.now();",
+			"  const tick = () => {",
+			"    if (hasReplacementService()) {",
+			"      process.exit(0);",
+			"      return;",
+			"    }",
+			"    if (Date.now() - startedAt >= maxWaitMs) {",
+			"      process.exit(0);",
+			"      return;",
+			"    }",
+			"    tryStart();",
+			"    if (hasReplacementService()) {",
+			"      process.exit(0);",
+			"      return;",
+			"    }",
+			"    setTimeout(tick, retryIntervalMs);",
+			"  };",
+			"  tick();",
+			"}, delayMs);"
+		].join("\n");
+		try {
+			spawn(process.execPath, ["-e", helperScript], {
+				detached: true,
+				stdio: "ignore",
+				env: createTopLevelNextclawCommandEnv(process.env)
+			}).unref();
+			this.selfRelaunchArmed = true;
+			console.warn(`Gateway self-restart armed (${reason}).`);
+		} catch (error) {
+			console.error(`Failed to arm gateway self-restart: ${String(error)}`);
+		}
+	};
+	requestRestart = async (params) => {
+		await this.restartRequestService.run(params);
+	};
+	writeRestartSentinelFromExecContext = async (reason) => {
+		const sessionKeyRaw = process.env.NEXTCLAW_RUNTIME_SESSION_KEY;
+		const sessionKey = typeof sessionKeyRaw === "string" ? sessionKeyRaw.trim() : "";
+		if (!sessionKey) return;
+		try {
+			await writeRestartSentinel({
+				kind: "restart",
+				status: "ok",
+				ts: Date.now(),
+				sessionKey,
+				stats: {
+					reason: reason || "cli.restart",
+					strategy: "exec-tool"
+				}
+			});
+		} catch (error) {
+			console.warn(`Warning: failed to write restart sentinel from exec context: ${String(error)}`);
+		}
+	};
+	onboard = async () => {
+		console.warn(`Warning: ${APP_NAME} onboard is deprecated. Use "${APP_NAME} init" instead.`);
+		await this.init({ source: "onboard" });
+	};
+	init = async (options = {}) => {
+		const source = options.source ?? "init";
+		const prefix = options.auto ? "Auto init" : "Init";
+		const force = Boolean(options.force);
+		const configPath = getConfigPath();
+		const createdConfig = initializeConfigIfMissing(configPath);
+		const workspaceSetting = loadConfig().agents.defaults.workspace;
+		const workspacePath = !workspaceSetting || workspaceSetting === DEFAULT_WORKSPACE_PATH ? join(getDataDir(), DEFAULT_WORKSPACE_DIR) : expandHome(workspaceSetting);
+		const workspaceExisted = existsSync(workspacePath);
+		mkdirSync(workspacePath, { recursive: true });
+		const templateResult = this.workspaceManager.createWorkspaceTemplates(workspacePath, { force });
+		if (createdConfig) console.log(`✓ ${prefix}: created config at ${configPath}`);
+		if (!workspaceExisted) console.log(`✓ ${prefix}: created workspace at ${workspacePath}`);
+		for (const file of templateResult.created) console.log(`✓ ${prefix}: created ${file}`);
+		if (!createdConfig && workspaceExisted && templateResult.created.length === 0) console.log(`${prefix}: already initialized.`);
+		if (!options.auto) {
+			console.log(`\n${this.logo} ${APP_NAME} is ready! (${source})`);
+			console.log("\nNext steps:");
+			console.log(`  1. Add your API key to ${configPath}`);
+			console.log(`  2. Chat: ${APP_NAME} agent -m "Hello!"`);
+		} else console.log(`Tip: Run "${APP_NAME} init${force ? " --force" : ""}" to re-run initialization if needed.`);
+	};
+	login = async (opts = {}) => {
+		await this.init({
+			source: "login",
+			auto: true
+		});
+		await this.platformAuthCommands.login(opts);
+	};
+	agent = async (opts) => {
+		const configPath = getConfigPath();
+		const kernel = new NextclawKernel({
+			homeDir: getDataDir(),
+			configPath
+		});
+		const config = kernel.configManager.config;
+		const pluginRegistry = loadPluginRegistry(config, getWorkspacePath(config.agents.defaults.workspace));
+		const extensionRegistry = toExtensionRegistry(pluginRegistry);
+		logPluginDiagnostics(pluginRegistry);
+		const pluginChannelBindings = getPluginChannelBindings(pluginRegistry);
+		setPluginRuntimeBridge({
+			loadConfig: () => toPluginConfigView$1(resolveConfigSecrets(loadConfig(), { configPath }), pluginChannelBindings),
+			writeConfigFile: async (nextConfigView) => {
+				if (!nextConfigView || typeof nextConfigView !== "object" || Array.isArray(nextConfigView)) throw new Error("plugin runtime writeConfigFile expects an object config");
+				saveConfig(mergePluginConfigView(loadConfig(), nextConfigView, pluginChannelBindings));
+			}
+		});
+		try {
+			const providerManager = kernel.llmUsage.observeProviderManager(kernel.llmProviders, "cli-agent");
+			await runCliAgentCommand({
+				logo: this.logo,
+				opts,
+				config,
+				kernel,
+				providerManager,
+				extensionRegistry,
+				loadResolvedConfig: () => resolveConfigSecrets(loadConfig(), { configPath }),
+				resolveMessageToolHints: ({ channel, accountId }) => resolvePluginChannelMessageToolHints({
+					registry: pluginRegistry,
+					channel,
+					cfg: resolveConfigSecrets(loadConfig(), { configPath }),
+					accountId
+				})
+			});
+		} finally {
+			setPluginRuntimeBridge(null);
+		}
+	};
+	update = async (opts) => {
+		const versionBefore = getPackageVersion$1();
+		if (!opts.json) console.log(`Current npm launcher version: ${versionBefore}`);
+		const snapshot = await new NpmRuntimeUpdateCommandService().run(opts);
+		if (snapshot.status === "blocked" || snapshot.status === "failed") process.exit(1);
+		const state = managedServiceStateStore.read();
+		if (snapshot.requiresRestart && state && isProcessRunning(state.pid)) console.log(`Tip: restart ${APP_NAME} to apply the update.`);
+	};
+};
+const runNextclawNpmRuntimeLauncher = (argv = process.argv) => {
+	new NpmRuntimeLauncher({ argv }).run();
+};
+//#endregion
+export { NextclawServiceRuntime, runNextclawNpmRuntimeLauncher };

package/dist/shared/controllers/gateway.controller.d.ts

@@ -0,0 +1,61 @@
+import { Config, CronService, GatewayController, SessionManager } from "@nextclaw/core";
+import { ChannelManager } from "@nextclaw/kernel";
+
+//#region src/shared/controllers/gateway.controller.d.ts
+type ConfigManagerLike = {
+  applyReloadPlan: (nextConfig: Config) => Promise<void>;
+  reloadConfig: (reason?: string) => Promise<string>;
+};
+type ControllerDeps = {
+  configManager: ConfigManagerLike;
+  channels: ChannelManager;
+  cron: CronService;
+  sessionManager?: SessionManager;
+  getConfigPath: () => string;
+  saveConfig: (config: Config) => void;
+  requestRestart?: (options?: {
+    delayMs?: number;
+    reason?: string;
+  }) => Promise<void> | void;
+};
+declare class GatewayControllerImpl implements GatewayController {
+  private deps;
+  constructor(deps: ControllerDeps);
+  private normalizeOptionalString;
+  private resolveDeliveryContext;
+  private writeRestartSentinelPayload;
+  private requestRestart;
+  private createConfigMutationResult;
+  private applyConfigChange;
+  status: () => Record<string, unknown>;
+  reloadConfig: (reason?: string) => Promise<string>;
+  restart: (options?: {
+    delayMs?: number;
+    reason?: string;
+    sessionKey?: string;
+  }) => Promise<string>;
+  getConfig: () => Promise<Record<string, unknown>>;
+  getConfigSchema: () => Promise<Record<string, unknown>>;
+  applyConfig: (params: {
+    raw: string;
+    baseHash?: string;
+    note?: string;
+    restartDelayMs?: number;
+    sessionKey?: string;
+  }) => Promise<Record<string, unknown>>;
+  patchConfig: (params: {
+    raw: string;
+    baseHash?: string;
+    note?: string;
+    restartDelayMs?: number;
+    sessionKey?: string;
+  }) => Promise<Record<string, unknown>>;
+  updateRun: (params: {
+    note?: string;
+    restartDelayMs?: number;
+    timeoutMs?: number;
+    sessionKey?: string;
+  }) => Promise<Record<string, unknown>>;
+}
+//#endregion
+export { GatewayControllerImpl };