@nextclaw/app-runtime 0.4.1 → 0.6.0

package/dist/index.js

@@ -1,6 +1,9 @@
 import { AppManifestService } from "./manifest/app-manifest.service.js";
 import { AppBundleService } from "./bundle/app-bundle.service.js";
 import { HostBridgeServer } from "./bridge/host-bridge.service.js";
+import { AppTsHttpScaffoldTemplateService } from "./scaffold/app-ts-http-scaffold-template.service.js";
+import { AppTsHttpLiteScaffoldTemplateService } from "./scaffold/app-ts-http-lite-scaffold-template.service.js";
+import { AppScaffoldService } from "./scaffold/app-scaffold.service.js";
 import { CreateCommand } from "./commands/create.controller.js";
 import { UiServerService } from "./ui/ui-server.service.js";
 import { AppHostService } from "./host/app-host.service.js";
@@ -15,6 +18,7 @@ import { AppRegistryConfigService } from "./registry/app-registry-config.service
 import { AppRemoteRegistryClientService } from "./registry/app-remote-registry-client.service.js";
 import { AppRegistryService } from "./registry/app-registry.service.js";
 import { AppInstallationService } from "./install/app-installation.service.js";
+import { WasmtimeWasiHttpComponentService } from "./runtime/wasmtime-wasi-http-component.service.js";
 import { AppGrantService } from "./permissions/app-grant.service.js";
 import { GrantCommand } from "./commands/grant.controller.js";
 import { InfoCommand } from "./commands/info.controller.js";
@@ -32,6 +36,10 @@ import { RegistryCommand } from "./commands/registry.controller.js";
 import { RevokeCommand } from "./commands/revoke.controller.js";
 import { UninstallCommand } from "./commands/uninstall.controller.js";
 import { UpdateCommand } from "./commands/update.controller.js";
+import { AppPublishValidationService } from "./publish/app-publish-validation.service.js";
+import { ValidatePublishCommand } from "./commands/validate-publish.controller.js";
+import { AppRuntimeToolchainService } from "./runtime/app-runtime-toolchain.service.js";
+import { AppBuildService } from "./runtime/app-build.service.js";
 import { AppRuntimeOptionsService } from "./cli/app-runtime-options.service.js";
 import { AppRuntimeCliService } from "./cli/app-runtime-cli.service.js";
-export { AppBundleService, AppGrantService, AppHomeService, AppHostService, AppInstallationService, AppInstanceService, AppManifestService, AppMarketplaceClientService, AppMarketplaceMetadataService, AppPermissionsService, AppPublishService, AppRegistryConfigService, AppRegistryService, AppRemoteRegistryClientService, AppRuntimeCliService, AppRuntimeOptionsService, CreateCommand, DEFAULT_APP_MARKETPLACE_API_BASE, DEFAULT_APP_REGISTRY_URL, GrantCommand, HostBridgeServer, InfoCommand, InstallCommand, ListCommand, MainRunnerService, PackCommand, PermissionsCommand, PlatformAuthStateService, PublishCommand, RegistryCommand, RevokeCommand, UiServerService, UninstallCommand, UpdateCommand, WasmMainRunnerService, WasmSidecarClientService };
+export { AppBuildService, AppBundleService, AppGrantService, AppHomeService, AppHostService, AppInstallationService, AppInstanceService, AppManifestService, AppMarketplaceClientService, AppMarketplaceMetadataService, AppPermissionsService, AppPublishService, AppPublishValidationService, AppRegistryConfigService, AppRegistryService, AppRemoteRegistryClientService, AppRuntimeCliService, AppRuntimeOptionsService, AppRuntimeToolchainService, AppScaffoldService, AppTsHttpLiteScaffoldTemplateService, AppTsHttpScaffoldTemplateService, CreateCommand, DEFAULT_APP_MARKETPLACE_API_BASE, DEFAULT_APP_REGISTRY_URL, GrantCommand, HostBridgeServer, InfoCommand, InstallCommand, ListCommand, MainRunnerService, PackCommand, PermissionsCommand, PlatformAuthStateService, PublishCommand, RegistryCommand, RevokeCommand, UiServerService, UninstallCommand, UpdateCommand, ValidatePublishCommand, WasmMainRunnerService, WasmSidecarClientService, WasmtimeWasiHttpComponentService };

package/dist/install/app-installation.service.js

@@ -179,6 +179,7 @@ var AppInstallationService = class {
 		return {
 			appDirectory: activeVersion.installDirectory,
 			appId: appRecord.appId,
+			dataDirectory: appRecord.dataDirectory,
 			documentGrantMap: {
 				...appRecord.grants,
 				...explicitDocumentGrantMap

package/dist/install/app-installation.types.d.ts

@@ -52,6 +52,7 @@ type AppUninstallResult = {
 type AppLaunchResolution = {
   appDirectory: string;
   appId?: string;
+  dataDirectory?: string;
   documentGrantMap: AppDocumentGrantMap;
 };
 type AppUpdateResult = AppInstallResult & {

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

@@ -27,7 +27,8 @@ var AppManifestService = class {
 			name: bundle.manifest.name,
 			version: bundle.manifest.version,
 			description: bundle.manifest.description,
-			action: bundle.manifest.main.action,
+			mainKind: bundle.manifest.main.kind,
+			action: bundle.manifest.main.kind === "wasm" ? bundle.manifest.main.action : void 0,
 			manifestPath: bundle.manifestPath,
 			mainEntryPath: bundle.mainEntryPath,
 			uiEntryPath: bundle.uiEntryPath,
@@ -54,13 +55,18 @@ var AppManifestService = class {
 	};
 	parseMain = (rawMain) => {
 		const candidate = this.assertObject(rawMain, "main");
-		if (this.readRequiredString(candidate.kind, "main.kind") !== "wasm") throw new Error("当前 main.kind 只支持 wasm。");
-		return {
+		const kind = this.readRequiredString(candidate.kind, "main.kind");
+		if (kind === "wasm") return {
 			kind: "wasm",
 			entry: this.readRequiredString(candidate.entry, "main.entry"),
 			export: this.readRequiredString(candidate.export, "main.export"),
 			action: this.readRequiredString(candidate.action, "main.action")
 		};
+		if (kind === "wasi-http-component") return {
+			kind: "wasi-http-component",
+			entry: this.readRequiredString(candidate.entry, "main.entry")
+		};
+		throw new Error("当前 main.kind 只支持 wasm 或 wasi-http-component。");
 	};
 	parseUi = (rawUi) => {
 		const candidate = this.assertObject(rawUi, "ui");

package/dist/manifest/app-manifest.types.d.ts

@@ -15,12 +15,17 @@ type AppPermissions = {
     hostBridge?: boolean;
   };
 };
-type AppMainManifest = {
+type AppCoreWasmMainManifest = {
   kind: "wasm";
   entry: string;
   export: string;
   action: string;
 };
+type AppWasiHttpComponentMainManifest = {
+  kind: "wasi-http-component";
+  entry: string;
+};
+type AppMainManifest = AppCoreWasmMainManifest | AppWasiHttpComponentMainManifest;
 type AppUiManifest = {
   entry: string;
 };
@@ -50,7 +55,8 @@ type AppManifestSummary = {
   name: string;
   version: string;
   description?: string;
-  action: string;
+  mainKind: AppMainManifest["kind"];
+  action?: string;
   manifestPath: string;
   mainEntryPath: string;
   uiEntryPath: string;
@@ -58,4 +64,4 @@ type AppManifestSummary = {
   permissions: AppPermissions;
 };
 //#endregion
-export { AppDocumentAccessMode, AppDocumentAccessScope, AppMainManifest, AppManifest, AppManifestBundle, AppManifestSummary, AppPermissions, AppUiManifest };
+export { AppCoreWasmMainManifest, AppDocumentAccessMode, AppDocumentAccessScope, AppMainManifest, AppManifest, AppManifestBundle, AppManifestSummary, AppPermissions, AppUiManifest, AppWasiHttpComponentMainManifest };

package/dist/package.js

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.4.1";
+var version = "0.6.0";
 //#endregion
 export { version };

package/dist/publish/app-publish-validation.service.d.ts

@@ -0,0 +1,37 @@
+import { AppManifestService } from "../manifest/app-manifest.service.js";
+import { AppBundleService } from "../bundle/app-bundle.service.js";
+import { AppMarketplaceMetadataService } from "./app-marketplace-metadata.service.js";
+
+//#region src/publish/app-publish-validation.service.d.ts
+type AppPublishValidationWarningCode = "main-entry-large" | "bundle-large";
+type AppPublishValidationWarning = {
+  code: AppPublishValidationWarningCode;
+  message: string;
+};
+type AppPublishValidationResult = {
+  ok: boolean;
+  appDirectory: string;
+  metadataPath: string;
+  appId: string;
+  version: string;
+  mainKind: string;
+  mainEntryPath: string;
+  mainEntrySizeBytes: number;
+  bundleSizeBytes: number;
+  bundleFilePaths: string[];
+  warnings: AppPublishValidationWarning[];
+};
+declare class AppPublishValidationService {
+  private readonly manifestService;
+  private readonly metadataService;
+  private readonly bundleService;
+  constructor(manifestService?: AppManifestService, metadataService?: AppMarketplaceMetadataService, bundleService?: AppBundleService);
+  validate: (params: {
+    appDirectory: string;
+    metadataPath?: string;
+  }) => Promise<AppPublishValidationResult>;
+  private buildWarnings;
+  private formatBytes;
+}
+//#endregion
+export { AppPublishValidationResult, AppPublishValidationService, AppPublishValidationWarning, AppPublishValidationWarningCode };

package/dist/publish/app-publish-validation.service.js

@@ -0,0 +1,76 @@
+import { AppManifestService } from "../manifest/app-manifest.service.js";
+import { AppBundleService } from "../bundle/app-bundle.service.js";
+import { AppMarketplaceMetadataService } from "./app-marketplace-metadata.service.js";
+import { mkdtemp, rm, stat } from "node:fs/promises";
+import path from "node:path";
+import { tmpdir } from "node:os";
+//#region src/publish/app-publish-validation.service.ts
+const MAIN_ENTRY_WARN_BYTES = 10 * 1024 * 1024;
+const BUNDLE_WARN_BYTES = 5 * 1024 * 1024;
+var AppPublishValidationService = class {
+	constructor(manifestService = new AppManifestService(), metadataService = new AppMarketplaceMetadataService(), bundleService = new AppBundleService()) {
+		this.manifestService = manifestService;
+		this.metadataService = metadataService;
+		this.bundleService = bundleService;
+	}
+	validate = async (params) => {
+		const appDirectory = path.resolve(params.appDirectory);
+		const bundle = await this.manifestService.load(appDirectory);
+		const metadataPath = params.metadataPath ? path.resolve(params.metadataPath) : path.join(appDirectory, "marketplace.json");
+		await this.metadataService.load({
+			appDirectory,
+			manifest: bundle.manifest,
+			metadataPath
+		});
+		const tempDirectory = await mkdtemp(path.join(tmpdir(), "napp-validate-publish-"));
+		try {
+			const packResult = await this.bundleService.packAppDirectory({
+				appDirectory,
+				outputPath: path.join(tempDirectory, `${bundle.manifest.id}-${bundle.manifest.version}.napp`)
+			});
+			const mainEntryStats = await stat(bundle.mainEntryPath);
+			const warnings = this.buildWarnings({
+				mainEntrySizeBytes: mainEntryStats.size,
+				bundleSizeBytes: packResult.sizeBytes
+			});
+			return {
+				ok: true,
+				appDirectory,
+				metadataPath,
+				appId: bundle.manifest.id,
+				version: bundle.manifest.version,
+				mainKind: bundle.manifest.main.kind,
+				mainEntryPath: bundle.mainEntryPath,
+				mainEntrySizeBytes: mainEntryStats.size,
+				bundleSizeBytes: packResult.sizeBytes,
+				bundleFilePaths: packResult.filePaths,
+				warnings
+			};
+		} finally {
+			await rm(tempDirectory, {
+				recursive: true,
+				force: true
+			});
+		}
+	};
+	buildWarnings = (params) => {
+		const { bundleSizeBytes, mainEntrySizeBytes } = params;
+		const warnings = [];
+		if (mainEntrySizeBytes > MAIN_ENTRY_WARN_BYTES) warnings.push({
+			code: "main-entry-large",
+			message: `main entry is ${this.formatBytes(mainEntrySizeBytes)}, which is larger than the ${this.formatBytes(MAIN_ENTRY_WARN_BYTES)} warning threshold.`
+		});
+		if (bundleSizeBytes > BUNDLE_WARN_BYTES) warnings.push({
+			code: "bundle-large",
+			message: `packed .napp is ${this.formatBytes(bundleSizeBytes)}, which is larger than the ${this.formatBytes(BUNDLE_WARN_BYTES)} warning threshold.`
+		});
+		return warnings;
+	};
+	formatBytes = (value) => {
+		if (value < 1024) return `${value} B`;
+		if (value < 1024 * 1024) return `${(value / 1024).toFixed(1)} KB`;
+		return `${(value / (1024 * 1024)).toFixed(1)} MB`;
+	};
+};
+//#endregion
+export { AppPublishValidationService };

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

@@ -0,0 +1,24 @@
+import { AppManifestService } from "../manifest/app-manifest.service.js";
+import { AppRuntimeToolchainService } from "./app-runtime-toolchain.service.js";
+
+//#region src/runtime/app-build.service.d.ts
+type AppBuildResult = {
+  appDirectory: string;
+  mainKind: string;
+  mainEntryPath: string;
+  installedDependencies: boolean;
+  built: boolean;
+  skippedReason?: string;
+};
+declare class AppBuildService {
+  private readonly manifestService;
+  private readonly toolchainService;
+  constructor(manifestService?: AppManifestService, toolchainService?: AppRuntimeToolchainService);
+  build: (params: {
+    appDirectory: string;
+    install: boolean;
+  }) => Promise<AppBuildResult>;
+  private pathExists;
+}
+//#endregion
+export { AppBuildResult, AppBuildService };

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