@nextclaw/app-runtime 0.4.1 → 0.5.0

package/dist/runtime/app-build.service.js

@@ -0,0 +1,55 @@
+import { AppManifestService } from "../manifest/app-manifest.service.js";
+import { AppRuntimeToolchainService } from "./app-runtime-toolchain.service.js";
+import { access } from "node:fs/promises";
+import path from "node:path";
+//#region src/runtime/app-build.service.ts
+var AppBuildService = class {
+	constructor(manifestService = new AppManifestService(), toolchainService = new AppRuntimeToolchainService()) {
+		this.manifestService = manifestService;
+		this.toolchainService = toolchainService;
+	}
+	build = async (params) => {
+		const appDirectory = path.resolve(params.appDirectory);
+		const bundle = await this.manifestService.load(appDirectory);
+		if (bundle.manifest.main.kind !== "wasi-http-component") return {
+			appDirectory,
+			mainKind: bundle.manifest.main.kind,
+			mainEntryPath: bundle.mainEntryPath,
+			installedDependencies: false,
+			built: false,
+			skippedReason: "main.kind=wasm 应用不需要 TS/WASI HTTP 构建。"
+		};
+		await this.toolchainService.assertReadyForWasiHttpBuild();
+		const mainDirectory = path.join(appDirectory, "main");
+		await access(path.join(mainDirectory, "package.json"));
+		const shouldInstall = params.install || !await this.pathExists(path.join(mainDirectory, "node_modules"));
+		if (shouldInstall) await this.toolchainService.runCommand({
+			command: "npm",
+			args: ["install"],
+			cwd: mainDirectory
+		});
+		await this.toolchainService.runCommand({
+			command: "npm",
+			args: ["run", "build"],
+			cwd: mainDirectory
+		});
+		await access(bundle.mainEntryPath);
+		return {
+			appDirectory,
+			mainKind: bundle.manifest.main.kind,
+			mainEntryPath: bundle.mainEntryPath,
+			installedDependencies: shouldInstall,
+			built: true
+		};
+	};
+	pathExists = async (targetPath) => {
+		try {
+			await access(targetPath);
+			return true;
+		} catch {
+			return false;
+		}
+	};
+};
+//#endregion
+export { AppBuildService };

package/dist/runtime/app-runtime-toolchain.service.d.ts

@@ -0,0 +1,30 @@
+//#region src/runtime/app-runtime-toolchain.service.d.ts
+type AppRuntimeToolStatus = {
+  name: string;
+  command: string;
+  ok: boolean;
+  version?: string;
+  installHint: string;
+  error?: string;
+};
+type AppRuntimeDoctorResult = {
+  ok: boolean;
+  tools: AppRuntimeToolStatus[];
+};
+type AppRuntimeCommandResult = {
+  stdout: string;
+  stderr: string;
+};
+declare class AppRuntimeToolchainService {
+  doctor: () => Promise<AppRuntimeDoctorResult>;
+  assertReadyForWasiHttpBuild: () => Promise<void>;
+  runCommand: (params: {
+    command: string;
+    args: string[];
+    cwd: string;
+  }) => Promise<AppRuntimeCommandResult>;
+  private checkTool;
+  private collectProcess;
+}
+//#endregion
+export { AppRuntimeCommandResult, AppRuntimeDoctorResult, AppRuntimeToolStatus, AppRuntimeToolchainService };

package/dist/runtime/app-runtime-toolchain.service.js

@@ -0,0 +1,96 @@
+import { spawn } from "node:child_process";
+//#region src/runtime/app-runtime-toolchain.service.ts
+const REQUIRED_TOOLS = [
+	{
+		name: "npm",
+		command: "npm",
+		args: ["--version"],
+		installHint: "请安装 Node.js，或使用 NextClaw 桌面版内置运行环境。"
+	},
+	{
+		name: "wasmtime",
+		command: "wasmtime",
+		args: ["--version"],
+		installHint: "请安装 Wasmtime，或使用后续内置 Wasmtime 的 NextClaw 发行包。"
+	},
+	{
+		name: "wkg",
+		command: "wkg",
+		args: ["--version"],
+		installHint: "请安装 Bytecode Alliance wkg；有 Rust/Cargo 时可执行：cargo install wkg --locked。"
+	}
+];
+var AppRuntimeToolchainService = class {
+	doctor = async () => {
+		const tools = await Promise.all(REQUIRED_TOOLS.map((tool) => this.checkTool(tool)));
+		return {
+			ok: tools.every((tool) => tool.ok),
+			tools
+		};
+	};
+	assertReadyForWasiHttpBuild = async () => {
+		const missing = (await this.doctor()).tools.filter((tool) => !tool.ok);
+		if (missing.length === 0) return;
+		throw new Error(["NApp WASI HTTP 开发环境尚未就绪。", ...missing.map((tool) => `- 缺少 ${tool.name}: ${tool.installHint}`)].join("\n"));
+	};
+	runCommand = async (params) => {
+		const { command, args, cwd } = params;
+		const child = spawn(command, args, {
+			cwd,
+			stdio: [
+				"ignore",
+				"pipe",
+				"pipe"
+			]
+		});
+		return await this.collectProcess(child, command);
+	};
+	checkTool = async (tool) => {
+		try {
+			const result = await this.runCommand({
+				command: tool.command,
+				args: tool.args,
+				cwd: process.cwd()
+			});
+			const version = (result.stdout || result.stderr).trim().split(/\r?\n/)[0]?.trim();
+			return {
+				name: tool.name,
+				command: tool.command,
+				ok: true,
+				version,
+				installHint: tool.installHint
+			};
+		} catch (error) {
+			return {
+				name: tool.name,
+				command: tool.command,
+				ok: false,
+				installHint: tool.installHint,
+				error: error instanceof Error ? error.message : String(error)
+			};
+		}
+	};
+	collectProcess = async (child, command) => {
+		const stdoutChunks = [];
+		const stderrChunks = [];
+		child.stdout.on("data", (chunk) => {
+			stdoutChunks.push(chunk);
+		});
+		child.stderr.on("data", (chunk) => {
+			stderrChunks.push(chunk);
+		});
+		const exitCode = await new Promise((resolve, reject) => {
+			child.once("error", reject);
+			child.once("exit", resolve);
+		});
+		const stdout = Buffer.concat(stdoutChunks).toString("utf-8");
+		const stderr = Buffer.concat(stderrChunks).toString("utf-8");
+		if (exitCode !== 0) throw new Error(`${command} exited with ${exitCode ?? "unknown"}\n${stderr || stdout}`);
+		return {
+			stdout,
+			stderr
+		};
+	};
+};
+//#endregion
+export { AppRuntimeToolchainService };

package/dist/runtime/wasm-main-runner.service.js

@@ -7,6 +7,7 @@ var WasmMainRunnerService = class extends MainRunnerService {
 		this.sidecarClient = sidecarClient;
 	}
 	runDocumentSummary = async (request) => {
+		if (request.bundle.manifest.main.kind !== "wasm") throw new Error("runDocumentSummary 只支持 main.kind=wasm。");
 		const output = await this.sidecarClient.runExport({
 			wasmPath: request.bundle.mainEntryPath,
 			exportName: request.bundle.manifest.main.export,

package/dist/runtime/wasmtime-wasi-http-component.service.d.ts

@@ -0,0 +1,24 @@
+import { IncomingMessage, ServerResponse } from "node:http";
+
+//#region src/runtime/wasmtime-wasi-http-component.service.d.ts
+type WasmtimeWasiHttpComponentStartOptions = {
+  wasmPath: string;
+  dataDirectory: string;
+};
+type WasmtimeWasiHttpComponentHandle = {
+  url: string;
+  port: number;
+};
+declare class WasmtimeWasiHttpComponentService {
+  private process?;
+  private handle?;
+  start: (options: WasmtimeWasiHttpComponentStartOptions) => Promise<WasmtimeWasiHttpComponentHandle>;
+  stop: () => Promise<void>;
+  handleRequest: (request: IncomingMessage, response: ServerResponse) => Promise<boolean>;
+  private readBody;
+  private methodSupportsBody;
+  private findAvailablePort;
+  private waitUntilReady;
+}
+//#endregion
+export { WasmtimeWasiHttpComponentHandle, WasmtimeWasiHttpComponentService, WasmtimeWasiHttpComponentStartOptions };

package/dist/runtime/wasmtime-wasi-http-component.service.js

@@ -0,0 +1,129 @@
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { createServer } from "node:http";
+import { spawn } from "node:child_process";
+//#region src/runtime/wasmtime-wasi-http-component.service.ts
+var WasmtimeWasiHttpComponentService = class {
+	process;
+	handle;
+	start = async (options) => {
+		if (this.process) throw new Error("WASI HTTP component 已经启动。");
+		const dataDirectory = path.resolve(options.dataDirectory);
+		await mkdir(dataDirectory, { recursive: true });
+		const port = await this.findAvailablePort();
+		const child = spawn("wasmtime", [
+			"serve",
+			"-S",
+			"cli=y",
+			"-S",
+			"http=y",
+			"-S",
+			"inherit-network=y",
+			"--addr",
+			`127.0.0.1:${port}`,
+			"--dir",
+			`${dataDirectory}::/data`,
+			options.wasmPath
+		], { stdio: [
+			"ignore",
+			"pipe",
+			"pipe"
+		] });
+		this.process = child;
+		const handle = {
+			url: `http://127.0.0.1:${port}`,
+			port
+		};
+		this.handle = handle;
+		await this.waitUntilReady(handle.url, child);
+		return handle;
+	};
+	stop = async () => {
+		const child = this.process;
+		if (!child) return;
+		await new Promise((resolve) => {
+			child.once("exit", () => {
+				resolve();
+			});
+			child.kill("SIGTERM");
+			setTimeout(() => {
+				if (!child.killed) child.kill("SIGKILL");
+				resolve();
+			}, 1e3).unref();
+		});
+		this.process = void 0;
+		this.handle = void 0;
+	};
+	handleRequest = async (request, response) => {
+		const handle = this.handle;
+		if (!handle) return false;
+		const requestUrl = new URL(request.url ?? "/", handle.url);
+		if (!requestUrl.pathname.startsWith("/api/")) return false;
+		const headers = new Headers();
+		for (const [key, value] of Object.entries(request.headers)) {
+			if (value === void 0 || key.toLowerCase() === "host") continue;
+			if (Array.isArray(value)) {
+				for (const item of value) headers.append(key, item);
+				continue;
+			}
+			headers.set(key, value);
+		}
+		const body = await this.readBody(request);
+		const upstreamResponse = await fetch(requestUrl, {
+			method: request.method,
+			headers,
+			body: this.methodSupportsBody(request.method) ? body : void 0
+		});
+		response.writeHead(upstreamResponse.status, Object.fromEntries(upstreamResponse.headers));
+		response.end(Buffer.from(await upstreamResponse.arrayBuffer()));
+		return true;
+	};
+	readBody = async (request) => {
+		const chunks = [];
+		for await (const chunk of request) chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+		return Buffer.concat(chunks);
+	};
+	methodSupportsBody = (method) => {
+		return method !== void 0 && method !== "GET" && method !== "HEAD";
+	};
+	findAvailablePort = async () => {
+		const server = createServer();
+		await new Promise((resolve, reject) => {
+			server.once("error", reject);
+			server.listen(0, "127.0.0.1", () => {
+				server.off("error", reject);
+				resolve();
+			});
+		});
+		const address = server.address();
+		await new Promise((resolve, reject) => {
+			server.close((error) => {
+				if (error) {
+					reject(error);
+					return;
+				}
+				resolve();
+			});
+		});
+		if (!address || typeof address === "string") throw new Error("无法分配 WASI HTTP component 端口。");
+		return address.port;
+	};
+	waitUntilReady = async (url, child) => {
+		const errors = [];
+		child.stderr.on("data", (chunk) => {
+			errors.push(chunk.toString("utf-8"));
+		});
+		for (let attempt = 0; attempt < 50; attempt += 1) {
+			if (child.exitCode !== null) throw new Error(`WASI HTTP component 启动失败：${errors.join("").trim() || `exit ${child.exitCode}`}`);
+			try {
+				await fetch(url);
+				return;
+			} catch {
+				await new Promise((resolve) => setTimeout(resolve, 100));
+			}
+		}
+		throw new Error(`WASI HTTP component 启动超时：${errors.join("").trim()}`);
+	};
+};
+//#endregion
+export { WasmtimeWasiHttpComponentService };

package/dist/scaffold/app-scaffold.service.d.ts

@@ -1,10 +1,19 @@
+import { AppTsHttpScaffoldTemplateService } from "./app-ts-http-scaffold-template.service.js";
+
 //#region src/scaffold/app-scaffold.service.d.ts
+type AppScaffoldTemplate = "starter" | "ts-http";
 type AppScaffoldResult = {
   appDirectory: string;
   manifestPath: string;
+  template: AppScaffoldTemplate;
 };
 declare class AppScaffoldService {
-  scaffold: (targetDirectory: string) => Promise<AppScaffoldResult>;
+  private readonly tsHttpTemplateService;
+  constructor(tsHttpTemplateService?: AppTsHttpScaffoldTemplateService);
+  scaffold: (targetDirectory: string, options?: {
+    template?: AppScaffoldTemplate;
+  }) => Promise<AppScaffoldResult>;
+  private writeTemplateFiles;
   private assertTargetDoesNotExist;
   private buildAppId;
   private buildAppName;
@@ -18,4 +27,4 @@ declare class AppScaffoldService {
   private buildIconSvg;
 }
 //#endregion
-export { AppScaffoldService };
+export { AppScaffoldResult, AppScaffoldService, AppScaffoldTemplate };

package/dist/scaffold/app-scaffold.service.js

@@ -1,9 +1,14 @@
+import { AppTsHttpScaffoldTemplateService } from "./app-ts-http-scaffold-template.service.js";
 import { access, mkdir, writeFile } from "node:fs/promises";
 import path from "node:path";
 //#region src/scaffold/app-scaffold.service.ts
 var AppScaffoldService = class {
-	scaffold = async (targetDirectory) => {
+	constructor(tsHttpTemplateService = new AppTsHttpScaffoldTemplateService()) {
+		this.tsHttpTemplateService = tsHttpTemplateService;
+	}
+	scaffold = async (targetDirectory, options) => {
 		const appDirectory = path.resolve(targetDirectory);
+		const template = options?.template ?? "starter";
 		await this.assertTargetDoesNotExist(appDirectory);
 		await mkdir(path.join(appDirectory, "main"), { recursive: true });
 		await mkdir(path.join(appDirectory, "ui"), { recursive: true });
@@ -11,6 +16,17 @@ var AppScaffoldService = class {
 		const appName = this.buildAppName(appDirectory);
 		const appId = this.buildAppId(appDirectory);
 		const manifestPath = path.join(appDirectory, "manifest.json");
+		if (template === "ts-http") {
+			await this.writeTemplateFiles(appDirectory, this.tsHttpTemplateService.buildFiles({
+				appId,
+				appName
+			}));
+			return {
+				appDirectory,
+				manifestPath,
+				template
+			};
+		}
 		await Promise.all([
 			writeFile(manifestPath, `${JSON.stringify(this.buildManifest(appId, appName), null, 2)}\n`, "utf-8"),
 			writeFile(path.join(appDirectory, "marketplace.json"), `${JSON.stringify(this.buildMarketplaceMetadata(appName), null, 2)}\n`, "utf-8"),
@@ -23,9 +39,17 @@ var AppScaffoldService = class {
 		]);
 		return {
 			appDirectory,
-			manifestPath
+			manifestPath,
+			template
 		};
 	};
+	writeTemplateFiles = async (appDirectory, files) => {
+		await Promise.all(files.map(async (file) => {
+			const filePath = path.join(appDirectory, file.relativePath);
+			await mkdir(path.dirname(filePath), { recursive: true });
+			await writeFile(filePath, file.content);
+		}));
+	};
 	assertTargetDoesNotExist = async (targetDirectory) => {
 		try {
 			await access(targetDirectory);

package/dist/scaffold/app-ts-http-scaffold-template.service.d.ts

@@ -0,0 +1,25 @@
+//#region src/scaffold/app-ts-http-scaffold-template.service.d.ts
+type AppScaffoldFile = {
+  relativePath: string;
+  content: string | Buffer;
+};
+declare class AppTsHttpScaffoldTemplateService {
+  buildFiles: (params: {
+    appId: string;
+    appName: string;
+  }) => AppScaffoldFile[];
+  private buildManifest;
+  private buildMainPackageJson;
+  private buildTsconfig;
+  private buildMarketplaceMetadata;
+  private buildReadme;
+  private buildRolldownConfig;
+  private buildWitWorld;
+  private buildComponentSource;
+  private buildUiHtml;
+  private buildUiScript;
+  private buildIconSvg;
+  private normalizeSlug;
+}
+//#endregion
+export { AppScaffoldFile, AppTsHttpScaffoldTemplateService };