@nextclaw/service 0.1.1

package/dist/cli/commands/skills/marketplace-identity.utils.js

@@ -0,0 +1,77 @@
+//#region src/cli/commands/skills/marketplace-identity.utils.ts
+function resolvePublishPackageName(params) {
+	const { explicitPackageName, explicitScope, slug, adminTokenPresent, currentUser } = params;
+	const normalizedExplicitPackageName = explicitPackageName?.trim();
+	if (normalizedExplicitPackageName) return resolveExplicitPackageName(normalizedExplicitPackageName, adminTokenPresent, currentUser);
+	const normalizedScope = explicitScope?.trim().toLowerCase();
+	if (normalizedScope) return resolveScopedPackageName(normalizedScope, slug, adminTokenPresent, currentUser);
+	return resolveDefaultPackageName(slug, adminTokenPresent, currentUser);
+}
+function resolveExplicitPackageName(packageName, adminTokenPresent, currentUser) {
+	const parsed = parsePackageName(packageName, "packageName");
+	if (parsed.scope === "nextclaw") {
+		assertOfficialScopeAllowed(adminTokenPresent, currentUser);
+		return packageName;
+	}
+	assertPersonalScopeAllowed(parsed.scope, currentUser);
+	return packageName;
+}
+function resolveScopedPackageName(scope, slug, adminTokenPresent, currentUser) {
+	if (scope === "nextclaw") {
+		assertOfficialScopeAllowed(adminTokenPresent, currentUser);
+		return `@nextclaw/${slug}`;
+	}
+	assertPersonalScopeAllowed(scope, currentUser);
+	return `@${scope}/${slug}`;
+}
+function resolveDefaultPackageName(slug, adminTokenPresent, currentUser) {
+	if (adminTokenPresent) return `@nextclaw/${slug}`;
+	return `@${requirePlatformUsername(currentUser)}/${slug}`;
+}
+function validateSkillSlug(raw, fieldName) {
+	if (!/^[A-Za-z0-9._-]+$/.test(raw)) throw new Error(`Invalid ${fieldName}: ${raw}`);
+	return raw;
+}
+function validateSkillSelector(raw, fieldName) {
+	if (raw.startsWith("@")) {
+		parsePackageName(raw, fieldName);
+		return raw;
+	}
+	return validateSkillSlug(raw, fieldName);
+}
+function normalizeTags(rawTags) {
+	const seen = /* @__PURE__ */ new Set();
+	const output = [];
+	for (const rawTag of rawTags ?? []) {
+		const tag = rawTag.trim();
+		if (!tag || seen.has(tag)) continue;
+		seen.add(tag);
+		output.push(tag);
+	}
+	return output.length > 0 ? output : ["skill"];
+}
+function canPublishOfficialScope(adminTokenPresent, currentUser) {
+	return adminTokenPresent || currentUser?.user.role === "admin";
+}
+function assertOfficialScopeAllowed(adminTokenPresent, currentUser) {
+	if (!canPublishOfficialScope(adminTokenPresent, currentUser)) throw new Error("Publishing to @nextclaw/* requires admin permission.");
+}
+function assertPersonalScopeAllowed(scope, currentUser) {
+	const username = requirePlatformUsername(currentUser);
+	if (scope !== username) throw new Error(`Personal publish scope must match your username: @${username}/*`);
+}
+function requirePlatformUsername(currentUser) {
+	const username = currentUser?.user.username;
+	if (!username) throw new Error("Set your NextClaw username before publishing personal skills. Open NextClaw Web account settings: https://platform.nextclaw.io/account or run `nextclaw account set-username <username>`.");
+	return username;
+}
+function parsePackageName(raw, fieldName) {
+	const match = raw.match(/^@([a-z0-9](?:[a-z0-9-]{1,30}[a-z0-9])?)\/([A-Za-z0-9._-]+)$/);
+	if (!match) throw new Error(`Invalid ${fieldName}: ${raw}`);
+	return {
+		scope: match[1],
+		name: match[2]
+	};
+}
+//#endregion
+export { normalizeTags, resolvePublishPackageName, validateSkillSelector, validateSkillSlug };

package/dist/cli/commands/skills/marketplace-network-retry.d.ts

@@ -0,0 +1,4 @@
+//#region src/cli/commands/skills/marketplace-network-retry.d.ts
+declare function runWithMarketplaceNetworkRetry<T>(action: () => Promise<T>): Promise<T>;
+//#endregion
+export { runWithMarketplaceNetworkRetry };

package/dist/cli/commands/skills/marketplace-network-retry.js

@@ -0,0 +1,32 @@
+//#region src/cli/commands/skills/marketplace-network-retry.ts
+const MARKETPLACE_NETWORK_RETRY_ATTEMPTS = 5;
+const MARKETPLACE_NETWORK_RETRY_BASE_MS = 350;
+function sleepMs(ms) {
+	return new Promise((resolve) => {
+		setTimeout(resolve, ms);
+	});
+}
+function isRetryableMarketplaceNetworkError(error) {
+	if (!(error instanceof Error)) return false;
+	if (error.name === "AbortError") return false;
+	const cause = error.cause;
+	if (cause && typeof cause === "object" && cause !== null && "code" in cause) {
+		const code = cause.code;
+		if (code === "ECONNRESET" || code === "ECONNREFUSED" || code === "ETIMEDOUT" || code === "EPIPE" || code === "ENOTFOUND" || code === "EAI_AGAIN") return true;
+	}
+	if (error instanceof TypeError && error.message === "fetch failed") return true;
+	return false;
+}
+async function runWithMarketplaceNetworkRetry(action) {
+	let last;
+	for (let attempt = 1; attempt <= MARKETPLACE_NETWORK_RETRY_ATTEMPTS; attempt++) try {
+		return await action();
+	} catch (error) {
+		last = error;
+		if (attempt === MARKETPLACE_NETWORK_RETRY_ATTEMPTS || !isRetryableMarketplaceNetworkError(error)) throw error;
+		await sleepMs(MARKETPLACE_NETWORK_RETRY_BASE_MS * 2 ** (attempt - 1));
+	}
+	throw last;
+}
+//#endregion
+export { runWithMarketplaceNetworkRetry };

package/dist/cli/commands/skills/marketplace.metadata.d.ts

@@ -0,0 +1,29 @@
+//#region src/cli/commands/skills/marketplace.metadata.d.ts
+type LocalizedTextMap = Record<string, string>;
+type MarketplaceSkillPublishMetadata = {
+  slug?: string;
+  name?: string;
+  summary?: string;
+  summaryI18n?: LocalizedTextMap;
+  description?: string;
+  descriptionI18n?: LocalizedTextMap;
+  author?: string;
+  tags?: string[];
+  sourceRepo?: string;
+  homepage?: string;
+  publishedAt?: string;
+  updatedAt?: string;
+};
+declare function parseSkillFrontmatter(raw: string): {
+  name?: string;
+  summary?: string;
+  summaryI18n?: LocalizedTextMap;
+  description?: string;
+  descriptionI18n?: LocalizedTextMap;
+  author?: string;
+  tags?: string[];
+};
+declare function buildLocalizedTextMap(englishText: string, ...maps: Array<LocalizedTextMap | Partial<LocalizedTextMap> | undefined>): LocalizedTextMap;
+declare function readMarketplaceMetadataFile(skillDir: string, explicitMetaFile?: string): MarketplaceSkillPublishMetadata;
+//#endregion
+export { LocalizedTextMap, MarketplaceSkillPublishMetadata, buildLocalizedTextMap, parseSkillFrontmatter, readMarketplaceMetadataFile };

package/dist/cli/commands/skills/marketplace.metadata.js

@@ -0,0 +1,158 @@
+import { resolve } from "node:path";
+import { existsSync, readFileSync } from "node:fs";
+import { parse } from "yaml";
+//#region src/cli/commands/skills/marketplace.metadata.ts
+const DEFAULT_MARKETPLACE_META_FILENAME = "marketplace.json";
+function parseSkillFrontmatter(raw) {
+	const match = raw.replace(/\r\n/g, "\n").match(/^---\n([\s\S]*?)\n---/);
+	if (!match || !match[1]) return {};
+	let parsed;
+	try {
+		parsed = parse(match[1]);
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Invalid SKILL.md frontmatter: ${message}`);
+	}
+	if (!isRecord(parsed)) return {};
+	const summaryI18n = readLocalizedTextMapField(parsed, [["summaryi18n"], ["summary_i18n"]]);
+	const descriptionI18n = readLocalizedTextMapField(parsed, [["descriptioni18n"], ["description_i18n"]]);
+	const summaryZh = readFrontmatterStringField(parsed, [["summaryzh"], ["summary_zh"]]);
+	const descriptionZh = readFrontmatterStringField(parsed, [["descriptionzh"], ["description_zh"]]);
+	return {
+		name: readFrontmatterStringField(parsed, [["name"]]),
+		summary: readFrontmatterStringField(parsed, [["summary"]]),
+		summaryI18n: mergeLocalizedTextMap(summaryI18n, { zh: summaryZh }),
+		description: readFrontmatterStringField(parsed, [["description"]]),
+		descriptionI18n: mergeLocalizedTextMap(descriptionI18n, { zh: descriptionZh }),
+		author: readFrontmatterStringField(parsed, [["author"]]),
+		tags: readFrontmatterTags(parsed)
+	};
+}
+function buildLocalizedTextMap(englishText, ...maps) {
+	return {
+		...mergeLocalizedTextMap(...maps) ?? {},
+		en: englishText
+	};
+}
+function readMarketplaceMetadataFile(skillDir, explicitMetaFile) {
+	const metadataPath = resolveMarketplaceMetadataPath(skillDir, explicitMetaFile);
+	if (!metadataPath) return {};
+	let parsed;
+	try {
+		parsed = JSON.parse(readFileSync(metadataPath, "utf8"));
+	} catch (error) {
+		const message = error instanceof Error ? error.message : String(error);
+		throw new Error(`Invalid marketplace metadata file: ${metadataPath} (${message})`);
+	}
+	if (!isRecord(parsed)) throw new Error(`Invalid marketplace metadata file: ${metadataPath} (root must be an object)`);
+	return {
+		slug: readMetadataString(parsed, "slug"),
+		name: readMetadataString(parsed, "name"),
+		summary: readMetadataString(parsed, "summary"),
+		summaryI18n: readMetadataLocalizedTextMap(parsed, "summaryI18n"),
+		description: readMetadataString(parsed, "description"),
+		descriptionI18n: readMetadataLocalizedTextMap(parsed, "descriptionI18n"),
+		author: readMetadataString(parsed, "author"),
+		tags: readMetadataStringArray(parsed, "tags"),
+		sourceRepo: readMetadataString(parsed, "sourceRepo"),
+		homepage: readMetadataString(parsed, "homepage"),
+		publishedAt: readMetadataString(parsed, "publishedAt"),
+		updatedAt: readMetadataString(parsed, "updatedAt")
+	};
+}
+function resolveMarketplaceMetadataPath(skillDir, explicitMetaFile) {
+	const resolved = explicitMetaFile?.trim() ? resolve(explicitMetaFile) : resolve(skillDir, DEFAULT_MARKETPLACE_META_FILENAME);
+	return existsSync(resolved) ? resolved : void 0;
+}
+function mergeLocalizedTextMap(...maps) {
+	const localized = {};
+	for (const map of maps) for (const [locale, text] of Object.entries(map ?? {})) {
+		const normalizedText = typeof text === "string" ? text.trim() : "";
+		if (!normalizedText) continue;
+		localized[normalizeLocaleTag(locale)] = normalizedText;
+	}
+	return Object.keys(localized).length > 0 ? localized : void 0;
+}
+function readMetadataString(record, fieldName) {
+	const value = record[fieldName];
+	if (value == null) return;
+	if (typeof value !== "string") throw new Error(`Invalid marketplace metadata field: ${fieldName} must be a string`);
+	return value.trim() || void 0;
+}
+function readMetadataStringArray(record, fieldName) {
+	const value = record[fieldName];
+	if (value == null) return;
+	if (!Array.isArray(value)) throw new Error(`Invalid marketplace metadata field: ${fieldName} must be an array`);
+	const tags = value.map((entry, index) => {
+		if (typeof entry !== "string") throw new Error(`Invalid marketplace metadata field: ${fieldName}[${index}] must be a string`);
+		return entry.trim();
+	}).filter(Boolean);
+	return tags.length > 0 ? tags : void 0;
+}
+function readMetadataLocalizedTextMap(record, fieldName) {
+	const value = record[fieldName];
+	if (value == null) return;
+	if (!isRecord(value)) throw new Error(`Invalid marketplace metadata field: ${fieldName} must be an object`);
+	const localized = {};
+	for (const [locale, text] of Object.entries(value)) {
+		if (typeof text !== "string") throw new Error(`Invalid marketplace metadata field: ${fieldName}.${locale} must be a string`);
+		const normalized = text.trim();
+		if (!normalized) continue;
+		localized[normalizeLocaleTag(locale)] = normalized;
+	}
+	return Object.keys(localized).length > 0 ? localized : void 0;
+}
+function readFrontmatterStringField(record, keyPaths) {
+	for (const keyPath of keyPaths) {
+		const value = readNestedFrontmatterValue(record, keyPath);
+		if (typeof value !== "string") continue;
+		const normalized = value.trim();
+		if (normalized) return normalized;
+	}
+}
+function readLocalizedTextMapField(record, keyPaths) {
+	for (const keyPath of keyPaths) {
+		const value = readNestedFrontmatterValue(record, keyPath);
+		if (!isRecord(value)) continue;
+		const normalized = {};
+		for (const [locale, text] of Object.entries(value)) {
+			if (typeof text !== "string") continue;
+			const trimmed = text.trim();
+			if (!trimmed) continue;
+			normalized[normalizeLocaleTag(locale)] = trimmed;
+		}
+		if (Object.keys(normalized).length > 0) return normalized;
+	}
+}
+function readFrontmatterTags(record) {
+	const rawTags = readNestedFrontmatterValue(record, ["tags"]);
+	if (Array.isArray(rawTags)) {
+		const tags = rawTags.filter((entry) => typeof entry === "string").map((entry) => entry.trim()).filter(Boolean);
+		return tags.length > 0 ? tags : void 0;
+	}
+	if (typeof rawTags !== "string") return;
+	const tags = rawTags.split(",").map((entry) => entry.trim()).filter(Boolean);
+	return tags.length > 0 ? tags : void 0;
+}
+function readNestedFrontmatterValue(record, keyPath) {
+	let current = record;
+	for (const rawKey of keyPath) {
+		if (!isRecord(current)) return;
+		const normalizedKey = normalizeFrontmatterKey(rawKey);
+		const matchingKey = Object.keys(current).find((candidate) => normalizeFrontmatterKey(candidate) === normalizedKey);
+		if (!matchingKey) return;
+		current = current[matchingKey];
+	}
+	return current;
+}
+function normalizeFrontmatterKey(raw) {
+	return raw.replace(/[-_]/g, "").toLowerCase();
+}
+function normalizeLocaleTag(raw) {
+	return raw.trim().toLowerCase();
+}
+function isRecord(value) {
+	return typeof value === "object" && value !== null && !Array.isArray(value);
+}
+//#endregion
+export { buildLocalizedTextMap, parseSkillFrontmatter, readMarketplaceMetadataFile };

package/dist/cli/commands/skills/marketplace.service.d.ts

@@ -0,0 +1,46 @@
+import { LocalizedTextMap } from "./marketplace.metadata.js";
+
+//#region src/cli/commands/skills/marketplace.service.d.ts
+type MarketplaceSkillInstallKind = "builtin" | "marketplace";
+type MarketplaceSkillInstallOptions = {
+  slug: string;
+  workdir: string;
+  dir?: string;
+  force?: boolean;
+  apiBaseUrl?: string;
+};
+type MarketplaceSkillPublishOptions = {
+  skillDir: string;
+  metaFile?: string;
+  slug?: string;
+  packageName?: string;
+  scope?: string;
+  name?: string;
+  summary?: string;
+  summaryI18n?: LocalizedTextMap;
+  description?: string;
+  descriptionI18n?: LocalizedTextMap;
+  author?: string;
+  tags?: string[];
+  sourceRepo?: string;
+  homepage?: string;
+  publishedAt?: string;
+  updatedAt?: string;
+  apiBaseUrl?: string;
+  token?: string;
+  requireExisting?: boolean;
+};
+declare function installMarketplaceSkill(options: MarketplaceSkillInstallOptions): Promise<{
+  slug: string;
+  destinationDir: string;
+  alreadyInstalled?: boolean;
+  source: MarketplaceSkillInstallKind;
+}>;
+declare function publishMarketplaceSkill(options: MarketplaceSkillPublishOptions): Promise<{
+  created: boolean;
+  slug: string;
+  packageName: string;
+  fileCount: number;
+}>;
+//#endregion
+export { MarketplaceSkillInstallOptions, MarketplaceSkillPublishOptions, installMarketplaceSkill, publishMarketplaceSkill };

package/dist/cli/commands/skills/marketplace.service.js

@@ -0,0 +1,238 @@
+import { PlatformAuthCommands } from "../../../commands/platform-auth/services/platform-auth-commands.service.js";
+import "../../../commands/platform-auth/index.js";
+import { normalizeTags, resolvePublishPackageName, validateSkillSelector, validateSkillSlug } from "./marketplace-identity.utils.js";
+import { buildLocalizedTextMap, parseSkillFrontmatter, readMarketplaceMetadataFile } from "./marketplace.metadata.js";
+import { runWithMarketplaceNetworkRetry } from "./marketplace-network-retry.js";
+import { fetchMarketplaceSkillFileBlob, fetchMarketplaceSkillFiles, fetchMarketplaceSkillItem, readMarketplaceEnvelope, resolveMarketplaceAdminToken, resolveMarketplaceApiBase } from "./marketplace-client.js";
+import { basename, dirname, isAbsolute, join, relative, resolve } from "node:path";
+import { SkillsLoader } from "@nextclaw/core";
+import { existsSync, mkdirSync, readFileSync, readdirSync, rmSync, writeFileSync } from "node:fs";
+//#region src/cli/commands/skills/marketplace.service.ts
+async function installMarketplaceSkill(options) {
+	const { slug, workdir: rawWorkdir, dir, force, apiBaseUrl } = options;
+	const selector = validateSkillSelector(slug.trim(), "slug");
+	const workdir = resolve(rawWorkdir);
+	if (!existsSync(workdir)) throw new Error(`Workdir does not exist: ${workdir}`);
+	const apiBase = resolveMarketplaceApiBase(apiBaseUrl);
+	const item = await fetchMarketplaceSkillItem(apiBase, selector);
+	const installSlug = item.slug;
+	const resolvedSlug = item.packageName || item.slug;
+	const destinationDir = resolveMarketplaceSkillDestinationDir({
+		workdir,
+		slug: installSlug,
+		dir
+	});
+	if (item.install.kind === "builtin") {
+		const builtinResult = resolveBuiltinMarketplaceInstallResult({
+			workdir,
+			slug: installSlug
+		});
+		builtinResult.slug = resolvedSlug;
+		return builtinResult;
+	}
+	const filesPayload = await fetchMarketplaceSkillFiles(apiBase, selector);
+	const existingInstall = prepareMarketplaceSkillDestinationDir({
+		destinationDir,
+		files: filesPayload.files,
+		force,
+		slug: installSlug
+	});
+	if (existingInstall) {
+		existingInstall.slug = resolvedSlug;
+		return existingInstall;
+	}
+	await writeMarketplaceSkillFiles({
+		destinationDir,
+		files: filesPayload.files,
+		apiBase,
+		slug: selector
+	});
+	ensureInstalledMarketplaceSkill(destinationDir, installSlug);
+	return buildMarketplaceInstallResult(resolvedSlug, destinationDir);
+}
+function resolveMarketplaceSkillDestinationDir(params) {
+	const { workdir, slug, dir } = params;
+	const dirName = dir?.trim() || "skills";
+	return isAbsolute(dirName) ? resolve(dirName, slug) : resolve(workdir, dirName, slug);
+}
+function resolveBuiltinMarketplaceInstallResult(params) {
+	return {
+		slug: params.slug,
+		destinationDir: resolveBuiltinSkillDir(params.workdir, params.slug),
+		alreadyInstalled: true,
+		source: "builtin"
+	};
+}
+function prepareMarketplaceSkillDestinationDir(params) {
+	const { destinationDir, files, force, slug } = params;
+	if (!force && existsSync(destinationDir)) {
+		const existingDirState = inspectMarketplaceSkillDirectory(destinationDir, files);
+		if (existingDirState === "installed") return {
+			slug,
+			destinationDir,
+			alreadyInstalled: true,
+			source: "marketplace"
+		};
+		if (existingDirState !== "recoverable") throw new Error(`Skill directory already exists: ${destinationDir} (use --force)`);
+		rmSync(destinationDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	if (force && existsSync(destinationDir)) rmSync(destinationDir, {
+		recursive: true,
+		force: true
+	});
+	mkdirSync(destinationDir, { recursive: true });
+	return null;
+}
+async function writeMarketplaceSkillFiles(params) {
+	const { destinationDir, files, apiBase, slug } = params;
+	for (const file of files) {
+		const targetPath = resolve(destinationDir, ...file.path.split("/"));
+		const rel = relative(destinationDir, targetPath);
+		if (rel.startsWith("..") || isAbsolute(rel)) throw new Error(`Invalid marketplace file path: ${file.path}`);
+		mkdirSync(dirname(targetPath), { recursive: true });
+		writeFileSync(targetPath, file.contentBase64 ? decodeMarketplaceFileContent(file.path, file.contentBase64) : await fetchMarketplaceSkillFileBlob(apiBase, slug, file));
+	}
+}
+function ensureInstalledMarketplaceSkill(destinationDir, slug) {
+	if (!existsSync(join(destinationDir, "SKILL.md"))) throw new Error(`Marketplace skill ${slug} does not include SKILL.md`);
+}
+function buildMarketplaceInstallResult(slug, destinationDir) {
+	return {
+		slug,
+		destinationDir,
+		source: "marketplace"
+	};
+}
+function inspectMarketplaceSkillDirectory(destinationDir, files) {
+	if (existsSync(join(destinationDir, "SKILL.md"))) return "installed";
+	const discoveredFiles = collectRelativeFiles(destinationDir);
+	if (discoveredFiles === null) return "conflict";
+	const relevantFiles = discoveredFiles.filter((file) => !isIgnorableMarketplaceResidue(file));
+	if (relevantFiles.length === 0) return "recoverable";
+	const manifestPaths = new Set(files.map((file) => normalizeMarketplaceRelativePath(file.path)));
+	return relevantFiles.every((file) => manifestPaths.has(normalizeMarketplaceRelativePath(file))) ? "recoverable" : "conflict";
+}
+function collectRelativeFiles(rootDir) {
+	const output = [];
+	const walk = (dir) => {
+		const entries = readdirSync(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const absolute = join(dir, entry.name);
+			if (entry.isDirectory()) {
+				if (!walk(absolute)) return false;
+				continue;
+			}
+			if (!entry.isFile()) return false;
+			const relativePath = relative(rootDir, absolute);
+			output.push(normalizeMarketplaceRelativePath(relativePath));
+		}
+		return true;
+	};
+	return walk(rootDir) ? output : null;
+}
+function normalizeMarketplaceRelativePath(path) {
+	return path.replace(/\\/g, "/");
+}
+function isIgnorableMarketplaceResidue(path) {
+	return path === ".DS_Store";
+}
+async function publishMarketplaceSkill(options) {
+	const { skillDir: rawSkillDir, slug: explicitSlug, metaFile, packageName: explicitPackageName, scope: explicitScope, name: explicitName, summary: explicitSummary, summaryI18n: explicitSummaryI18n, description: explicitDescription, descriptionI18n: explicitDescriptionI18n, tags: explicitTags, sourceRepo: explicitSourceRepo, homepage: explicitHomepage, publishedAt: explicitPublishedAt, updatedAt: explicitUpdatedAt, apiBaseUrl, token: explicitToken, requireExisting } = options;
+	const skillDir = resolve(rawSkillDir);
+	if (!existsSync(skillDir)) throw new Error(`Skill directory not found: ${skillDir}`);
+	const files = collectFiles(skillDir);
+	if (!files.some((file) => file.path === "SKILL.md")) throw new Error(`Skill directory must include SKILL.md: ${skillDir}`);
+	const parsedFrontmatter = parseSkillFrontmatter(readFileSync(join(skillDir, "SKILL.md"), "utf8"));
+	const metadata = readMarketplaceMetadataFile(skillDir, metaFile);
+	const slug = validateSkillSlug(explicitSlug?.trim() || metadata.slug || basename(skillDir), "slug");
+	const name = explicitName?.trim() || metadata.name || parsedFrontmatter.name || slug;
+	const description = explicitDescription?.trim() || metadata.description || metadata.descriptionI18n?.en || parsedFrontmatter.description;
+	const summary = explicitSummary?.trim() || metadata.summary || metadata.summaryI18n?.en || parsedFrontmatter.summary || description || `${slug} skill`;
+	const summaryI18n = buildLocalizedTextMap(summary, parsedFrontmatter.summaryI18n, metadata.summaryI18n, explicitSummaryI18n);
+	const descriptionI18n = description ? buildLocalizedTextMap(description, parsedFrontmatter.descriptionI18n, metadata.descriptionI18n, explicitDescriptionI18n) : void 0;
+	const tags = normalizeTags(explicitTags && explicitTags.length > 0 ? explicitTags : metadata.tags ?? parsedFrontmatter.tags);
+	const apiBase = resolveMarketplaceApiBase(apiBaseUrl);
+	const adminToken = resolveMarketplaceAdminToken(explicitToken);
+	const platformAuth = new PlatformAuthCommands();
+	const currentUser = adminToken ? null : await platformAuth.me();
+	const packageName = resolvePublishPackageName({
+		explicitPackageName,
+		explicitScope,
+		slug,
+		adminTokenPresent: Boolean(adminToken),
+		currentUser
+	});
+	const authToken = adminToken ?? currentUser?.token;
+	if (!authToken) throw new Error("Publishing requires either a marketplace admin token or an active NextClaw platform login.");
+	const response = await runWithMarketplaceNetworkRetry(() => fetch(`${apiBase}/api/v1/skills/publish`, {
+		method: "POST",
+		headers: {
+			"content-type": "application/json",
+			Authorization: `Bearer ${authToken}`
+		},
+		body: JSON.stringify({
+			slug,
+			packageName,
+			name,
+			summary,
+			summaryI18n,
+			description,
+			descriptionI18n,
+			tags,
+			sourceRepo: explicitSourceRepo?.trim() || metadata.sourceRepo,
+			homepage: explicitHomepage?.trim() || metadata.homepage,
+			publishedAt: explicitPublishedAt?.trim() || metadata.publishedAt,
+			updatedAt: explicitUpdatedAt?.trim() || metadata.updatedAt,
+			requireExisting,
+			files
+		})
+	}));
+	const payload = await readMarketplaceEnvelope(response);
+	if (!payload.ok || !payload.data) {
+		const message = payload.error?.message || `marketplace publish failed: HTTP ${response.status}`;
+		throw new Error(message);
+	}
+	return {
+		created: payload.data.created,
+		slug: payload.data.item?.slug || slug,
+		packageName: payload.data.item?.packageName || packageName,
+		fileCount: payload.data.fileCount
+	};
+}
+function collectFiles(rootDir) {
+	const output = [];
+	const walk = (dir, prefix) => {
+		const entries = readdirSync(dir, { withFileTypes: true });
+		for (const entry of entries) {
+			const absolute = join(dir, entry.name);
+			const relativePath = prefix ? `${prefix}/${entry.name}` : entry.name;
+			if (entry.isDirectory()) {
+				walk(absolute, relativePath);
+				continue;
+			}
+			if (!entry.isFile()) continue;
+			const content = readFileSync(absolute);
+			output.push({
+				path: relativePath,
+				contentBase64: content.toString("base64")
+			});
+		}
+	};
+	walk(rootDir, "");
+	return output;
+}
+function resolveBuiltinSkillDir(workdir, skillName) {
+	const builtinSkill = new SkillsLoader(workdir).listSkills(false).find((skill) => skill.name === skillName && skill.source === "builtin");
+	if (!builtinSkill) throw new Error(`Built-in skill not found in local installation: ${skillName}`);
+	return dirname(builtinSkill.path);
+}
+function decodeMarketplaceFileContent(path, contentBase64) {
+	const normalized = contentBase64.replace(/\s+/g, "");
+	if (!normalized || normalized.length % 4 !== 0 || !/^[A-Za-z0-9+/]+={0,2}$/.test(normalized)) throw new Error(`Invalid marketplace file contentBase64 for path: ${path}`);
+	return Buffer.from(normalized, "base64");
+}
+//#endregion
+export { installMarketplaceSkill, publishMarketplaceSkill };