@mulmoclaude/core 0.2.15 → 0.2.16

package/dist/collection/registry/server/index.js

@@ -0,0 +1,1076 @@
+import { G as collectionsRegistriesConfigPath, I as writeFileAtomic, J as log, U as safeRecordId, _ as acceptParsedSchema, g as CollectionSchemaZ, m as errorMessage, p as ONE_SECOND_MS, y as loadCollection } from "../../../server-DRoqc8dL.js";
+import { isSafeActionTemplatePath } from "../../paths.js";
+import { n as parseRegistryIndex, r as isRecord, t as OFFICIAL_REGISTRY_NAME } from "../../../types-BKVZrtyc.js";
+import { claudeSkillDir, dataSkillDir, mirrorSkillWrite } from "../../../skill-bridge/index.js";
+import path from "node:path";
+import { readFileSync } from "node:fs";
+import { cp, mkdir, readFile, readdir, rename, rm, stat, writeFile } from "node:fs/promises";
+//#region src/collection/registry/server/fetch.ts
+var DEFAULT_FETCH_TIMEOUT_MS = 10 * ONE_SECOND_MS;
+/** `fetch` with a finite timeout. Rejects with a `TimeoutError` once `timeoutMs`
+*  elapses. Composes with a caller-supplied `signal` so external cancellation
+*  still works. */
+async function fetchWithTimeout(url, init = {}) {
+	const { timeoutMs = DEFAULT_FETCH_TIMEOUT_MS, signal: callerSignal, ...rest } = init;
+	if (callerSignal?.aborted) throw callerSignal.reason ?? new DOMException("Aborted", "AbortError");
+	const controller = new AbortController();
+	const timer = setTimeout(() => {
+		controller.abort(new DOMException(`fetch timed out after ${timeoutMs}ms`, "TimeoutError"));
+	}, timeoutMs);
+	const unsubscribeCaller = bridgeExternalSignal(callerSignal, controller);
+	try {
+		return await fetch(url, {
+			...rest,
+			signal: controller.signal
+		});
+	} finally {
+		clearTimeout(timer);
+		unsubscribeCaller?.();
+	}
+}
+function bridgeExternalSignal(external, controller) {
+	if (!external) return null;
+	const onAbort = () => controller.abort(external.reason);
+	external.addEventListener("abort", onAbort, { once: true });
+	return () => external.removeEventListener("abort", onAbort);
+}
+//#endregion
+//#region src/collection/registry/server/registriesConfig.ts
+var NAME_RE = /^[A-Za-z0-9][A-Za-z0-9_-]{0,31}$/;
+function isValidHttpsUrl(value) {
+	if (typeof value !== "string" || value.length === 0) return false;
+	let url;
+	try {
+		url = new URL(value);
+	} catch {
+		return false;
+	}
+	if (url.protocol !== "https:") return false;
+	if (url.username !== "" || url.password !== "") return false;
+	return true;
+}
+function parseEntry(value, index) {
+	if (!isRecord(value)) return `entry[${index}] is not an object`;
+	const { name, indexUrl, rawBaseUrl } = value;
+	if (typeof name !== "string" || !NAME_RE.test(name)) return `entry[${index}].name must match ${NAME_RE.source}`;
+	if (name === "official") return `entry[${index}].name "${OFFICIAL_REGISTRY_NAME}" is reserved`;
+	if (!isValidHttpsUrl(indexUrl)) return `entry[${index}].indexUrl must be a valid HTTPS URL (no credentials)`;
+	if (!isValidHttpsUrl(rawBaseUrl)) return `entry[${index}].rawBaseUrl must be a valid HTTPS URL (no credentials)`;
+	if (rawBaseUrl.includes("?") || rawBaseUrl.includes("#")) return `entry[${index}].rawBaseUrl must not contain a query (?) or fragment (#) — it's joined as a path prefix`;
+	let normalizedRawBase = rawBaseUrl;
+	while (normalizedRawBase.endsWith("/")) normalizedRawBase = normalizedRawBase.slice(0, -1);
+	return {
+		name,
+		indexUrl,
+		rawBaseUrl: normalizedRawBase
+	};
+}
+/** Parse the JSON text of `config/collections-registries.json`. Bad entries
+*  drop with a warning; valid entries are returned in source order. Exported
+*  for unit testing — the I/O wrapper `loadRegistriesConfig` below reads the
+*  workspace file and delegates here. */
+function parseRegistriesConfig(raw) {
+	if (!Array.isArray(raw)) {
+		log.warn("collections-registry", "registries config is not an array — ignoring");
+		return [];
+	}
+	const seen = /* @__PURE__ */ new Set();
+	const out = [];
+	for (let i = 0; i < raw.length; i++) {
+		const parsed = parseEntry(raw[i], i);
+		if (typeof parsed === "string") {
+			log.warn("collections-registry", "registry config entry rejected", { reason: parsed });
+			continue;
+		}
+		if (seen.has(parsed.name)) {
+			log.warn("collections-registry", "registry config duplicate name dropped", { name: parsed.name });
+			continue;
+		}
+		seen.add(parsed.name);
+		out.push(parsed);
+	}
+	return out;
+}
+function readConfigTextOrNull(filePath) {
+	try {
+		return readFileSync(filePath, "utf-8");
+	} catch (err) {
+		if (isRecord(err) && err.code === "ENOENT") return null;
+		throw err;
+	}
+}
+/** Read `config/collections-registries.json` from the configured workspace.
+*  Missing file ⇒ empty list. Malformed JSON or rejected entries log but never
+*  throw. */
+function loadRegistriesConfig() {
+	const text = readConfigTextOrNull(collectionsRegistriesConfigPath());
+	if (text === null) return [];
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch (err) {
+		log.warn("collections-registry", "registries config is not valid JSON — ignoring", { error: err instanceof Error ? err.message : String(err) });
+		return [];
+	}
+	return parseRegistriesConfig(parsed);
+}
+//#endregion
+//#region src/collection/registry/server/client.ts
+var DEFAULT_OFFICIAL_INDEX_URL = "https://receptron.github.io/mulmoclaude-collections/index.json";
+var DEFAULT_OFFICIAL_RAW_BASE = "https://raw.githubusercontent.com/receptron/mulmoclaude-collections/main";
+var CACHE_TTL_MS = 300 * ONE_SECOND_MS;
+var STALE_RETRY_BACKOFF_MS = 60 * ONE_SECOND_MS;
+var FETCH_TIMEOUT_MS$1 = 10 * ONE_SECOND_MS;
+var STATUS_BAD_GATEWAY$2 = 502;
+var STATUS_UNAVAILABLE$1 = 503;
+var cache = /* @__PURE__ */ new Map();
+var lastFailureMs = /* @__PURE__ */ new Map();
+function officialDescriptor() {
+	return {
+		name: OFFICIAL_REGISTRY_NAME,
+		indexUrl: process.env.COLLECTIONS_REGISTRY_URL ?? DEFAULT_OFFICIAL_INDEX_URL,
+		rawBaseUrl: process.env.COLLECTIONS_REGISTRY_RAW_BASE ?? DEFAULT_OFFICIAL_RAW_BASE
+	};
+}
+/** The full ordered registry list: official first, then user-configured ones.
+*  Re-reads the config file on every call so a Discover refresh picks up edits
+*  without a server restart (the config is small + read-rarely). */
+function listRegistries() {
+	return [officialDescriptor(), ...loadRegistriesConfig()];
+}
+/** Look up one registry descriptor by name. Used by the preview / import path,
+*  which has the registry label from the entry and needs the rawBase. */
+function findRegistry(name) {
+	return listRegistries().find((reg) => reg.name === name) ?? null;
+}
+async function loadFromNetwork(descriptor) {
+	let res;
+	try {
+		res = await fetchWithTimeout(descriptor.indexUrl, {
+			timeoutMs: FETCH_TIMEOUT_MS$1,
+			headers: { accept: "application/json" }
+		});
+	} catch (err) {
+		log.warn("collections-registry", "index fetch failed", {
+			registry: descriptor.name,
+			url: descriptor.indexUrl,
+			error: errorMessage(err)
+		});
+		return {
+			ok: false,
+			status: STATUS_UNAVAILABLE$1,
+			error: "registry unreachable"
+		};
+	}
+	if (!res.ok) return {
+		ok: false,
+		status: STATUS_BAD_GATEWAY$2,
+		error: `registry responded ${res.status}`
+	};
+	const parsed = parseRegistryIndex(await res.json().catch(() => null), descriptor.name);
+	if (!parsed.ok) {
+		log.warn("collections-registry", "index invalid", {
+			registry: descriptor.name,
+			url: descriptor.indexUrl,
+			error: parsed.error
+		});
+		return {
+			ok: false,
+			status: STATUS_BAD_GATEWAY$2,
+			error: `registry index invalid: ${parsed.error}`
+		};
+	}
+	return {
+		ok: true,
+		index: parsed.index,
+		stale: false
+	};
+}
+/** Cache key incorporates BOTH URLs so editing `indexUrl` or `rawBaseUrl` for
+*  an existing registry name invalidates the cached index automatically — same
+*  refresh cycle as if the user had renamed it (CodeRabbit review on #1837).
+*  Without this, the Discover catalog could keep serving the old upstream's
+*  entries while preview / import resolved the new rawBase, drifting until TTL
+*  expiry. Tab + key-content guarantees no collision between e.g. swapped
+*  name/url pairs. */
+function descriptorCacheKey(descriptor) {
+	return `${descriptor.name}\t${descriptor.indexUrl}\t${descriptor.rawBaseUrl}`;
+}
+/** Fetch one registry's index. Same cache + stale-on-failure semantics as the
+*  original single-registry implementation — just keyed by descriptor identity
+*  (name + both URLs) so multiple registries don't fight over one slot AND a
+*  reconfigured registry doesn't serve a stale index from the prior URL. */
+async function fetchRegistryIndex(descriptor, opts = {}) {
+	const nowMs = opts.nowMs ?? Date.now();
+	const loader = opts.loader ?? loadFromNetwork;
+	const key = descriptorCacheKey(descriptor);
+	const cached = cache.get(key);
+	if (!opts.force && cached && nowMs - cached.atMs < CACHE_TTL_MS) return {
+		ok: true,
+		index: cached.index,
+		stale: false
+	};
+	const failedAt = lastFailureMs.get(key);
+	if (!opts.force && cached && failedAt !== void 0 && nowMs - failedAt < STALE_RETRY_BACKOFF_MS) return {
+		ok: true,
+		index: cached.index,
+		stale: true
+	};
+	const fresh = await loader(descriptor);
+	if (fresh.ok) {
+		cache.set(key, {
+			index: fresh.index,
+			atMs: nowMs
+		});
+		lastFailureMs.delete(key);
+		return {
+			ok: true,
+			index: fresh.index,
+			stale: false
+		};
+	}
+	lastFailureMs.set(key, nowMs);
+	if (cached) return {
+		ok: true,
+		index: cached.index,
+		stale: true
+	};
+	return fresh;
+}
+/** Fetch every configured registry in parallel and return per-registry
+*  outcomes. Callers (the Discover route) concatenate `entries` from each.
+*  Failure of any single registry doesn't abort the others — that's the point
+*  of supporting multiple registries. */
+async function fetchAllRegistries(opts = {}) {
+	const descriptors = listRegistries();
+	return await Promise.all(descriptors.map(async (descriptor) => {
+		const result = await fetchRegistryIndex(descriptor, opts);
+		if (!result.ok) return {
+			name: descriptor.name,
+			status: "failed",
+			generatedAt: null,
+			error: result.error,
+			entries: []
+		};
+		return {
+			name: descriptor.name,
+			status: result.stale ? "stale" : "ok",
+			generatedAt: result.index.generatedAt,
+			error: null,
+			entries: result.index.collections
+		};
+	}));
+}
+/** Test seam: reset the module cache + failure backoff state (all registries). */
+function resetRegistryCache() {
+	cache.clear();
+	lastFailureMs.clear();
+}
+//#endregion
+//#region src/collection/registry/server/collectionFiles.ts
+var FETCH_TIMEOUT_MS = 10 * ONE_SECOND_MS;
+var STATUS_BAD_GATEWAY$1 = 502;
+var STATUS_UNAVAILABLE = 503;
+var STATUS_NOT_FOUND$2 = 404;
+/** Compose the raw URL for `<dirPath>/<relFile>` under a given registry's
+*  rawBase. Empty and traversal (`.`/`..`) segments are dropped so the URL can
+*  never escape the base, even if an upstream check is bypassed (the index
+*  parser already rejects such identifiers — this is defense-in-depth). The
+*  rawBase is trailing-slash-normalized: `parseRegistriesConfig` already trims
+*  user-config trailing slashes, but the official descriptor and any test
+*  bypass parse — repeating the trim here keeps the join `${base}/${path}`
+*  from producing `//` even when the caller bypassed config validation
+*  (CodeRabbit review on #1837). */
+function collectionFileUrl(rawBase, dirPath, relFile) {
+	let base = rawBase;
+	while (base.endsWith("/")) base = base.slice(0, -1);
+	const segments = dirPath.split("/").filter((segment) => segment.length > 0 && segment !== "." && segment !== "..");
+	return `${base}/${segments.join("/")}/${relFile}`;
+}
+/** Fetch one file out of a registry collection. `rawBase` comes from the
+*  entry's source registry (`findRegistry(entry.registryName).rawBaseUrl`),
+*  not a module-level setting — that's what makes additional user-configured
+*  registries reachable. */
+async function fetchCollectionFile(rawBase, dirPath, relFile) {
+	const url = collectionFileUrl(rawBase, dirPath, relFile);
+	let res;
+	try {
+		res = await fetchWithTimeout(url, { timeoutMs: FETCH_TIMEOUT_MS });
+	} catch (err) {
+		return {
+			ok: false,
+			status: STATUS_UNAVAILABLE,
+			error: `fetch failed: ${errorMessage(err)}`
+		};
+	}
+	if (!res.ok) return {
+		ok: false,
+		status: STATUS_BAD_GATEWAY$1,
+		error: `${relFile} responded ${res.status}`
+	};
+	return {
+		ok: true,
+		text: await res.text()
+	};
+}
+function parseJsonObject(text, label) {
+	let parsed;
+	try {
+		parsed = JSON.parse(text);
+	} catch {
+		return {
+			ok: false,
+			error: `${label} is not valid JSON`
+		};
+	}
+	if (!isRecord(parsed)) return {
+		ok: false,
+		error: `${label} is not an object`
+	};
+	return {
+		ok: true,
+		value: parsed
+	};
+}
+async function fetchJsonObject(rawBase, dirPath, relFile, label) {
+	const file = await fetchCollectionFile(rawBase, dirPath, relFile);
+	if (!file.ok) return {
+		ok: false,
+		status: file.status,
+		error: `${label}: ${file.error}`
+	};
+	const parsed = parseJsonObject(file.text, label);
+	if (!parsed.ok) return {
+		ok: false,
+		status: STATUS_BAD_GATEWAY$1,
+		error: parsed.error
+	};
+	return {
+		ok: true,
+		value: parsed.value
+	};
+}
+/** Resolve an entry's rawBase from its `registryName`. A missing match (the
+*  user removed the registry from config while a cached index still references
+*  it) returns null — the caller surfaces it as a 404 rather than crashing. */
+function rawBaseForEntry(entry) {
+	return findRegistry(entry.registryName)?.rawBaseUrl ?? null;
+}
+/** Resolve an entry by author+slug across every cached registry's entries.
+*  When `registry` is passed we constrain to that registry — needed because
+*  multiple registries can publish the same author/slug, and the UI should
+*  follow the card it just clicked. */
+function findEntryInMergedView(merged, author, slug, registry) {
+	for (const reg of merged) {
+		if (registry !== null && reg.name !== registry) continue;
+		const match = reg.entries.find((candidate) => candidate.author === author && candidate.slug === slug);
+		if (match) return match;
+	}
+	return null;
+}
+/** Preview a registry collection: confirm it's in some registry's published
+*  index, then fetch + parse its schema.json + meta.json so the Discover tab
+*  can show fields/views before import. With multi-registry support the
+*  `registry` arg disambiguates same-name collections from different sources. */
+async function previewCollection(author, slug, registry = null) {
+	const entry = findEntryInMergedView(await fetchAllRegistries(), author, slug, registry);
+	if (!entry) return {
+		ok: false,
+		status: STATUS_NOT_FOUND$2,
+		error: `unknown collection: ${author}/${slug}`
+	};
+	const rawBase = rawBaseForEntry(entry);
+	if (!rawBase) return {
+		ok: false,
+		status: STATUS_NOT_FOUND$2,
+		error: `registry "${entry.registryName}" is no longer configured`
+	};
+	const schema = await fetchJsonObject(rawBase, entry.path, "schema.json", "schema.json");
+	if (!schema.ok) return schema;
+	const meta = await fetchJsonObject(rawBase, entry.path, "meta.json", "meta.json");
+	if (!meta.ok) return meta;
+	return {
+		ok: true,
+		entry,
+		schema: schema.value,
+		meta: meta.value
+	};
+}
+//#endregion
+//#region src/collection/registry/server/importCollection.ts
+var MANIFEST_FILE = "manifest.json";
+var STATUS_BAD_GATEWAY = 502;
+/** A manifest entry must be a relative path that stays inside the collection dir:
+*  no absolute paths, no backslashes, no empty / `.` / `..` segments. */
+function isSafeBundlePath(rel) {
+	if (typeof rel !== "string" || rel.length === 0) return false;
+	if (rel.startsWith("/") || rel.includes("\\")) return false;
+	return !rel.split("/").some((segment) => segment === "" || segment === "." || segment === "..");
+}
+function parseManifest(value) {
+	if (!isRecord(value) || !Array.isArray(value.files)) return {
+		ok: false,
+		error: "manifest is missing a files[] array"
+	};
+	const unsafe = value.files.find((file) => !isSafeBundlePath(file));
+	if (unsafe !== void 0) return {
+		ok: false,
+		error: `manifest contains an unsafe path: ${String(unsafe)}`
+	};
+	return {
+		ok: true,
+		files: value.files.filter(isSafeBundlePath)
+	};
+}
+/** `data/collections/<localSlug>/items` — the host owns dataPath, never the
+*  registry's authored value, so imported collections can't collide on disk. */
+function normalizedDataPath(localSlug) {
+	return `data/collections/${localSlug}/items`;
+}
+function withNormalizedDataPath(schema, localSlug) {
+	return {
+		...schema,
+		dataPath: normalizedDataPath(localSlug)
+	};
+}
+async function fetchManifest(entry) {
+	const rawBase = rawBaseForEntry(entry);
+	if (!rawBase) return {
+		ok: false,
+		status: STATUS_BAD_GATEWAY,
+		error: `registry "${entry.registryName}" is no longer configured`
+	};
+	const file = await fetchCollectionFile(rawBase, entry.path, MANIFEST_FILE);
+	if (!file.ok) return {
+		ok: false,
+		status: file.status,
+		error: `manifest.json: ${file.error}`
+	};
+	const obj = parseJsonObject(file.text, "manifest.json");
+	if (!obj.ok) return {
+		ok: false,
+		status: STATUS_BAD_GATEWAY,
+		error: obj.error
+	};
+	const manifest = parseManifest(obj.value);
+	if (!manifest.ok) return {
+		ok: false,
+		status: STATUS_BAD_GATEWAY,
+		error: manifest.error
+	};
+	return {
+		ok: true,
+		files: manifest.files
+	};
+}
+/** Fetch every manifest file. Paths are already safety-checked by parseManifest. */
+async function fetchBundle(entry, fileList) {
+	const rawBase = rawBaseForEntry(entry);
+	if (!rawBase) return {
+		ok: false,
+		status: STATUS_BAD_GATEWAY,
+		error: `registry "${entry.registryName}" is no longer configured`
+	};
+	const files = /* @__PURE__ */ new Map();
+	for (const rel of fileList) {
+		const file = await fetchCollectionFile(rawBase, entry.path, rel);
+		if (!file.ok) return {
+			ok: false,
+			status: file.status,
+			error: `${rel}: ${file.error}`
+		};
+		files.set(rel, file.text);
+	}
+	return {
+		ok: true,
+		files
+	};
+}
+//#endregion
+//#region src/collection/registry/server/importWriter.ts
+var ORIGIN_FILE = ".origin.json";
+var SEED_PREFIX = "seed/items/";
+var SCHEMA_FILE = "schema.json";
+var SKILL_FILE = "SKILL.md";
+var STATUS_NOT_FOUND$1 = 404;
+var STATUS_CONFLICT = 409;
+var STATUS_UNPROCESSABLE = 422;
+async function statType(target) {
+	try {
+		return (await stat(target)).isDirectory() ? "dir" : "other";
+	} catch (err) {
+		if (isRecord(err) && err.code === "ENOENT") return "absent";
+		return "other";
+	}
+}
+async function isEmptyOrAbsentDir(target) {
+	try {
+		return (await readdir(target)).length === 0;
+	} catch {
+		return true;
+	}
+}
+function originMatches(origin, registry, author, slug) {
+	return isRecord(origin) && origin.registry === registry && origin.author === author && origin.slug === slug;
+}
+async function readOrigin(targetDir) {
+	try {
+		return JSON.parse(await readFile(path.join(targetDir, ORIGIN_FILE), "utf-8"));
+	} catch {
+		return null;
+	}
+}
+var MAX_SLUG_ATTEMPTS = 1e4;
+var renameCandidate = (slug, attempt) => attempt === 0 ? slug : `${slug}-${attempt + 1}`;
+function isRenameOf(name, slug) {
+	if (name === slug) return true;
+	if (!name.startsWith(`${slug}-`)) return false;
+	const suffix = name.slice(slug.length + 1);
+	return suffix.length > 0 && /^\d+$/.test(suffix);
+}
+async function findMatchingInstall(skillsDir, registry, entry) {
+	const names = await readdir(skillsDir).catch(() => []);
+	for (const name of names) {
+		if (!isRenameOf(name, entry.slug)) continue;
+		const dir = path.join(skillsDir, name);
+		if (await statType(dir) === "dir" && originMatches(await readOrigin(dir), registry, entry.author, entry.slug)) return name;
+	}
+	return null;
+}
+async function resolveTarget(workspaceRoot, registry, entry) {
+	const existing = await findMatchingInstall(path.dirname(dataSkillDir(workspaceRoot, entry.slug)), registry, entry);
+	if (existing) return {
+		targetDir: dataSkillDir(workspaceRoot, existing),
+		localSlug: existing,
+		updated: true
+	};
+	for (let attempt = 0; attempt < MAX_SLUG_ATTEMPTS; attempt += 1) {
+		const localSlug = renameCandidate(entry.slug, attempt);
+		const sourceAbsent = await statType(dataSkillDir(workspaceRoot, localSlug)) === "absent";
+		const mirrorAbsent = await statType(claudeSkillDir(workspaceRoot, localSlug)) === "absent";
+		if (sourceAbsent && mirrorAbsent) return {
+			targetDir: dataSkillDir(workspaceRoot, localSlug),
+			localSlug,
+			updated: false
+		};
+	}
+	return { conflict: `couldn't find an available slug for '${entry.slug}'` };
+}
+function validateAndNormalize(bundle, localSlug, workspaceRoot) {
+	if (bundle.get(SKILL_FILE) === void 0) return { error: "bundle is missing SKILL.md" };
+	const schemaText = bundle.get(SCHEMA_FILE);
+	if (schemaText === void 0) return { error: "bundle is missing schema.json" };
+	let parsedJson;
+	try {
+		parsedJson = JSON.parse(schemaText);
+	} catch {
+		return { error: "schema.json is not valid JSON" };
+	}
+	const parsed = CollectionSchemaZ.safeParse(parsedJson);
+	if (!parsed.success) return { error: `schema.json failed validation: ${parsed.error.issues[0]?.message ?? "invalid"}` };
+	const schema = {
+		...parsed.data,
+		dataPath: normalizedDataPath(localSlug)
+	};
+	const acceptance = acceptParsedSchema(schema, {
+		source: "project",
+		workspaceRoot
+	});
+	if (!acceptance.ok) return { error: `schema.json rejected: ${acceptance.reason}` };
+	return { schema };
+}
+async function writeBundleFiles(targetDir, bundle, schema) {
+	for (const [rel, content] of bundle) {
+		if (rel.startsWith(SEED_PREFIX)) continue;
+		const dest = path.join(targetDir, ...rel.split("/"));
+		if (dest !== targetDir && !dest.startsWith(targetDir + path.sep)) continue;
+		await mkdir(path.dirname(dest), { recursive: true });
+		await writeFile(dest, rel === SCHEMA_FILE ? `${JSON.stringify(schema, null, 2)}\n` : content, "utf-8");
+	}
+}
+async function materializeSeed(dataDir, bundle) {
+	const seedEntries = [...bundle].filter(([rel]) => rel.startsWith(SEED_PREFIX));
+	if (seedEntries.length === 0) return {
+		written: 0,
+		skipped: false
+	};
+	if (!await isEmptyOrAbsentDir(dataDir)) return {
+		written: 0,
+		skipped: true
+	};
+	await mkdir(dataDir, { recursive: true });
+	let written = 0;
+	for (const [rel, content] of seedEntries) {
+		const fileName = rel.slice(11);
+		if (fileName.includes("/") || safeRecordId(fileName.replace(/\.json$/, "")) === null) {
+			log.warn("collections-registry", "skipped unsafe seed record", { rel });
+			continue;
+		}
+		await writeFile(path.join(dataDir, fileName), content, "utf-8");
+		written += 1;
+	}
+	return {
+		written,
+		skipped: false
+	};
+}
+/** Compute the set of bundle-relative paths that should land in `.claude/skills/<slug>/`.
+*  Matches the bridge allowlist exactly — SKILL.md, schema.json,
+*  `templates/<safe>` — so anything else (seed, meta.json, views, README,
+*  assets) stays source-side. */
+function bridgeAllowlistFiles(bundle) {
+	const wanted = /* @__PURE__ */ new Set([SKILL_FILE, SCHEMA_FILE]);
+	for (const rel of bundle.keys()) {
+		if (rel === SKILL_FILE || rel === SCHEMA_FILE) continue;
+		if (rel.startsWith(SEED_PREFIX)) continue;
+		if (!isSafeActionTemplatePath(rel)) continue;
+		wanted.add(rel);
+	}
+	return wanted;
+}
+/** Recursively list every file under `root`, returned as forward-slash paths
+*  relative to `root`. Empty list when `root` doesn't exist. Used to spot
+*  mirror files left over from a previous install so we can prune them after
+*  writing the new ones. */
+async function listFilesRecursive(root, prefix = "") {
+	const entries = await readdir(prefix ? path.join(root, ...prefix.split("/")) : root, { withFileTypes: true }).catch(() => []);
+	const out = [];
+	for (const entry of entries) {
+		const rel = prefix ? `${prefix}/${entry.name}` : entry.name;
+		if (entry.isFile()) out.push(rel);
+		else if (entry.isDirectory()) out.push(...await listFilesRecursive(root, rel));
+	}
+	return out;
+}
+async function mirrorToClaudeSkills(workspaceRoot, localSlug, bundle) {
+	const wanted = bridgeAllowlistFiles(bundle);
+	for (const rel of wanted) mirrorSkillWrite(workspaceRoot, {
+		slug: localSlug,
+		relSegments: rel.split("/")
+	});
+	const mirrorRoot = claudeSkillDir(workspaceRoot, localSlug);
+	const existing = await listFilesRecursive(mirrorRoot);
+	for (const rel of existing) {
+		if (wanted.has(rel)) continue;
+		await rm(path.join(mirrorRoot, ...rel.split("/")), { force: true }).catch(() => void 0);
+	}
+}
+async function writeImportedCollection(params) {
+	const { registry, entry, bundle, workspaceRoot, nowIso } = params;
+	const target = await resolveTarget(workspaceRoot, registry, entry);
+	if ("conflict" in target) return {
+		ok: false,
+		status: STATUS_CONFLICT,
+		error: target.conflict
+	};
+	const { localSlug } = target;
+	const dataDir = path.join(workspaceRoot, ...normalizedDataPath(localSlug).split("/"));
+	if (await statType(dataDir) === "other") return {
+		ok: false,
+		status: STATUS_CONFLICT,
+		error: `data path for slug '${localSlug}' exists and is not a directory`
+	};
+	const validated = validateAndNormalize(bundle, localSlug, workspaceRoot);
+	if ("error" in validated) return {
+		ok: false,
+		status: STATUS_UNPROCESSABLE,
+		error: validated.error
+	};
+	const skillsParent = path.dirname(target.targetDir);
+	await mkdir(skillsParent, { recursive: true });
+	const staging = path.join(skillsParent, `.importing-${localSlug}`);
+	const backup = path.join(skillsParent, `.backup-${localSlug}`);
+	await rm(staging, {
+		recursive: true,
+		force: true
+	});
+	await rm(backup, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(staging, { recursive: true });
+	await writeBundleFiles(staging, bundle, validated.schema);
+	const origin = {
+		registry,
+		author: entry.author,
+		slug: entry.slug,
+		version: entry.version,
+		contentSha: entry.contentSha,
+		importedAt: nowIso
+	};
+	await writeFileAtomic(path.join(staging, ORIGIN_FILE), `${JSON.stringify(origin, null, 2)}\n`);
+	if (target.updated) await rename(target.targetDir, backup);
+	try {
+		await rename(staging, target.targetDir);
+	} catch (err) {
+		if (target.updated) await rename(backup, target.targetDir).catch(() => void 0);
+		throw err;
+	}
+	await rm(backup, {
+		recursive: true,
+		force: true
+	});
+	try {
+		await mirrorToClaudeSkills(workspaceRoot, localSlug, bundle);
+	} catch (err) {
+		log.warn("collections-registry", "mirror to .claude/skills/ failed (data/skills write succeeded; prior mirror left intact)", {
+			localSlug,
+			error: errorMessage(err)
+		});
+	}
+	const seed = await materializeSeed(dataDir, bundle);
+	return {
+		ok: true,
+		localSlug,
+		updated: target.updated,
+		seedWritten: seed.written,
+		seedSkipped: seed.skipped
+	};
+}
+async function performImport(author, slug, workspaceRoot, registry = null) {
+	const merged = await fetchAllRegistries();
+	let entry;
+	for (const reg of merged) {
+		if (registry !== null && reg.name !== registry) continue;
+		entry = reg.entries.find((candidate) => candidate.author === author && candidate.slug === slug);
+		if (entry) break;
+	}
+	if (!entry) return {
+		ok: false,
+		status: STATUS_NOT_FOUND$1,
+		error: `unknown collection: ${author}/${slug}`
+	};
+	const manifest = await fetchManifest(entry);
+	if (!manifest.ok) return {
+		ok: false,
+		status: manifest.status,
+		error: manifest.error
+	};
+	const bundle = await fetchBundle(entry, manifest.files);
+	if (!bundle.ok) return {
+		ok: false,
+		status: bundle.status,
+		error: bundle.error
+	};
+	try {
+		return await writeImportedCollection({
+			registry: entry.registryName,
+			entry,
+			bundle: bundle.files,
+			workspaceRoot,
+			nowIso: (/* @__PURE__ */ new Date()).toISOString()
+		});
+	} catch (err) {
+		log.warn("collections-registry", "import write failed", {
+			author,
+			slug,
+			registry: entry.registryName,
+			error: errorMessage(err)
+		});
+		return {
+			ok: false,
+			status: 500,
+			error: `import failed: ${errorMessage(err)}`
+		};
+	}
+}
+//#endregion
+//#region src/collection/registry/server/exportCollection.ts
+var EXPORT_BASE = "data/registry-export";
+var BUNDLE_FILES = ["SKILL.md", "schema.json"];
+var OPTIONAL_FILES = ["screenshot.png"];
+var BUNDLE_DIRS = ["views", "templates"];
+var AUTHOR_RE = /^[A-Za-z0-9][A-Za-z0-9-]{0,38}$/;
+var SLUG_RE = /^[a-z0-9][a-z0-9-]{0,62}$/;
+var STATUS_BAD_REQUEST = 400;
+var SECRET_PATTERNS = [
+	/AKIA[0-9A-Z]{16}/,
+	/gh[pousr]_[A-Za-z0-9]{20,}/,
+	/-----BEGIN [A-Z ]*PRIVATE KEY-----/,
+	/sk-[A-Za-z0-9]{20,}/,
+	/xox[baprs]-[A-Za-z0-9-]{10,}/
+];
+var hasSecret = (text) => SECRET_PATTERNS.some((pattern) => pattern.test(text));
+var EMAIL_RE = /[\w.%+-]{1,64}@[\w-]{1,255}\.[a-z]{2,24}/i;
+async function pathKind(target) {
+	try {
+		return (await stat(target)).isDirectory() ? "dir" : "file";
+	} catch {
+		return "absent";
+	}
+}
+async function copyBundle(skillDir, outDir) {
+	let count = 0;
+	for (const file of [...BUNDLE_FILES, ...OPTIONAL_FILES]) {
+		const src = path.join(skillDir, file);
+		if (await pathKind(src) !== "file") continue;
+		await cp(src, path.join(outDir, file));
+		count += 1;
+	}
+	for (const dir of BUNDLE_DIRS) {
+		const src = path.join(skillDir, dir);
+		if (await pathKind(src) !== "dir") continue;
+		await cp(src, path.join(outDir, dir), { recursive: true });
+		count += (await readdir(src)).filter((name) => !name.startsWith(".")).length;
+	}
+	return count;
+}
+async function exportSeed(dataDir, outDir) {
+	let names;
+	try {
+		names = (await readdir(dataDir)).filter((name) => name.endsWith(".json"));
+	} catch {
+		return {
+			count: 0,
+			skipped: 0,
+			warnings: []
+		};
+	}
+	if (names.length === 0) return {
+		count: 0,
+		skipped: 0,
+		warnings: []
+	};
+	const seedDir = path.join(outDir, "seed", "items");
+	await mkdir(seedDir, { recursive: true });
+	const warnings = [];
+	let count = 0;
+	let skipped = 0;
+	for (const name of names) {
+		const base = path.basename(name);
+		const text = await readFile(path.join(dataDir, base), "utf-8");
+		if (hasSecret(text)) {
+			warnings.push(`skipped ${base}: contains a possible credential`);
+			skipped += 1;
+			continue;
+		}
+		if (EMAIL_RE.test(text)) warnings.push(`${base}: contains a possible email/PII (kept — your responsibility)`);
+		await writeFile(path.join(seedDir, base), text, "utf-8");
+		count += 1;
+	}
+	return {
+		count,
+		skipped,
+		warnings
+	};
+}
+function resolveWithin(root, ...segments) {
+	const resolvedRoot = path.resolve(root);
+	const target = path.resolve(resolvedRoot, ...segments);
+	return target === resolvedRoot || target.startsWith(resolvedRoot + path.sep) ? target : null;
+}
+async function findMissingRequired(skillDir) {
+	for (const file of BUNDLE_FILES) if (await pathKind(path.join(skillDir, file)) !== "file") return file;
+	return null;
+}
+async function writeCollectionExport(params) {
+	const { workspaceRoot, skillDir, dataDir, meta, includeSeed } = params;
+	if (!AUTHOR_RE.test(meta.author)) return {
+		ok: false,
+		status: STATUS_BAD_REQUEST,
+		error: `author '${meta.author}' is not a valid GitHub login`
+	};
+	if (!SLUG_RE.test(meta.slug)) return {
+		ok: false,
+		status: STATUS_BAD_REQUEST,
+		error: `slug '${meta.slug}' is invalid`
+	};
+	const wsRoot = path.resolve(workspaceRoot);
+	const outDir = resolveWithin(path.join(wsRoot, ...EXPORT_BASE.split("/")), meta.author, meta.slug);
+	const safeSkillDir = resolveWithin(wsRoot, skillDir);
+	const safeDataDir = resolveWithin(wsRoot, dataDir);
+	if (!outDir || !safeSkillDir || !safeDataDir) return {
+		ok: false,
+		status: STATUS_BAD_REQUEST,
+		error: "resolved path escapes the workspace"
+	};
+	const missing = await findMissingRequired(safeSkillDir);
+	if (missing) return {
+		ok: false,
+		status: STATUS_BAD_REQUEST,
+		error: `required bundle file missing: ${missing}`
+	};
+	await rm(outDir, {
+		recursive: true,
+		force: true
+	});
+	await mkdir(outDir, { recursive: true });
+	const bundleCount = await copyBundle(safeSkillDir, outDir);
+	const seed = includeSeed ? await exportSeed(safeDataDir, outDir) : {
+		count: 0,
+		skipped: 0,
+		warnings: []
+	};
+	const metaOut = {
+		...meta,
+		...seed.count > 0 ? { dataConsent: true } : {}
+	};
+	await writeFile(path.join(outDir, "meta.json"), `${JSON.stringify(metaOut, null, 2)}\n`, "utf-8");
+	log.info("collections-registry", "exported collection", {
+		slug: meta.slug,
+		author: meta.author,
+		seedCount: seed.count
+	});
+	return {
+		ok: true,
+		outputPath: path.relative(wsRoot, outDir).split(path.sep).join("/"),
+		fileCount: bundleCount + 1,
+		seedCount: seed.count,
+		seedSkipped: seed.skipped,
+		warnings: seed.warnings
+	};
+}
+//#endregion
+//#region src/collection/registry/server/skillDescription.ts
+var FENCE = "---";
+var KEY = "description:";
+var BLOCK_SCALAR_INDICATORS = /* @__PURE__ */ new Set([
+	"|",
+	">",
+	"|-",
+	">-",
+	"|+",
+	">+"
+]);
+var isYamlSpace = (char) => char === " " || char === "	";
+var isOnlyTrailingComment = (rest) => {
+	const trimmed = rest.trimStart();
+	return trimmed === "" || trimmed.startsWith("#");
+};
+var DOUBLE_QUOTE_ESCAPES = {
+	n: "\n",
+	t: "	"
+};
+var unescapeDoubleQuote = (next) => DOUBLE_QUOTE_ESCAPES[next] ?? next;
+function parseDoubleQuoted(value) {
+	const out = [];
+	for (let i = 1; i < value.length; i += 1) {
+		const char = value[i];
+		if (char === "\\" && i + 1 < value.length) {
+			out.push(unescapeDoubleQuote(value[i + 1]));
+			i += 1;
+			continue;
+		}
+		if (char === "\"") return isOnlyTrailingComment(value.slice(i + 1)) ? out.join("") : null;
+		out.push(char);
+	}
+	return null;
+}
+function parseSingleQuoted(value) {
+	const out = [];
+	for (let i = 1; i < value.length; i += 1) {
+		const char = value[i];
+		if (char === "'") {
+			if (value[i + 1] === "'") {
+				out.push("'");
+				i += 1;
+				continue;
+			}
+			return isOnlyTrailingComment(value.slice(i + 1)) ? out.join("") : null;
+		}
+		out.push(char);
+	}
+	return null;
+}
+function stripPlainComment(value) {
+	for (let i = 0; i < value.length; i += 1) if (value[i] === "#" && (i === 0 || isYamlSpace(value[i - 1]))) return value.slice(0, i);
+	return value;
+}
+/** Extract the frontmatter `description` from raw SKILL.md text. Returns "" when
+*  there's no `---` envelope, no `description:` key, or the value is a block
+*  scalar indicator. */
+function parseSkillDescription(raw) {
+	const lines = raw.split(/\r?\n/);
+	if (lines[0]?.trim() !== FENCE) return "";
+	for (let i = 1; i < lines.length; i += 1) {
+		const line = lines[i];
+		if (line.trim() === FENCE) return "";
+		if (!line.startsWith(KEY)) continue;
+		const value = line.slice(12).trim();
+		if (value === "" || BLOCK_SCALAR_INDICATORS.has(value)) return "";
+		if (value.startsWith("\"")) return parseDoubleQuoted(value) ?? "";
+		if (value.startsWith("'")) return parseSingleQuoted(value) ?? "";
+		return stripPlainComment(value).trim();
+	}
+	return "";
+}
+//#endregion
+//#region src/collection/registry/server/performExport.ts
+var STATUS_NOT_FOUND = 404;
+async function readJsonObject(file) {
+	try {
+		const parsed = JSON.parse(await readFile(file, "utf-8"));
+		return isRecord(parsed) ? parsed : null;
+	} catch {
+		return null;
+	}
+}
+async function performExport(slug, opts, workspaceRoot) {
+	const collection = await loadCollection(slug);
+	if (!collection) return {
+		ok: false,
+		status: STATUS_NOT_FOUND,
+		error: `collection not found: ${slug}`
+	};
+	const skillMd = await readFile(path.join(collection.skillDir, "SKILL.md"), "utf-8").catch(() => "");
+	const existingMeta = await readJsonObject(path.join(collection.skillDir, "meta.json"));
+	const meta = {
+		author: opts.author,
+		slug,
+		version: typeof existingMeta?.version === "string" ? existingMeta.version : "1.0.0",
+		title: collection.schema.title,
+		description: parseSkillDescription(skillMd),
+		tags: [],
+		license: opts.license
+	};
+	return writeCollectionExport({
+		workspaceRoot,
+		skillDir: collection.skillDir,
+		dataDir: collection.dataDir,
+		meta,
+		includeSeed: opts.includeSeed
+	});
+}
+//#endregion
+//#region src/collection/registry/server/index.ts
+/** Build the merged Discover catalog response (`GET …collectionsRegistry.list`).
+*  Wraps `fetchAllRegistries` with the per-registry summary + stale-flag shaping
+*  every host needs, so a downstream host doesn't re-implement the mapping. */
+async function listRegistry() {
+	const merged = await fetchAllRegistries();
+	return {
+		registries: merged.map((reg) => ({
+			name: reg.name,
+			status: reg.status,
+			generatedAt: reg.generatedAt,
+			error: reg.error,
+			entryCount: reg.entries.length
+		})),
+		stale: merged.some((reg) => reg.status === "stale"),
+		collections: merged.flatMap((reg) => reg.entries)
+	};
+}
+/** Import a registry collection and return the host-facing response shape
+*  (`POST …collectionsRegistry.import`). On failure carries the HTTP status so
+*  the host route can pass it straight through. */
+async function importRegistry(author, slug, workspaceRoot, registry = null) {
+	const result = await performImport(author, slug, workspaceRoot, registry);
+	if (!result.ok) return {
+		ok: false,
+		status: result.status,
+		error: result.error
+	};
+	return {
+		ok: true,
+		response: {
+			localSlug: result.localSlug,
+			updated: result.updated,
+			seedWritten: result.seedWritten,
+			seedSkipped: result.seedSkipped
+		}
+	};
+}
+//#endregion
+export { CACHE_TTL_MS, EXPORT_BASE, OFFICIAL_REGISTRY_NAME, STALE_RETRY_BACKOFF_MS, claudeSkillDir, collectionFileUrl, dataSkillDir, fetchAllRegistries, fetchBundle, fetchCollectionFile, fetchManifest, fetchRegistryIndex, findRegistry, importRegistry, isSafeBundlePath, listRegistries, listRegistry, loadRegistriesConfig, normalizedDataPath, parseJsonObject, parseManifest, parseRegistriesConfig, parseRegistryIndex, parseSkillDescription, performExport, performImport, previewCollection, rawBaseForEntry, resetRegistryCache, withNormalizedDataPath, writeCollectionExport, writeImportedCollection };
+
+//# sourceMappingURL=index.js.map