@powerhousedao/registry 6.2.3-dev.30 → 6.2.3-dev.31

package/README.md

@@ -32,6 +32,36 @@ If the package is not published locally, Verdaccio transparently proxies metadat
 
 Responses carry caching headers keyed on the request shape. Version-pinned requests (`<pkg>@1.2.3/...`) are served `Cache-Control: public, max-age=31536000, immutable`; moving requests (a dist-tag like `@dev`/`@latest`, or untagged) get `public, max-age=60, must-revalidate`. A version-derived weak `ETag` is sent, and a matching `If-None-Match` returns `304`. When the upstream metadata lookup fails (as opposed to a genuine not-found), the endpoint serves the latest cached version if present, otherwise responds `503` rather than a cacheable `404`.
 
+### Pieces
+
+A reactor's workflow runtime reads pieces from these endpoints, ahead of the
+Activepieces catalogue.
+
+#### `GET /pieces`
+
+The catalog of pieces that published packages ship, in the shape of
+cloud.activepieces.com's list endpoint. `?suggestionType=ACTION_AND_TRIGGER`
+adds suggested actions and triggers.
+
+#### `GET /pieces/<name>` and `GET /pieces/<name>?version=<v>`
+
+One piece's detail: the latest version, or the one named. An unknown version
+returns `404` with `available`, the versions the registry has.
+
+#### `GET /pieces/<name>/versions`
+
+Every version of the piece: `[{ version, packageVersion, publishedAt }]`. A
+piece's version is always the version of the package that ships it.
+
+#### `GET /-/pieces/bundled/<file>.tgz`
+
+The piece directory as an npm-shaped tarball, the file a reactor's piece worker
+downloads. The file name is the piece name with `/` replaced by `-`, then
+`-<version>`, as cdn.activepieces.com names its own. It is served immutable.
+
+Piece names under `@activepieces/` are reserved: a package that claims one is
+refused.
+
 ### Publish Notifications
 
 When a package is published, the registry can notify subscribers in real time via Server-Sent Events (SSE) and webhooks.

package/dist/cli.mjs

@@ -108,27 +108,48 @@ function wasStoreLoaded(token) {
 }
 //#endregion
 //#region src/semver.ts
-/**
-* Compare two semver version strings for sorting.
-* Returns negative if a < b, positive if a > b, 0 if equal.
-*
-* Handles numeric component comparison (so "1.0.10" > "1.0.9")
-* and prerelease ordering (release > prerelease).
-*/
+function splitVersion(version) {
+	const withoutBuild = version.split("+", 1)[0];
+	const dash = withoutBuild.indexOf("-");
+	const core = dash === -1 ? withoutBuild : withoutBuild.slice(0, dash);
+	const pre = dash === -1 ? "" : withoutBuild.slice(dash + 1);
+	return {
+		core: core.split(".").map(Number),
+		pre: pre ? pre.split(".") : []
+	};
+}
+const NUMERIC = /^\d+$/;
+function comparePrerelease(a, b) {
+	for (let i = 0; i < Math.max(a.length, b.length); i++) {
+		if (i >= a.length) return -1;
+		if (i >= b.length) return 1;
+		const x = a[i];
+		const y = b[i];
+		const xNum = NUMERIC.test(x);
+		const yNum = NUMERIC.test(y);
+		if (xNum && yNum) {
+			const diff = Number(x) - Number(y);
+			if (diff !== 0) return diff;
+			continue;
+		}
+		if (xNum) return -1;
+		if (yNum) return 1;
+		if (x !== y) return x < y ? -1 : 1;
+	}
+	return 0;
+}
+/** Semver sort order: negative if a < b, positive if a > b, 0 if equal. */
 function compareSemver(a, b) {
-	const [coreA, preA] = a.split("-", 2);
-	const [coreB, preB] = b.split("-", 2);
-	const partsA = coreA.split(".").map(Number);
-	const partsB = coreB.split(".").map(Number);
-	for (let i = 0; i < Math.max(partsA.length, partsB.length); i++) {
-		const na = partsA[i] ?? 0;
-		const nb = partsB[i] ?? 0;
+	const va = splitVersion(a);
+	const vb = splitVersion(b);
+	for (let i = 0; i < Math.max(va.core.length, vb.core.length); i++) {
+		const na = va.core[i] ?? 0;
+		const nb = vb.core[i] ?? 0;
 		if (na !== nb) return na - nb;
 	}
-	if (!preA && preB) return 1;
-	if (preA && !preB) return -1;
-	if (preA && preB) return preA < preB ? -1 : preA > preB ? 1 : 0;
-	return 0;
+	if (va.pre.length === 0 && vb.pre.length > 0) return 1;
+	if (va.pre.length > 0 && vb.pre.length === 0) return -1;
+	return comparePrerelease(va.pre, vb.pre);
 }
 //#endregion
 //#region src/cdn.ts
@@ -167,12 +188,15 @@ function isExactVersion(tag) {
 	return !!tag && /^\d+\.\d+\.\d+(?:-[0-9A-Za-z.-]+)?(?:\+[0-9A-Za-z.-]+)?$/.test(tag);
 }
 var CdnCache = class {
-	registryUrl;
 	cdnCachePath;
 	#extractionLocks = /* @__PURE__ */ new Map();
+	#registryUrl;
 	constructor(registryUrl, cdnCachePath) {
-		this.registryUrl = registryUrl;
 		this.cdnCachePath = cdnCachePath;
+		this.#registryUrl = registryUrl;
+	}
+	get registryUrl() {
+		return typeof this.#registryUrl === "function" ? this.#registryUrl() : this.#registryUrl;
 	}
 	async getFileByVersion(packageName, version, filePath) {
 		const versionDir = path.join(this.cdnCachePath, packageName, version);
@@ -358,9 +382,15 @@ function readPackageMetadata(storagePath, packageName) {
 		const distTags = parsed["dist-tags"];
 		const versions = (parsed.versions ? Object.keys(parsed.versions) : []).slice().sort(compareSemver);
 		const locallyPublished = !!parsed._attachments && Object.keys(parsed._attachments).length > 0;
+		const time = {};
+		for (const version of versions) {
+			const at = parsed.time?.[version];
+			if (typeof at === "string") time[version] = at;
+		}
 		return {
 			distTags: distTags && Object.keys(distTags).length > 0 ? distTags : void 0,
 			versions: versions.length > 0 ? versions : void 0,
+			time,
 			locallyPublished
 		};
 	} catch {
@@ -396,16 +426,19 @@ function readPackageJsonVersion(dir) {
 		return;
 	}
 }
-function getLatestVersionDir(pkgDir) {
+/** Extracted version directories of a package, oldest first. */
+function listVersionDirs(pkgDir) {
 	let entries;
 	try {
 		entries = fs.readdirSync(pkgDir, { withFileTypes: true });
 	} catch {
-		return null;
+		return [];
 	}
-	const versions = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+	return entries.filter((e) => e.isDirectory() && !e.name.startsWith(".")).map((e) => e.name).sort(compareSemver);
+}
+function getLatestVersionDir(pkgDir) {
+	const versions = listVersionDirs(pkgDir);
 	if (versions.length === 0) return null;
-	versions.sort(compareSemver);
 	return path.join(pkgDir, versions[versions.length - 1]);
 }
 function loadPackage(cdnCachePath, name, version, storagePath) {
@@ -454,18 +487,23 @@ function getDocumentTypesFromManifest(manifest) {
 }
 function readPackageDir(cdnCachePath, dirName, storagePath) {
 	const pkgDir = path.join(cdnCachePath, dirName);
-	const manifestDir = getLatestVersionDir(pkgDir) ?? pkgDir;
+	const versionDirs = listVersionDirs(pkgDir);
+	const latest = versionDirs.at(-1);
+	const manifestDir = latest ? path.join(pkgDir, latest) : pkgDir;
 	const manifest = readManifest(manifestDir);
 	const name = manifest?.name || dirName;
-	const { distTags, versions, locallyPublished } = readPackageMetadata(storagePath, name);
+	const { distTags, versions, time, locallyPublished } = readPackageMetadata(storagePath, name);
 	return {
 		dirName,
+		packageDir: pkgDir,
 		manifestDir,
+		versionDirs,
 		manifest,
 		name,
 		version: readPackageJsonVersion(manifestDir),
 		distTags,
 		versions,
+		time,
 		locallyPublished
 	};
 }
@@ -522,12 +560,17 @@ function findPackagesByDocumentType(packagesDir, documentType) {
 //#endregion
 //#region src/pieces.ts
 const gunzip$1 = promisify(gunzip);
+/** Piece names in this scope belong to Activepieces; no package may claim one. */
+const RESERVED_PIECE_SCOPE = "@activepieces/";
 const INDEX_TTL_MS = 3e4;
 const indexes = /* @__PURE__ */ new Map();
+const versionPieces = /* @__PURE__ */ new Map();
 const descriptors = /* @__PURE__ */ new Map();
+const materializing = /* @__PURE__ */ new Map();
 /** Drop the cached index and descriptors — a publish or unpublish moved them. */
 function invalidatePieceIndex() {
 	indexes.clear();
+	versionPieces.clear();
 	descriptors.clear();
 }
 function indexKey(cdnCachePath, storagePath) {
@@ -536,34 +579,77 @@ function indexKey(cdnCachePath, storagePath) {
 function piecesOf(manifest) {
 	return manifest?.pieces ?? [];
 }
-function toIndexEntry(piece, packageName, packageVersion, packageDir) {
-	const { id, version, bundle } = piece;
-	if (!id || !version || !bundle) return null;
+function piecesAt(versionDir) {
+	const hit = versionPieces.get(versionDir);
+	if (hit) return hit;
+	if (!fs.existsSync(path.join(versionDir, "package.json"))) return [];
+	const manifest = readManifest(versionDir);
+	if (!manifest) return [];
+	const pieces = piecesOf(manifest);
+	versionPieces.set(versionDir, pieces);
+	return pieces;
+}
+function toIndexEntry(piece, packageName, packageVersion, packageDir, publishedAt) {
+	const { id, bundle } = piece;
+	if (!id || !bundle) return null;
 	return {
 		name: id,
 		displayName: piece.name || id,
 		...piece.description ? { description: piece.description } : {},
-		version,
+		version: packageVersion,
 		packageName,
 		packageVersion,
 		packageDir,
 		bundle,
-		descriptor: piece.descriptor ?? `${bundle}/descriptor.json`
+		descriptor: piece.descriptor ?? `${bundle}/descriptor.json`,
+		...publishedAt ? { publishedAt } : {}
 	};
 }
+function indexVersion(index, pkg, version) {
+	const versionDir = path.join(pkg.dir, version);
+	const held = [];
+	for (const piece of piecesAt(versionDir)) {
+		const entry = toIndexEntry(piece, pkg.name, version, versionDir, pkg.publishedAt[version]);
+		if (!entry) continue;
+		let line = index.get(entry.name);
+		if (line && line.packageName !== pkg.name) {
+			console.warn(`[registry] piece "${entry.name}" is claimed by both ${line.packageName} and ${pkg.name}; keeping ${line.packageName}`);
+			continue;
+		}
+		if (!line) {
+			line = {
+				packageName: pkg.name,
+				versions: /* @__PURE__ */ new Map(),
+				pending: /* @__PURE__ */ new Set(),
+				publishedAt: pkg.publishedAt
+			};
+			index.set(entry.name, line);
+		}
+		line.versions.set(version, entry);
+		held.push(entry.name);
+	}
+	return held;
+}
 function buildPieceIndex(cdnCachePath, storagePath) {
 	const index = /* @__PURE__ */ new Map();
-	for (const pkg of scanPackageDirs(cdnCachePath, storagePath)) {
-		if (pkg.locallyPublished === false) continue;
-		for (const piece of piecesOf(pkg.manifest)) {
-			const entry = toIndexEntry(piece, pkg.name, pkg.version, pkg.manifestDir);
-			if (!entry) continue;
-			const claimed = index.get(entry.name);
-			if (claimed && claimed.packageName !== entry.packageName) {
-				console.warn(`[registry] piece "${entry.name}" is claimed by both ${claimed.packageName} and ${entry.packageName}; keeping ${claimed.packageName}`);
-				continue;
-			}
-			index.set(entry.name, entry);
+	for (const scanned of scanPackageDirs(cdnCachePath, storagePath)) {
+		if (scanned.locallyPublished === false) continue;
+		const pkg = {
+			name: scanned.name,
+			dir: scanned.packageDir,
+			publishedAt: scanned.time ?? {}
+		};
+		const names = /* @__PURE__ */ new Set();
+		const extracted = /* @__PURE__ */ new Set();
+		for (const version of scanned.versionDirs) {
+			const held = indexVersion(index, pkg, version);
+			if (fs.existsSync(path.join(pkg.dir, version, "package.json"))) extracted.add(version);
+			for (const name of held) names.add(name);
+		}
+		const pending = (scanned.versions ?? []).filter((v) => !extracted.has(v));
+		for (const name of names) {
+			const line = index.get(name);
+			for (const version of pending) line?.pending.add(version);
 		}
 	}
 	return index;
@@ -580,8 +666,77 @@ function pieceIndex(cdnCachePath, storagePath) {
 	});
 	return index;
 }
+/** The highest extracted version of a piece. */
+function latestOf(line) {
+	let latest;
+	for (const entry of line.versions.values()) if (!latest || compareSemver(entry.version, latest.version) > 0) latest = entry;
+	return latest;
+}
+/** The latest version of a piece. */
 function findPiece(cdnCachePath, name, storagePath) {
-	return pieceIndex(cdnCachePath, storagePath).get(name);
+	const line = pieceIndex(cdnCachePath, storagePath).get(name);
+	return line ? latestOf(line) : void 0;
+}
+async function materialize(extractor, cdnCachePath, index, line, version) {
+	const key = `${line.packageName}@${version}`;
+	const running = materializing.get(key);
+	if (running) return running;
+	const started = (async () => {
+		try {
+			await extractor.getFileByVersion(line.packageName, version, "package.json");
+		} catch (error) {
+			console.error(`[registry] failed to extract ${key}:`, error);
+			return;
+		}
+		const dir = path.join(cdnCachePath, line.packageName);
+		if (!fs.existsSync(path.join(dir, version, "package.json"))) return;
+		indexVersion(index, {
+			name: line.packageName,
+			dir,
+			publishedAt: line.publishedAt
+		}, version);
+		for (const other of index.values()) if (other.packageName === line.packageName) other.pending.delete(version);
+	})().finally(() => materializing.delete(key));
+	materializing.set(key, started);
+	return started;
+}
+async function materializeAll(extractor, cdnCachePath, index, line) {
+	await Promise.all([...line.pending].map((version) => materialize(extractor, cdnCachePath, index, line, version)));
+}
+function newestFirst(line) {
+	return [...line.versions.values()].sort((a, b) => compareSemver(b.version, a.version));
+}
+/** Every version of a piece, newest first; undefined for an unknown name. */
+async function pieceVersions(extractor, cdnCachePath, name, storagePath) {
+	const index = pieceIndex(cdnCachePath, storagePath);
+	const line = index.get(name);
+	if (!line) return void 0;
+	await materializeAll(extractor, cdnCachePath, index, line);
+	return newestFirst(line);
+}
+function versionSummary(entry) {
+	return {
+		version: entry.version,
+		packageVersion: entry.packageVersion,
+		publishedAt: entry.publishedAt ?? null
+	};
+}
+/** One exact version of a piece, extracting its package version if needed. */
+async function findPieceVersion(extractor, cdnCachePath, name, version, storagePath) {
+	const index = pieceIndex(cdnCachePath, storagePath);
+	const line = index.get(name);
+	if (!line) return { kind: "unknown-piece" };
+	if (!line.versions.has(version) && line.pending.has(version)) await materialize(extractor, cdnCachePath, index, line, version);
+	const entry = line.versions.get(version);
+	if (entry) return {
+		kind: "found",
+		entry
+	};
+	await materializeAll(extractor, cdnCachePath, index, line);
+	return {
+		kind: "unknown-version",
+		available: newestFirst(line).map((e) => e.version)
+	};
 }
 function insidePackage(entry, relative) {
 	const root = path.resolve(entry.packageDir);
@@ -638,19 +793,20 @@ function catalogEntry(entry, descriptor, suggestions) {
 		} : {}
 	};
 }
-/** The catalog, sorted by display name the way the editor renders it. */
+/** The catalog of latest versions, sorted by display name. */
 function pieceCatalog(cdnCachePath, options = {}) {
 	const entries = [];
-	for (const entry of pieceIndex(cdnCachePath, options.storagePath).values()) {
-		const descriptor = readDescriptor(entry);
-		if (!descriptor) continue;
+	for (const line of pieceIndex(cdnCachePath, options.storagePath).values()) {
+		const entry = latestOf(line);
+		const descriptor = entry ? readDescriptor(entry) : null;
+		if (!entry || !descriptor) continue;
 		entries.push(catalogEntry(entry, descriptor, options.suggestions === true));
 	}
 	return entries.sort((a, b) => a.displayName.localeCompare(b.displayName));
 }
-/** The CDN path of a file inside the package that ships the piece. */
+/** The CDN path of a file inside the package version that ships the piece. */
 function cdnPath(entry, relative) {
-	return `/-/cdn/${entry.packageVersion ? `${entry.packageName}@${entry.packageVersion}` : entry.packageName}/${relative}`;
+	return `/-/cdn/${entry.packageName}@${entry.packageVersion}/${relative}`;
 }
 /** The tarball filename cdn.activepieces.com would use for the same piece. */
 function pieceTarballName(name, version) {
@@ -659,7 +815,7 @@ function pieceTarballName(name, version) {
 function pieceTarballPath(entry) {
 	return `/-/pieces/bundled/${pieceTarballName(entry.name, entry.version)}`;
 }
-/** One piece: what provides it, and where its descriptor and bundle are. */
+/** One piece version: what provides it, and where its descriptor and bundle are. */
 function pieceDetail(entry, origin) {
 	const descriptor = readDescriptor(entry);
 	if (!descriptor) return null;
@@ -673,8 +829,17 @@ function pieceDetail(entry, origin) {
 		bundleUrl: `${origin}${pieceTarballPath(entry)}`
 	};
 }
-function findPieceByTarball(cdnCachePath, filename, storagePath) {
-	for (const entry of pieceIndex(cdnCachePath, storagePath).values()) if (pieceTarballName(entry.name, entry.version) === filename) return entry;
+async function findPieceByTarball(extractor, cdnCachePath, filename, storagePath) {
+	if (!filename.endsWith(".tgz")) return void 0;
+	const stem = filename.slice(0, -4);
+	for (const name of pieceIndex(cdnCachePath, storagePath).keys()) {
+		const prefix = `${name.replace("/", "-")}-`;
+		if (!stem.startsWith(prefix)) continue;
+		const version = stem.slice(prefix.length);
+		if (!isExactVersion(version)) continue;
+		const found = await findPieceVersion(extractor, cdnCachePath, name, version, storagePath);
+		if (found.kind === "found") return found.entry;
+	}
 }
 function listFiles(dir, prefix = "") {
 	const files = [];
@@ -776,7 +941,7 @@ function createWarmer(config, cdn) {
 	let warmInFlight = false;
 	let lastWarmAt = 0;
 	return async function warm() {
-		if (warmInFlight) return;
+		if (warmInFlight || config.port === 0) return;
 		if (Date.now() - lastWarmAt < WARM_INTERVAL_MS) return;
 		warmInFlight = true;
 		try {
@@ -840,6 +1005,15 @@ const MIME_TYPES = {
 	".html": "text/html",
 	".svg": "image/svg+xml"
 };
+function localUrl(config) {
+	return () => `http://localhost:${config.port}`;
+}
+function versionsRouteName(raw) {
+	if (!raw.endsWith("/versions")) return null;
+	const name = raw.slice(0, -9);
+	const slashes = name.split("/").length - 1;
+	return (name.startsWith("@") ? slashes === 1 : slashes === 0) && name !== "" ? name : null;
+}
 function getContentType(filePath) {
 	const ext = path.extname(filePath).toLowerCase();
 	return MIME_TYPES[ext] ?? "application/octet-stream";
@@ -896,7 +1070,7 @@ function etagMatches(header, etag) {
 	});
 }
 function createPowerhouseRouter(config, sse, webhooks, ownerStore) {
-	const cdn = new CdnCache(`http://localhost:${config.port}`, config.cdnCachePath);
+	const cdn = new CdnCache(localUrl(config), config.cdnCachePath);
 	const router = Router();
 	const withOwners = async (pkgs) => {
 		if (!ownerStore || pkgs.length === 0) return pkgs;
@@ -1010,21 +1184,54 @@ function createPowerhouseRouter(config, sse, webhooks, ownerStore) {
 			suggestions: req.query.suggestionType === "ACTION_AND_TRIGGER"
 		}));
 	});
-	router.get("/pieces/*", (req, res) => {
+	router.get("/pieces/*", async (req, res) => {
 		warm();
-		const name = req.params[0];
-		const entry = findPiece(config.cdnCachePath, name, config.storagePath);
-		const detail = entry ? pieceDetail(entry, originOf(req)) : null;
-		if (!detail) {
+		const raw = req.params[0];
+		const versionsOf = versionsRouteName(raw);
+		if (versionsOf) {
+			const versions = await pieceVersions(cdn, config.cdnCachePath, versionsOf, config.storagePath);
+			if (!versions) {
+				res.status(404).json({ error: `Piece not found: ${versionsOf}` });
+				return;
+			}
+			res.json(versions.map(versionSummary));
+			return;
+		}
+		const name = raw;
+		const version = typeof req.query.version === "string" ? req.query.version : void 0;
+		if (version === void 0) {
+			const entry = findPiece(config.cdnCachePath, name, config.storagePath);
+			const detail = entry ? pieceDetail(entry, originOf(req)) : null;
+			if (!detail) {
+				res.status(404).json({ error: `Piece not found: ${name}` });
+				return;
+			}
+			res.json(detail);
+			return;
+		}
+		const found = await findPieceVersion(cdn, config.cdnCachePath, name, version, config.storagePath);
+		if (found.kind === "unknown-piece") {
 			res.status(404).json({ error: `Piece not found: ${name}` });
 			return;
 		}
+		if (found.kind === "unknown-version") {
+			res.status(404).json({
+				error: `Piece version not found: ${name}@${version}`,
+				available: found.available
+			});
+			return;
+		}
+		const detail = pieceDetail(found.entry, originOf(req));
+		if (!detail) {
+			res.status(404).json({ error: `Piece not found: ${name}@${version}` });
+			return;
+		}
 		res.json(detail);
 	});
 	router.get("/-/pieces/bundled/*", async (req, res) => {
 		warm();
 		const filename = req.params[0];
-		const entry = findPieceByTarball(config.cdnCachePath, filename, config.storagePath);
+		const entry = await findPieceByTarball(cdn, config.cdnCachePath, filename, config.storagePath);
 		const file = entry ? await pieceTarball(entry) : null;
 		if (!entry || !file) {
 			res.status(404).json({ error: `Piece bundle not found: ${filename}` });
@@ -1136,7 +1343,7 @@ function parseManifestRewrite(reqPath) {
 	return { packageName: decodeURIComponent(beforeRev) };
 }
 function createUnpublishHook(config, notifications) {
-	const cdn = new CdnCache(`http://localhost:${config.port}`, config.cdnCachePath);
+	const cdn = new CdnCache(localUrl(config), config.cdnCachePath);
 	const handleManifestRewrite = (req, res) => {
 		const rewrite = parseManifestRewrite(req.path);
 		if (!rewrite) return;
@@ -1193,7 +1400,7 @@ function createUnpublishHook(config, notifications) {
 	};
 }
 function createPublishHook(config, notifications) {
-	const cdn = new CdnCache(`http://localhost:${config.port}`, config.cdnCachePath);
+	const cdn = new CdnCache(localUrl(config), config.cdnCachePath);
 	const parseBody = express.json({
 		strict: false,
 		limit: config.maxBodySize ?? "300mb"
@@ -1269,11 +1476,14 @@ function publishedTarball(body) {
 	return null;
 }
 async function pieceClaimConflict(config, packageName, body) {
-	const index = pieceIndex(config.cdnCachePath, config.storagePath);
-	if (index.size === 0) return null;
 	const tarball = publishedTarball(body);
 	if (!tarball) return null;
-	for (const name of await pieceNamesInTarball(tarball)) {
+	const names = await pieceNamesInTarball(tarball);
+	if (names.length === 0) return null;
+	const reserved = names.filter((name) => name.startsWith(RESERVED_PIECE_SCOPE));
+	if (reserved.length > 0) return `Piece names in the ${RESERVED_PIECE_SCOPE} scope belong to Activepieces; ${packageName} cannot claim ${reserved.map((n) => `"${n}"`).join(", ")}. Rename the piece into your own scope.`;
+	const index = pieceIndex(config.cdnCachePath, config.storagePath);
+	for (const name of names) {
 		const owner = index.get(name);
 		if (owner && owner.packageName !== packageName) return `Piece "${name}" is already published by ${owner.packageName}; ${packageName} cannot claim it.`;
 	}
@@ -1553,7 +1763,9 @@ async function runRegistry(args) {
 	app.use(createPublishHook(config, notifications));
 	app.use(createUnpublishHook(config, notifications));
 	app.use((req, res) => verdaccioHandler(req, res));
-	return app.listen(port, () => {
+	const server = app.listen(port, () => {
+		config.port = server.address().port;
+		const port = config.port;
 		console.log(`Powerhouse Registry running on http://localhost:${port}`);
 		console.log(`  CDN:      http://localhost:${port}/-/cdn/`);
 		console.log(`  Packages: http://localhost:${port}/packages`);
@@ -1563,6 +1775,7 @@ async function runRegistry(args) {
 		if (config.s3) console.log(`  S3:       ${config.s3.endpoint}/${config.s3.bucket}`);
 		if (config.renown) console.log(`  Renown auth: ${config.renown.publicUrl}`);
 	});
+	return server;
 }
 //#endregion
 //#region cli.ts