@nextclaw/app-runtime 0.2.0 → 0.4.0

package/dist/main.js

@@ -1,136 +1,9 @@
 #!/usr/bin/env node
-import { version } from "./package.js";
-import { CreateCommand } from "./commands/create.controller.js";
-import { RunCommand } from "./commands/run.controller.js";
-import { DevCommand } from "./commands/dev.controller.js";
-import { InspectCommand } from "./commands/inspect.controller.js";
+import { AppRuntimeCliService } from "./cli/app-runtime-cli.service.js";
 //#region src/main.ts
-var AppRuntimeCli = class {
-	run = async () => {
-		const [command, appDirectory, ...restArgs] = process.argv.slice(2);
-		if (command === "--help" || command === "help") {
-			this.writeUsage();
-			return;
-		}
-		if (command === "--version" || command === "version") {
-			this.write(`${version}\n`);
-			return;
-		}
-		if (!command || !appDirectory) {
-			this.writeUsage();
-			process.exit(1);
-		}
-		if (command === "create") {
-			const options = this.readCreateOptions(restArgs);
-			await new CreateCommand().run({
-				appDirectory,
-				json: options.json,
-				write: this.write
-			});
-			return;
-		}
-		const options = this.readRuntimeOptions(restArgs);
-		if (command === "inspect") {
-			await new InspectCommand().run({
-				appDirectory,
-				json: options.json,
-				write: this.write
-			});
-			return;
-		}
-		if (command === "run") {
-			await new RunCommand().run({
-				appDirectory,
-				host: options.host,
-				port: options.port,
-				json: options.json,
-				documentGrantMap: options.documentGrantMap,
-				write: this.write
-			});
-			return;
-		}
-		if (command === "dev") {
-			await new DevCommand().run({
-				appDirectory,
-				host: options.host,
-				port: options.port,
-				json: options.json,
-				documentGrantMap: options.documentGrantMap,
-				write: this.write
-			});
-			return;
-		}
-		this.writeUsage();
-		process.exit(1);
-	};
-	readCreateOptions = (rawArgs) => {
-		const options = { json: false };
-		for (const current of rawArgs) {
-			if (!current?.startsWith("--")) throw new Error(`未知参数：${current}`);
-			switch (current) {
-				case "--json":
-					options.json = true;
-					break;
-				default: throw new Error(`未知参数：${current}`);
-			}
-		}
-		return options;
-	};
-	readRuntimeOptions = (rawArgs) => {
-		const options = {
-			host: "127.0.0.1",
-			port: 3100,
-			json: false,
-			documentGrantMap: {}
-		};
-		for (let index = 0; index < rawArgs.length; index += 1) {
-			const current = rawArgs[index];
-			if (!current?.startsWith("--")) throw new Error(`未知参数：${current}`);
-			const nextValue = rawArgs[index + 1];
-			switch (current) {
-				case "--host":
-					options.host = this.requireOptionValue(current, nextValue);
-					index += 1;
-					break;
-				case "--port":
-					options.port = Number.parseInt(this.requireOptionValue(current, nextValue), 10);
-					if (Number.isNaN(options.port) || options.port < 0) throw new Error("--port 必须是非负整数。");
-					index += 1;
-					break;
-				case "--json":
-					options.json = true;
-					break;
-				case "--document":
-					this.assignDocumentGrant(options.documentGrantMap, this.requireOptionValue(current, nextValue));
-					index += 1;
-					break;
-				default: throw new Error(`未知参数：${current}`);
-			}
-		}
-		return options;
-	};
-	assignDocumentGrant = (documentGrantMap, rawGrant) => {
-		const delimiterIndex = rawGrant.indexOf("=");
-		if (delimiterIndex < 1) throw new Error("--document 必须使用 scopeId=/absolute/or/relative/path 格式。");
-		const scopeId = rawGrant.slice(0, delimiterIndex).trim();
-		const directoryPath = rawGrant.slice(delimiterIndex + 1).trim();
-		if (!scopeId || !directoryPath) throw new Error("--document 缺少 scopeId 或 path。");
-		documentGrantMap[scopeId] = directoryPath;
-	};
-	requireOptionValue = (flag, nextValue) => {
-		if (!nextValue || nextValue.startsWith("--")) throw new Error(`${flag} 缺少值。`);
-		return nextValue;
-	};
-	writeUsage = () => {
-		this.write("Usage: napp create <app-dir> [--json]\n");
-		this.write("       napp <inspect|run|dev> <app-dir> [--host 127.0.0.1] [--port 3100] [--json] [--document scope=/path]\n");
-		this.write("       napp --help\n");
-		this.write("       napp --version\n");
-	};
-	write = (text) => {
-		process.stdout.write(text);
-	};
-};
-new AppRuntimeCli().run();
+new AppRuntimeCliService().run().catch((error) => {
+	process.stderr.write(`${error instanceof Error ? error.message : String(error)}\n`);
+	process.exit(1);
+});
 //#endregion
 export {};

package/dist/package.js

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

package/dist/paths/app-home.service.d.ts

@@ -0,0 +1,16 @@
+//#region src/paths/app-home.service.d.ts
+declare class AppHomeService {
+  private readonly appHomeDirectory;
+  constructor(appHomeDirectory?: string);
+  getAppHomeDirectory: () => string;
+  getPackagesDirectory: () => string;
+  getDataDirectory: () => string;
+  getRegistryPath: () => string;
+  getConfigPath: () => string;
+  getInstallDirectory: (appId: string, version: string) => string;
+  getAppDataDirectory: (appId: string) => string;
+  ensureBaseDirectories: () => Promise<void>;
+  createTemporaryDirectory: (prefix: string) => Promise<string>;
+}
+//#endregion
+export { AppHomeService };

package/dist/paths/app-home.service.js

@@ -0,0 +1,42 @@
+import { mkdir, mkdtemp } from "node:fs/promises";
+import path from "node:path";
+import { tmpdir } from "node:os";
+//#region src/paths/app-home.service.ts
+var AppHomeService = class {
+	constructor(appHomeDirectory = process.env.NEXTCLAW_APP_HOME ? path.resolve(process.env.NEXTCLAW_APP_HOME) : path.join(process.env.HOME ?? process.cwd(), ".nextclaw", "apps")) {
+		this.appHomeDirectory = appHomeDirectory;
+	}
+	getAppHomeDirectory = () => {
+		return this.appHomeDirectory;
+	};
+	getPackagesDirectory = () => {
+		return path.join(this.appHomeDirectory, "packages");
+	};
+	getDataDirectory = () => {
+		return path.join(this.appHomeDirectory, "data");
+	};
+	getRegistryPath = () => {
+		return path.join(this.appHomeDirectory, "registry.json");
+	};
+	getConfigPath = () => {
+		return path.join(this.appHomeDirectory, "config.json");
+	};
+	getInstallDirectory = (appId, version) => {
+		return path.join(this.getPackagesDirectory(), appId, version);
+	};
+	getAppDataDirectory = (appId) => {
+		return path.join(this.getDataDirectory(), appId);
+	};
+	ensureBaseDirectories = async () => {
+		await Promise.all([
+			mkdir(this.appHomeDirectory, { recursive: true }),
+			mkdir(this.getPackagesDirectory(), { recursive: true }),
+			mkdir(this.getDataDirectory(), { recursive: true })
+		]);
+	};
+	createTemporaryDirectory = async (prefix) => {
+		return mkdtemp(path.join(tmpdir(), prefix));
+	};
+};
+//#endregion
+export { AppHomeService };

package/dist/permissions/app-grant.service.d.ts

@@ -0,0 +1,22 @@
+import { AppManifestService } from "../manifest/app-manifest.service.js";
+import { AppDocumentGrantMutationResult, AppInstalledPermissionState } from "./app-permissions.types.js";
+import { AppRegistryService } from "../registry/app-registry.service.js";
+
+//#region src/permissions/app-grant.service.d.ts
+declare class AppGrantService {
+  private readonly registryService;
+  private readonly manifestService;
+  constructor(registryService?: AppRegistryService, manifestService?: AppManifestService);
+  summarize: (appId: string) => Promise<AppInstalledPermissionState>;
+  grantDocumentScope: (params: {
+    appId: string;
+    scopeId: string;
+    directoryPath: string;
+  }) => Promise<AppDocumentGrantMutationResult>;
+  revokeDocumentScope: (params: {
+    appId: string;
+    scopeId: string;
+  }) => Promise<AppDocumentGrantMutationResult>;
+}
+//#endregion
+export { AppGrantService };

package/dist/permissions/app-grant.service.js

@@ -0,0 +1,63 @@
+import { AppManifestService } from "../manifest/app-manifest.service.js";
+import { AppRegistryService } from "../registry/app-registry.service.js";
+import { access } from "node:fs/promises";
+import path from "node:path";
+//#region src/permissions/app-grant.service.ts
+var AppGrantService = class {
+	constructor(registryService = new AppRegistryService(), manifestService = new AppManifestService()) {
+		this.registryService = registryService;
+		this.manifestService = manifestService;
+	}
+	summarize = async (appId) => {
+		const appRecord = await this.registryService.getApp(appId);
+		if (!appRecord) throw new Error(`未找到已安装应用：${appId}`);
+		const activeVersion = appRecord.installedVersions[appRecord.activeVersion];
+		if (!activeVersion) throw new Error(`已安装应用缺少激活版本：${appId}`);
+		const requestedPermissions = (await this.manifestService.load(activeVersion.installDirectory)).manifest.permissions ?? {};
+		return {
+			appId: appRecord.appId,
+			name: appRecord.name,
+			activeVersion: appRecord.activeVersion,
+			documentAccess: (requestedPermissions.documentAccess ?? []).map((scope) => ({
+				id: scope.id,
+				mode: scope.mode,
+				description: scope.description,
+				granted: Boolean(appRecord.grants[scope.id]),
+				grantedPath: appRecord.grants[scope.id]
+			})),
+			allowedDomains: requestedPermissions.allowedDomains ?? [],
+			storage: {
+				enabled: requestedPermissions.storage !== void 0 && requestedPermissions.storage !== false,
+				namespace: typeof requestedPermissions.storage === "object" ? requestedPermissions.storage.namespace : void 0
+			},
+			capabilities: { hostBridge: requestedPermissions.capabilities?.hostBridge !== false }
+		};
+	};
+	grantDocumentScope = async (params) => {
+		const { appId, scopeId, directoryPath } = params;
+		if (!(await this.summarize(appId)).documentAccess.find((scope) => scope.id === scopeId)) throw new Error(`应用 ${appId} 未声明 documentAccess scope：${scopeId}`);
+		const normalizedDirectory = path.resolve(directoryPath);
+		try {
+			await access(normalizedDirectory);
+		} catch {
+			throw new Error(`授权目录不存在：${normalizedDirectory}`);
+		}
+		await this.registryService.setDocumentGrant(appId, scopeId, normalizedDirectory);
+		return {
+			appId,
+			scopeId,
+			grantedPath: normalizedDirectory
+		};
+	};
+	revokeDocumentScope = async (params) => {
+		const { appId, scopeId } = params;
+		await this.summarize(appId);
+		return {
+			appId,
+			scopeId,
+			removed: await this.registryService.removeDocumentGrant(appId, scopeId)
+		};
+	};
+};
+//#endregion
+export { AppGrantService };

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

@@ -3,7 +3,9 @@ import { AppDocumentGrantMap, AppPermissionSummary, ResolvedPermissions } from "
 
 //#region src/permissions/app-permissions.service.d.ts
 declare class AppPermissionsService {
-  resolve: (bundle: AppManifestBundle, documentGrantMap: AppDocumentGrantMap) => Promise<ResolvedPermissions>;
+  resolve: (bundle: AppManifestBundle, documentGrantMap: AppDocumentGrantMap, context?: {
+    appId?: string;
+  }) => Promise<ResolvedPermissions>;
   summarize: (bundle: AppManifestBundle, permissions: ResolvedPermissions) => AppPermissionSummary;
   private resolveDocumentGrant;
 }

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

@@ -2,10 +2,10 @@ import { access } from "node:fs/promises";
 import path from "node:path";
 //#region src/permissions/app-permissions.service.ts
 var AppPermissionsService = class {
-	resolve = async (bundle, documentGrantMap) => {
+	resolve = async (bundle, documentGrantMap, context) => {
 		const requestedPermissions = bundle.manifest.permissions ?? {};
 		return {
-			documentAccess: requestedPermissions.documentAccess === void 0 ? [] : await Promise.all(requestedPermissions.documentAccess.map((scope) => this.resolveDocumentGrant(scope, documentGrantMap))),
+			documentAccess: requestedPermissions.documentAccess === void 0 ? [] : await Promise.all(requestedPermissions.documentAccess.map((scope) => this.resolveDocumentGrant(scope, documentGrantMap, context?.appId))),
 			allowedDomains: requestedPermissions.allowedDomains ?? [],
 			storage: {
 				enabled: requestedPermissions.storage !== void 0 && requestedPermissions.storage !== false,
@@ -23,11 +23,18 @@ var AppPermissionsService = class {
 			capabilities: permissions.capabilities
 		};
 	};
-	resolveDocumentGrant = async (scope, documentGrantMap) => {
+	resolveDocumentGrant = async (scope, documentGrantMap, appId) => {
 		const grantedPath = documentGrantMap[scope.id];
-		if (!grantedPath) throw new Error(`缺少 documentAccess 授权：${scope.id}`);
+		if (!grantedPath) {
+			if (appId) throw new Error(`缺少 documentAccess 授权：${scope.id}。请先执行 napp grant ${appId} --document ${scope.id}=/absolute/path`);
+			throw new Error(`缺少 documentAccess 授权：${scope.id}。请通过 --document ${scope.id}=/absolute/path 提供授权。`);
+		}
 		const normalizedPath = path.resolve(grantedPath);
-		await access(normalizedPath);
+		try {
+			await access(normalizedPath);
+		} catch {
+			throw new Error(`documentAccess 授权路径不存在：${scope.id} -> ${normalizedPath}`);
+		}
 		return {
 			id: scope.id,
 			mode: scope.mode,

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

@@ -22,5 +22,32 @@ type ResolvedPermissions = {
 type AppPermissionSummary = Pick<ResolvedPermissions, "documentAccess" | "allowedDomains" | "storage" | "capabilities"> & {
   requested: AppPermissions;
 };
+type AppDocumentGrantState = {
+  id: string;
+  mode: "read" | "read-write";
+  description?: string;
+  granted: boolean;
+  grantedPath?: string;
+};
+type AppInstalledPermissionState = {
+  appId: string;
+  name: string;
+  activeVersion: string;
+  documentAccess: AppDocumentGrantState[];
+  allowedDomains: string[];
+  storage: {
+    enabled: boolean;
+    namespace?: string;
+  };
+  capabilities: {
+    hostBridge: boolean;
+  };
+};
+type AppDocumentGrantMutationResult = {
+  appId: string;
+  scopeId: string;
+  grantedPath?: string;
+  removed?: boolean;
+};
 //#endregion
-export { AppDocumentGrantMap, AppPermissionSummary, ResolvedDocumentGrant, ResolvedPermissions };
+export { AppDocumentGrantMap, AppDocumentGrantMutationResult, AppDocumentGrantState, AppInstalledPermissionState, AppPermissionSummary, ResolvedDocumentGrant, ResolvedPermissions };

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

@@ -0,0 +1,13 @@
+import { AppPublishPayload, AppPublishResult } from "./app-publish.types.js";
+
+//#region src/publish/app-marketplace-client.service.d.ts
+declare class AppMarketplaceClientService {
+  publish: (params: {
+    payload: AppPublishPayload;
+    apiBaseUrl?: string;
+    token?: string;
+  }) => Promise<AppPublishResult>;
+  private normalizeApiBase;
+}
+//#endregion
+export { AppMarketplaceClientService };

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

@@ -0,0 +1,31 @@
+import "./app-publish.types.js";
+//#region src/publish/app-marketplace-client.service.ts
+var AppMarketplaceClientService = class {
+	publish = async (params) => {
+		const apiBaseUrl = this.normalizeApiBase(params.apiBaseUrl ?? "https://apps-registry.nextclaw.io");
+		const token = params.token?.trim() || process.env.NEXTCLAW_MARKETPLACE_ADMIN_TOKEN?.trim();
+		if (!token) throw new Error("缺少 marketplace admin token，请传 --token 或设置 NEXTCLAW_MARKETPLACE_ADMIN_TOKEN。");
+		const response = await fetch(`${apiBaseUrl}/api/v1/apps/publish`, {
+			method: "POST",
+			headers: {
+				"content-type": "application/json",
+				authorization: `Bearer ${token}`,
+				accept: "application/json"
+			},
+			body: JSON.stringify(params.payload)
+		});
+		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(`发布 app 失败：${message}`);
+		}
+		const data = typeof payload === "object" && payload && "data" in payload && typeof payload.data === "object" ? payload.data : null;
+		if (!data) throw new Error("marketplace publish 返回格式无效。");
+		return data;
+	};
+	normalizeApiBase = (apiBaseUrl) => {
+		return new URL(apiBaseUrl).toString().replace(/\/+$/, "");
+	};
+};
+//#endregion
+export { AppMarketplaceClientService };

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

@@ -0,0 +1,27 @@
+import { AppManifest } from "../manifest/app-manifest.types.js";
+import { AppMarketplaceMetadata } from "./app-publish.types.js";
+
+//#region src/publish/app-marketplace-metadata.service.d.ts
+declare class AppMarketplaceMetadataService {
+  load: (params: {
+    appDirectory: string;
+    manifest: AppManifest;
+    metadataPath?: string;
+  }) => Promise<AppMarketplaceMetadata>;
+  collectPublishFiles: (params: {
+    appDirectory: string;
+    metadataPath?: string;
+  }) => Promise<Array<{
+    path: string;
+    bytes: Buffer;
+  }>>;
+  private parseMetadata;
+  private parsePublisher;
+  private readRequiredString;
+  private readOptionalString;
+  private readStringArray;
+  private readOptionalBoolean;
+  private readLocalizedTextMap;
+}
+//#endregion
+export { AppMarketplaceMetadataService };

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

@@ -0,0 +1,84 @@
+import { readFile } from "node:fs/promises";
+import path from "node:path";
+import { existsSync } from "node:fs";
+//#region src/publish/app-marketplace-metadata.service.ts
+var AppMarketplaceMetadataService = class {
+	load = async (params) => {
+		const { appDirectory, manifest, metadataPath: customMetadataPath } = params;
+		const metadataPath = customMetadataPath ? path.resolve(customMetadataPath) : path.join(path.resolve(appDirectory), "marketplace.json");
+		const raw = JSON.parse(await readFile(metadataPath, "utf-8"));
+		return this.parseMetadata(raw, manifest);
+	};
+	collectPublishFiles = async (params) => {
+		const appDirectory = path.resolve(params.appDirectory);
+		const publishFiles = [];
+		const metadataPath = params.metadataPath ? path.resolve(params.metadataPath) : path.join(appDirectory, "marketplace.json");
+		publishFiles.push({
+			path: "marketplace.json",
+			bytes: Buffer.from(await readFile(metadataPath))
+		});
+		const readmePath = path.join(appDirectory, "README.md");
+		if (existsSync(readmePath)) publishFiles.push({
+			path: "README.md",
+			bytes: Buffer.from(await readFile(readmePath))
+		});
+		return publishFiles;
+	};
+	parseMetadata = (rawMetadata, manifest) => {
+		if (!rawMetadata || typeof rawMetadata !== "object" || Array.isArray(rawMetadata)) throw new Error("marketplace.json 必须是对象。");
+		const candidate = rawMetadata;
+		const slug = this.readRequiredString(candidate.slug, "slug");
+		const summary = this.readRequiredString(candidate.summary, "summary");
+		const description = this.readOptionalString(candidate.description, "description");
+		const author = this.readOptionalString(candidate.author, "author") ?? manifest.name;
+		const publisher = this.parsePublisher(candidate.publisher);
+		return {
+			slug,
+			summary,
+			summaryI18n: this.readLocalizedTextMap(candidate.summaryI18n, "summaryI18n", summary),
+			description,
+			descriptionI18n: description ? this.readLocalizedTextMap(candidate.descriptionI18n, "descriptionI18n", description) : void 0,
+			author,
+			tags: this.readStringArray(candidate.tags, "tags"),
+			sourceRepo: this.readOptionalString(candidate.sourceRepo, "sourceRepo"),
+			homepage: this.readOptionalString(candidate.homepage, "homepage"),
+			featured: this.readOptionalBoolean(candidate.featured, "featured") ?? false,
+			publisher
+		};
+	};
+	parsePublisher = (rawPublisher) => {
+		if (rawPublisher === void 0) return;
+		if (!rawPublisher || typeof rawPublisher !== "object" || Array.isArray(rawPublisher)) throw new Error("publisher 必须是对象。");
+		const candidate = rawPublisher;
+		return {
+			id: this.readRequiredString(candidate.id, "publisher.id"),
+			name: this.readRequiredString(candidate.name, "publisher.name"),
+			url: this.readOptionalString(candidate.url, "publisher.url")
+		};
+	};
+	readRequiredString = (value, fieldName) => {
+		if (typeof value !== "string" || !value.trim()) throw new Error(`${fieldName} 必须是非空字符串。`);
+		return value.trim();
+	};
+	readOptionalString = (value, fieldName) => {
+		if (value === void 0) return;
+		return this.readRequiredString(value, fieldName);
+	};
+	readStringArray = (value, fieldName) => {
+		if (!Array.isArray(value) || value.length === 0) throw new Error(`${fieldName} 必须是非空字符串数组。`);
+		return value.map((item, index) => this.readRequiredString(item, `${fieldName}[${index}]`));
+	};
+	readOptionalBoolean = (value, fieldName) => {
+		if (value === void 0) return;
+		if (typeof value !== "boolean") throw new Error(`${fieldName} 必须是布尔值。`);
+		return value;
+	};
+	readLocalizedTextMap = (value, fieldName, fallbackEn) => {
+		if (!value || typeof value !== "object" || Array.isArray(value)) throw new Error(`${fieldName} 必须是对象。`);
+		const normalized = Object.fromEntries(Object.entries(value).map(([locale, localeValue]) => [locale, this.readRequiredString(localeValue, `${fieldName}.${locale}`)]));
+		if (!normalized.en) normalized.en = fallbackEn;
+		return normalized;
+	};
+};
+//#endregion
+export { AppMarketplaceMetadataService };

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

@@ -0,0 +1,22 @@
+import { AppManifestService } from "../manifest/app-manifest.service.js";
+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";
+
+//#region src/publish/app-publish.service.d.ts
+declare class AppPublishService {
+  private readonly manifestService;
+  private readonly bundleService;
+  private readonly metadataService;
+  private readonly marketplaceClient;
+  constructor(manifestService?: AppManifestService, bundleService?: AppBundleService, metadataService?: AppMarketplaceMetadataService, marketplaceClient?: AppMarketplaceClientService);
+  publish: (params: {
+    appDirectory: string;
+    metadataPath?: string;
+    apiBaseUrl?: string;
+    token?: string;
+  }) => Promise<AppPublishResult>;
+}
+//#endregion
+export { AppPublishService };

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

@@ -0,0 +1,74 @@
+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 { readFile } from "node:fs/promises";
+import { createHash } from "node:crypto";
+import path from "node:path";
+//#region src/publish/app-publish.service.ts
+var AppPublishService = class {
+	constructor(manifestService = new AppManifestService(), bundleService = new AppBundleService(), metadataService = new AppMarketplaceMetadataService(), marketplaceClient = new AppMarketplaceClientService()) {
+		this.manifestService = manifestService;
+		this.bundleService = bundleService;
+		this.metadataService = metadataService;
+		this.marketplaceClient = marketplaceClient;
+	}
+	publish = async (params) => {
+		const { appDirectory: inputAppDirectory, metadataPath, apiBaseUrl, token } = params;
+		const appDirectory = path.resolve(inputAppDirectory);
+		const manifestBundle = await this.manifestService.load(appDirectory);
+		const metadata = await this.metadataService.load({
+			appDirectory,
+			manifest: manifestBundle.manifest,
+			metadataPath
+		});
+		const bundle = await this.bundleService.packAppDirectory({ appDirectory });
+		const bundleBytes = Buffer.from(await readFile(bundle.bundlePath));
+		const bundleSha256 = createHash("sha256").update(bundleBytes).digest("hex");
+		const publishFiles = await this.metadataService.collectPublishFiles({
+			appDirectory,
+			metadataPath
+		});
+		const payload = {
+			slug: metadata.slug,
+			appId: manifestBundle.manifest.id,
+			name: manifestBundle.manifest.name,
+			version: manifestBundle.manifest.version,
+			summary: metadata.summary,
+			summaryI18n: metadata.summaryI18n,
+			description: metadata.description ?? manifestBundle.manifest.description,
+			descriptionI18n: metadata.descriptionI18n,
+			author: metadata.author,
+			tags: metadata.tags,
+			sourceRepo: metadata.sourceRepo,
+			homepage: metadata.homepage,
+			featured: metadata.featured ?? false,
+			publisher: metadata.publisher ?? {
+				id: "nextclaw",
+				name: "NextClaw",
+				url: "https://nextclaw.io"
+			},
+			manifest: manifestBundle.manifest,
+			permissions: manifestBundle.manifest.permissions ?? {},
+			bundleBase64: bundleBytes.toString("base64"),
+			bundleSha256,
+			files: publishFiles.map((file) => ({
+				path: file.path,
+				contentBase64: file.bytes.toString("base64")
+			}))
+		};
+		return {
+			...await this.marketplaceClient.publish({
+				payload,
+				apiBaseUrl,
+				token
+			}),
+			bundle: {
+				path: bundle.bundlePath,
+				sha256: bundleSha256
+			}
+		};
+	};
+};
+//#endregion
+export { AppPublishService };