nextclaw 0.21.5 → 0.21.7

package/dist/cli/app/index.js

@@ -1,16 +1,17 @@
 #!/usr/bin/env node
 import { t as createNextclawDistribution } from "../../nextclaw-distribution.utils-BJZhAnGk.js";
 import { createRequire } from "node:module";
-import { APP_NAME, APP_TAGLINE, getConfigPath, loadConfig, resolveConfigSecrets } from "@nextclaw/core";
+import { APP_NAME, APP_TAGLINE, getConfigPath, getDataDir, getRunPath, loadConfig, resolveConfigSecrets } from "@nextclaw/core";
 import { Command } from "commander";
-import { constants } from "node:fs";
-import path from "node:path";
+import { constants, existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import path, { join, resolve } from "node:path";
 import "@nextclaw/server";
 import { NextclawDistributionService, NextclawServiceRuntime, readLearningLoopRuntimeConfig } from "@nextclaw/service";
 import { McpServiceAppRuntimeService, buildServiceActionId, getServiceAppManifestPath, mergeServiceAppRuntimeActions, readServiceAppManifest } from "@nextclaw/kernel";
 import { access, readFile, stat } from "node:fs/promises";
 import { execFile } from "node:child_process";
 import { promisify } from "node:util";
+import { randomBytes } from "node:crypto";
 var __commonJSMin = (cb, mod) => () => (mod || cb((mod = { exports: {} }).exports, mod), mod.exports);
 var __require = /* @__PURE__ */ createRequire(import.meta.url);
 //#endregion
@@ -2017,7 +2018,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 	const http$1 = __require("http");
 	const net = __require("net");
 	const tls = __require("tls");
-	const { randomBytes, createHash: createHash$1 } = __require("crypto");
+	const { randomBytes: randomBytes$1, createHash: createHash$1 } = __require("crypto");
 	const { Duplex: Duplex$2, Readable } = __require("stream");
 	const { URL: URL$1 } = __require("url");
 	const PerMessageDeflate = require_permessage_deflate();
@@ -2572,7 +2573,7 @@ var require_websocket = /* @__PURE__ */ __commonJSMin(((exports, module) => {
 			}
 		}
 		const defaultPort = isSecure ? 443 : 80;
-		const key = randomBytes(16).toString("base64");
+		const key = randomBytes$1(16).toString("base64");
 		const request = isSecure ? https.request : http$1.request;
 		const protocolSet = /* @__PURE__ */ new Set();
 		let perMessageDeflate;
@@ -4416,15 +4417,183 @@ var AppDevCommandController = class {
 	};
 };
 //#endregion
+//#region src/cli/app/services/service-app-live-runtime.service.ts
+function readErrorMessage(error) {
+	if (error instanceof Error && error.message.trim().length > 0) return error.message.trim();
+	return String(error ?? "unknown error");
+}
+var ServiceAppLiveRuntimeService = class {
+	constructor(params = {}) {
+		this.params = params;
+	}
+	restart = async (appId) => {
+		const target = appId.trim();
+		const issues = [];
+		if (!target) {
+			issues.push({
+				severity: "error",
+				code: "service.id.invalid",
+				message: "Service App id is required."
+			});
+			return {
+				ok: false,
+				target,
+				issues
+			};
+		}
+		const apiClient = this.createApiClient();
+		if (!apiClient) {
+			issues.push({
+				severity: "error",
+				code: "service.runtime.notRunning",
+				message: "NextClaw UI runtime is not running; start NextClaw before restarting a live Service App."
+			});
+			return {
+				ok: false,
+				target,
+				issues
+			};
+		}
+		try {
+			return {
+				ok: true,
+				target,
+				app: await apiClient.request({
+					path: `/api/service-apps/${encodeURIComponent(target)}/restart`,
+					method: "POST"
+				}),
+				issues
+			};
+		} catch (error) {
+			issues.push({
+				severity: "error",
+				code: "service.runtime.restartFailed",
+				message: readErrorMessage(error)
+			});
+			return {
+				ok: false,
+				target,
+				issues
+			};
+		}
+	};
+	createApiClient = () => {
+		if (this.params.createApiClient) return this.params.createApiClient();
+		const apiBase = resolveLocalUiApiBase();
+		return apiBase ? new LocalUiApiClient(apiBase) : null;
+	};
+};
+var LocalUiApiClient = class {
+	cookie;
+	constructor(apiBase) {
+		this.apiBase = apiBase;
+	}
+	request = async (params) => {
+		const { body, method, path } = params;
+		const cookie = await this.getCookie();
+		const headers = {};
+		if (body) headers["Content-Type"] = "application/json";
+		if (cookie) headers.Cookie = cookie;
+		const requestInit = {
+			method: method ?? "GET",
+			headers
+		};
+		if (body) requestInit.body = JSON.stringify(body);
+		const response = await fetch(`${this.apiBase}${path}`, requestInit);
+		if (!response.ok) throw new Error(`api request failed with status ${response.status}`);
+		const payload = await response.json();
+		if (!payload.ok) throw new Error(payload.error?.message ?? "api request failed");
+		return payload.data;
+	};
+	getCookie = async () => {
+		if (this.cookie !== void 0) return this.cookie;
+		const response = await fetch(`${this.apiBase}/api/auth/bridge`, {
+			method: "POST",
+			headers: { "x-nextclaw-ui-bridge-secret": ensureUiBridgeSecret() }
+		});
+		if (!response.ok) throw new Error(`bridge auth failed with status ${response.status}`);
+		const payload = await response.json();
+		if (!payload.ok) throw new Error(payload.error?.message ?? "bridge auth failed");
+		this.cookie = typeof payload.data.cookie === "string" && payload.data.cookie.trim().length > 0 ? payload.data.cookie.trim() : null;
+		return this.cookie;
+	};
+};
+function resolveLocalUiApiBase() {
+	const state = readRunningRuntimeState(resolve(getRunPath(), "ui-runtime.json")) ?? readRunningRuntimeState(resolve(getRunPath(), "service.json"));
+	if (!state) return null;
+	if (typeof state.uiUrl === "string" && state.uiUrl.trim().length > 0) return state.uiUrl.replace(/\/+$/, "");
+	if (typeof state.apiUrl === "string" && state.apiUrl.trim().length > 0) return state.apiUrl.replace(/\/api\/?$/, "").replace(/\/+$/, "");
+	return null;
+}
+function readRunningRuntimeState(statePath) {
+	if (!existsSync(statePath)) return null;
+	try {
+		const state = JSON.parse(readFileSync(statePath, "utf-8"));
+		return typeof state.pid === "number" && isProcessRunning(state.pid) ? state : null;
+	} catch {
+		return null;
+	}
+}
+function isProcessRunning(pid) {
+	try {
+		process.kill(pid, 0);
+		return true;
+	} catch {
+		return false;
+	}
+}
+function ensureUiBridgeSecret() {
+	const dirPath = join(getDataDir(), "remote");
+	const secretPath = join(dirPath, "ui-bridge-secret");
+	if (existsSync(secretPath)) {
+		const existing = readFileSync(secretPath, "utf-8").trim();
+		if (existing.length > 0) return existing;
+	}
+	mkdirSync(dirPath, { recursive: true });
+	const secret = randomBytes(24).toString("hex");
+	writeFileSync(secretPath, `${secret}\n`, "utf-8");
+	return secret;
+}
+//#endregion
+//#region src/cli/app/controllers/app-restart-command.controller.ts
+var AppRestartCommandController = class {
+	constructor(liveRuntimeService = new ServiceAppLiveRuntimeService()) {
+		this.liveRuntimeService = liveRuntimeService;
+	}
+	restart = async (appId, options) => {
+		const report = await this.liveRuntimeService.restart(appId);
+		process.stdout.write(options.json ? `${JSON.stringify(report, null, 2)}\n` : this.format(report));
+		if (!report.ok) process.exitCode = 1;
+	};
+	format = (report) => {
+		return [
+			report.ok ? `NextClaw service app restart passed: ${report.target}\n` : `NextClaw service app restart failed: ${report.target || "(empty)"}\n`,
+			report.app ? [
+				`App: ${report.app.title} (${report.app.id})`,
+				`Status: ${report.app.status}`,
+				report.app.lastError ? `Last error: ${report.app.lastError}` : ""
+			].filter(Boolean).join("\n") : "",
+			this.formatIssueSection("Errors", report.issues.filter((issue) => issue.severity === "error")),
+			this.formatIssueSection("Warnings", report.issues.filter((issue) => issue.severity === "warning"))
+		].filter(Boolean).join("\n");
+	};
+	formatIssueSection = (title, issues) => {
+		if (issues.length === 0) return "";
+		return `${title}:\n${issues.flatMap((issue) => [`- [${issue.code}] ${issue.message}`, issue.fixHint ? `  Fix: ${issue.fixHint}` : ""].filter(Boolean)).join("\n")}\n`;
+	};
+};
+//#endregion
 //#region src/cli/app/register-app-commands.ts
 function registerAppCommands(program) {
 	const app = program.command("app").description("Inspect and validate lightweight NextClaw apps");
 	const appCheck = new AppCheckCommandController();
 	const appDev = new AppDevCommandController();
 	const appCall = new AppCallCommandController();
+	const appRestart = new AppRestartCommandController();
 	app.command("check <app-dir>").description("Check a Panel App or Service App directory").option("--json", "Output JSON", false).action(async (target, opts) => appCheck.check(target, opts));
 	app.command("dev <service-app-dir>").description("Start a Service App through the real runtime and inspect its actions").option("--json", "Output JSON", false).action(async (target, opts) => appDev.dev(target, opts));
 	app.command("call <service-app-dir> <action-name>").description("Call a Service App action through the real runtime").option("--input <json>", "JSON object input for the action").option("--json", "Output JSON", false).action(async (target, actionName, opts) => appCall.call(target, actionName, opts));
+	app.command("restart <app-id>").description("Restart a live Service App runtime in the running NextClaw UI").option("--json", "Output JSON", false).action(async (appId, opts) => appRestart.restart(appId, opts));
 }
 //#endregion
 //#region src/cli/app/index.ts