@nextclaw/app-runtime 0.4.0 → 0.5.0

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

@@ -3,6 +3,7 @@ import { AppBundleService } from "../bundle/app-bundle.service.js";
 import { AppPublishResult } from "./app-publish.types.js";
 import { AppMarketplaceClientService } from "./app-marketplace-client.service.js";
 import { AppMarketplaceMetadataService } from "./app-marketplace-metadata.service.js";
+import { PlatformAuthStateService } from "./platform-auth-state.service.js";
 
 //#region src/publish/app-publish.service.d.ts
 declare class AppPublishService {
@@ -10,13 +11,19 @@ declare class AppPublishService {
   private readonly bundleService;
   private readonly metadataService;
   private readonly marketplaceClient;
-  constructor(manifestService?: AppManifestService, bundleService?: AppBundleService, metadataService?: AppMarketplaceMetadataService, marketplaceClient?: AppMarketplaceClientService);
+  private readonly authStateService;
+  constructor(manifestService?: AppManifestService, bundleService?: AppBundleService, metadataService?: AppMarketplaceMetadataService, marketplaceClient?: AppMarketplaceClientService, authStateService?: PlatformAuthStateService);
   publish: (params: {
     appDirectory: string;
     metadataPath?: string;
     apiBaseUrl?: string;
     token?: string;
   }) => Promise<AppPublishResult>;
+  private resolvePublishActor;
+  private fetchCurrentPlatformUser;
+  private resolvePlatformApiBase;
+  private buildUserPublisher;
+  private buildOfficialPublisher;
 }
 //#endregion
 export { AppPublishService };

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

@@ -2,16 +2,19 @@ import { AppManifestService } from "../manifest/app-manifest.service.js";
 import { AppBundleService } from "../bundle/app-bundle.service.js";
 import { AppMarketplaceClientService } from "./app-marketplace-client.service.js";
 import { AppMarketplaceMetadataService } from "./app-marketplace-metadata.service.js";
+import { PlatformAuthStateService } from "./platform-auth-state.service.js";
 import { readFile } from "node:fs/promises";
 import { createHash } from "node:crypto";
 import path from "node:path";
 //#region src/publish/app-publish.service.ts
+const DEFAULT_PLATFORM_API_BASE = "https://ai-gateway-api.nextclaw.io";
 var AppPublishService = class {
-	constructor(manifestService = new AppManifestService(), bundleService = new AppBundleService(), metadataService = new AppMarketplaceMetadataService(), marketplaceClient = new AppMarketplaceClientService()) {
+	constructor(manifestService = new AppManifestService(), bundleService = new AppBundleService(), metadataService = new AppMarketplaceMetadataService(), marketplaceClient = new AppMarketplaceClientService(), authStateService = new PlatformAuthStateService()) {
 		this.manifestService = manifestService;
 		this.bundleService = bundleService;
 		this.metadataService = metadataService;
 		this.marketplaceClient = marketplaceClient;
+		this.authStateService = authStateService;
 	}
 	publish = async (params) => {
 		const { appDirectory: inputAppDirectory, metadataPath, apiBaseUrl, token } = params;
@@ -22,6 +25,11 @@ var AppPublishService = class {
 			manifest: manifestBundle.manifest,
 			metadataPath
 		});
+		const actor = await this.resolvePublishActor({
+			apiBaseUrl,
+			explicitToken: token,
+			appId: manifestBundle.manifest.id
+		});
 		const bundle = await this.bundleService.packAppDirectory({ appDirectory });
 		const bundleBytes = Buffer.from(await readFile(bundle.bundlePath));
 		const bundleSha256 = createHash("sha256").update(bundleBytes).digest("hex");
@@ -43,11 +51,7 @@ var AppPublishService = class {
 			sourceRepo: metadata.sourceRepo,
 			homepage: metadata.homepage,
 			featured: metadata.featured ?? false,
-			publisher: metadata.publisher ?? {
-				id: "nextclaw",
-				name: "NextClaw",
-				url: "https://nextclaw.io"
-			},
+			publisher: actor.publisher,
 			manifest: manifestBundle.manifest,
 			permissions: manifestBundle.manifest.permissions ?? {},
 			bundleBase64: bundleBytes.toString("base64"),
@@ -61,7 +65,7 @@ var AppPublishService = class {
 			...await this.marketplaceClient.publish({
 				payload,
 				apiBaseUrl,
-				token
+				token: actor.token
 			}),
 			bundle: {
 				path: bundle.bundlePath,
@@ -69,6 +73,82 @@ var AppPublishService = class {
 			}
 		};
 	};
+	resolvePublishActor = async (params) => {
+		const explicitToken = params.explicitToken?.trim();
+		const envAdminToken = process.env.NEXTCLAW_MARKETPLACE_ADMIN_TOKEN?.trim();
+		if (explicitToken) {
+			const token = explicitToken;
+			if (!token) throw new Error("缺少 publish token。");
+			const me = await this.fetchCurrentPlatformUser({
+				token,
+				platformApiBase: this.resolvePlatformApiBase()
+			});
+			return {
+				token,
+				publisher: this.buildUserPublisher(me, params.appId)
+			};
+		}
+		const authState = this.authStateService.readCurrentAuthState();
+		const platformToken = authState.token?.trim();
+		if (platformToken) {
+			const me = await this.fetchCurrentPlatformUser({
+				token: platformToken,
+				platformApiBase: this.resolvePlatformApiBase(authState.apiBaseUrl)
+			});
+			return {
+				token: platformToken,
+				publisher: this.buildUserPublisher(me, params.appId)
+			};
+		}
+		if (envAdminToken) return {
+			token: envAdminToken,
+			publisher: this.buildOfficialPublisher()
+		};
+		throw new Error("发布需要 NextClaw 平台登录态。请先运行 nextclaw login，或传入 --token。");
+	};
+	fetchCurrentPlatformUser = async (params) => {
+		const response = await fetch(`${params.platformApiBase}/platform/auth/me`, { headers: {
+			authorization: `Bearer ${params.token}`,
+			accept: "application/json"
+		} });
+		const payload = await response.json().catch(() => null);
+		if (!response.ok) {
+			const message = typeof payload === "object" && payload && "error" in payload && typeof payload.error?.message === "string" ? payload.error.message : `${response.status} ${response.statusText}`;
+			throw new Error(`读取 NextClaw 登录态失败：${message}`);
+		}
+		const user = typeof payload === "object" && payload && "data" in payload && typeof payload.data?.user === "object" && payload.data.user ? payload.data.user : null;
+		const id = typeof user?.id === "string" ? user.id.trim() : "";
+		const username = typeof user?.username === "string" ? user.username.trim() : "";
+		const role = user?.role === "admin" ? "admin" : "user";
+		if (!id) throw new Error("平台登录态缺少用户 id。");
+		return {
+			id,
+			username: username || null,
+			role
+		};
+	};
+	resolvePlatformApiBase = (configuredApiBase) => {
+		const source = configuredApiBase?.trim() || process.env.NEXTCLAW_PLATFORM_API_BASE?.trim() || DEFAULT_PLATFORM_API_BASE;
+		const normalized = new URL(source);
+		normalized.pathname = normalized.pathname.replace(/\/v1\/?$/, "/");
+		return normalized.toString().replace(/\/+$/, "");
+	};
+	buildUserPublisher = (user, appId) => {
+		if (appId.startsWith("nextclaw.") && user.role === "admin") return this.buildOfficialPublisher();
+		if (!user.username) throw new Error("当前 NextClaw 账号还没有 username，无法发布个人 scope app。请先在平台账号页设置用户名。");
+		return {
+			id: user.username,
+			name: user.username,
+			url: `https://platform.nextclaw.io/account`
+		};
+	};
+	buildOfficialPublisher = () => {
+		return {
+			id: "nextclaw",
+			name: "NextClaw",
+			url: "https://nextclaw.io"
+		};
+	};
 };
 //#endregion
 export { AppPublishService };

package/dist/publish/platform-auth-state.service.d.ts

@@ -0,0 +1,11 @@
+//#region src/publish/platform-auth-state.service.d.ts
+type PlatformPublishAuthState = {
+  token: string | null;
+  apiBaseUrl?: string;
+};
+declare class PlatformAuthStateService {
+  readCurrentAuthState: () => PlatformPublishAuthState;
+  private resolveConfigPath;
+}
+//#endregion
+export { PlatformAuthStateService, PlatformPublishAuthState };

package/dist/publish/platform-auth-state.service.js

@@ -0,0 +1,26 @@
+import { resolve } from "node:path";
+import { homedir } from "node:os";
+import { existsSync, readFileSync } from "node:fs";
+//#region src/publish/platform-auth-state.service.ts
+var PlatformAuthStateService = class {
+	readCurrentAuthState = () => {
+		const configPath = this.resolveConfigPath();
+		if (!existsSync(configPath)) return { token: null };
+		try {
+			const raw = readFileSync(configPath, "utf-8");
+			const provider = JSON.parse(raw).providers?.nextclaw;
+			return {
+				token: typeof provider?.apiKey === "string" && provider.apiKey.trim().length > 0 ? provider.apiKey.trim() : null,
+				apiBaseUrl: typeof provider?.apiBase === "string" && provider.apiBase.trim().length > 0 ? provider.apiBase.trim() : void 0
+			};
+		} catch {
+			return { token: null };
+		}
+	};
+	resolveConfigPath = () => {
+		const nextclawHome = process.env.NEXTCLAW_HOME?.trim();
+		return resolve(nextclawHome && nextclawHome.length > 0 ? resolve(nextclawHome) : resolve(homedir(), ".nextclaw"), "config.json");
+	};
+};
+//#endregion
+export { PlatformAuthStateService };

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,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);
@@ -216,12 +240,7 @@ var AppScaffoldService = class {
 			],
 			sourceRepo: "https://github.com/Peiiii/nextclaw",
 			homepage: "https://nextclaw.io",
-			featured: false,
-			publisher: {
-				id: "nextclaw",
-				name: "NextClaw",
-				url: "https://nextclaw.io"
-			}
+			featured: false
 		};
 	};
 	buildReadme = (appName, appId) => {