@powerhousedao/registry 6.0.0-dev.105 → 6.0.0-dev.107

package/dist/cli.mjs

@@ -0,0 +1,646 @@
+import { binary, command, flag, number, option, optional, run, string } from "cmd-ts";
+import express, { Router } from "express";
+import { findUp } from "find-up";
+import { mkdir } from "node:fs/promises";
+import path from "node:path";
+import { runServer } from "verdaccio";
+import fs from "node:fs";
+import { Readable } from "node:stream";
+import { pipeline } from "node:stream/promises";
+import { extract } from "tar";
+//#endregion
+//#region src/cdn.ts
+var CdnCache = class {
+	#extractionLocks = /* @__PURE__ */ new Map();
+	constructor(registryUrl, cdnCachePath) {
+		this.registryUrl = registryUrl;
+		this.cdnCachePath = cdnCachePath;
+	}
+	async getFile(packageName, filePath) {
+		const version = this.getLatestCachedVersion(packageName) ?? await this.getLatestVersion(packageName);
+		if (!version) return null;
+		const versionDir = path.join(this.cdnCachePath, packageName, version);
+		const resolved = this.#resolveFile(versionDir, filePath);
+		if (resolved) return resolved;
+		await this.#extractWithLock(packageName, version);
+		return this.#resolveFile(versionDir, filePath);
+	}
+	#resolveFile(versionDir, filePath) {
+		const candidates = [
+			path.join(versionDir, filePath),
+			path.join(versionDir, "cdn", filePath),
+			path.join(versionDir, "dist", "cdn", filePath),
+			path.join(versionDir, "dist", filePath)
+		];
+		for (const candidate of candidates) if (this.isSafePath(candidate) && fs.existsSync(candidate)) return candidate;
+		return null;
+	}
+	async #extractWithLock(packageName, version) {
+		const key = `${packageName}@${version}`;
+		const existing = this.#extractionLocks.get(key);
+		if (existing) return existing;
+		const promise = this.extractTarball(packageName, version).finally(() => {
+			this.#extractionLocks.delete(key);
+		});
+		this.#extractionLocks.set(key, promise);
+		return promise;
+	}
+	getLatestCachedVersion(packageName) {
+		const pkgDir = path.join(this.cdnCachePath, packageName);
+		try {
+			const versions = fs.readdirSync(pkgDir, { withFileTypes: true }).filter((e) => e.isDirectory()).map((e) => e.name);
+			if (versions.length === 0) return null;
+			versions.sort();
+			return versions[versions.length - 1];
+		} catch {
+			return null;
+		}
+	}
+	async getLatestVersion(packageName) {
+		try {
+			const url = `${this.registryUrl}/${encodeURIComponent(packageName)}`;
+			const res = await fetch(url, { headers: { Accept: "application/json" } });
+			if (!res.ok) return null;
+			const distTags = (await res.json())["dist-tags"];
+			if (!distTags) return null;
+			return distTags.latest ?? Object.values(distTags)[0] ?? null;
+		} catch {
+			return null;
+		}
+	}
+	async extractTarball(packageName, version) {
+		const shortName = packageName.startsWith("@") ? packageName.split("/")[1] : packageName;
+		const tarballUrl = `${this.registryUrl}/${encodeURIComponent(packageName)}/-/${shortName}-${version}.tgz`;
+		let res;
+		try {
+			res = await fetch(tarballUrl);
+			if (!res.ok || !res.body) return;
+		} catch {
+			return;
+		}
+		const destDir = path.join(this.cdnCachePath, packageName, version);
+		fs.mkdirSync(destDir, { recursive: true });
+		const tmpFile = path.join(destDir, ".tmp-tarball.tgz");
+		try {
+			const fileStream = fs.createWriteStream(tmpFile);
+			await pipeline(Readable.fromWeb(res.body), fileStream);
+			await extract({
+				file: tmpFile,
+				cwd: destDir,
+				strip: 1
+			});
+		} finally {
+			fs.rmSync(tmpFile, { force: true });
+		}
+	}
+	invalidate(packageName) {
+		const cacheDir = path.join(this.cdnCachePath, packageName);
+		if (!this.isSafePath(cacheDir)) return;
+		fs.rmSync(cacheDir, {
+			recursive: true,
+			force: true
+		});
+	}
+	isSafePath(filePath) {
+		const resolved = path.resolve(filePath);
+		const cacheRoot = path.resolve(this.cdnCachePath);
+		return resolved.startsWith(cacheRoot + path.sep) || resolved === cacheRoot;
+	}
+};
+//#endregion
+//#region src/packages.ts
+function readManifest(dir) {
+	const candidates = [
+		path.join(dir, "powerhouse.manifest.json"),
+		path.join(dir, "cdn", "powerhouse.manifest.json"),
+		path.join(dir, "dist", "powerhouse.manifest.json")
+	];
+	for (const manifestPath of candidates) try {
+		const raw = fs.readFileSync(manifestPath, "utf-8");
+		return JSON.parse(raw);
+	} catch {}
+	return null;
+}
+function getLatestVersionDir(pkgDir) {
+	let entries;
+	try {
+		entries = fs.readdirSync(pkgDir, { withFileTypes: true });
+	} catch {
+		return null;
+	}
+	const versions = entries.filter((e) => e.isDirectory()).map((e) => e.name);
+	if (versions.length === 0) return null;
+	versions.sort();
+	return path.join(pkgDir, versions[versions.length - 1]);
+}
+function loadPackage(cdnCachePath, name) {
+	const pkgDir = path.join(cdnCachePath, name);
+	const manifest = readManifest(getLatestVersionDir(pkgDir) ?? pkgDir);
+	if (!manifest) console.error(`Failed to find manifest for "${name}" in "${cdnCachePath}".`);
+	return {
+		name: manifest?.name ?? name,
+		path: `/-/cdn/${name}`,
+		manifest
+	};
+}
+function scanPackages(cdnCachePath) {
+	const absDir = path.resolve(cdnCachePath);
+	const packages = [];
+	let entries;
+	try {
+		entries = fs.readdirSync(absDir, { withFileTypes: true });
+	} catch {
+		return packages;
+	}
+	for (const entry of entries) {
+		if (!entry.isDirectory()) continue;
+		if (entry.name.startsWith("@")) {
+			const scopeDir = path.join(absDir, entry.name);
+			let scopedEntries;
+			try {
+				scopedEntries = fs.readdirSync(scopeDir, { withFileTypes: true });
+			} catch (error) {
+				console.log(error);
+				continue;
+			}
+			for (const scopedEntry of scopedEntries) {
+				if (!scopedEntry.isDirectory()) continue;
+				const dirName = `${entry.name}/${scopedEntry.name}`;
+				const pkgDir = path.join(scopeDir, scopedEntry.name);
+				const manifest = readManifest(getLatestVersionDir(pkgDir) ?? pkgDir);
+				const name = manifest?.name ?? dirName;
+				packages.push({
+					name,
+					path: `/-/cdn/${dirName}`,
+					manifest
+				});
+			}
+		} else {
+			const pkgDir = path.join(absDir, entry.name);
+			const manifest = readManifest(getLatestVersionDir(pkgDir) ?? pkgDir);
+			const name = manifest?.name ?? entry.name;
+			packages.push({
+				name,
+				path: `/-/cdn/${entry.name}`,
+				manifest
+			});
+		}
+	}
+	return packages;
+}
+function findPackagesByDocumentType(packagesDir, documentType) {
+	return scanPackages(packagesDir).filter((pkg) => {
+		if (!pkg.manifest?.documentModels) return false;
+		return pkg.manifest.documentModels.some((dm) => dm.id === documentType);
+	});
+}
+//#endregion
+//#region src/middleware.ts
+const MIME_TYPES = {
+	".js": "application/javascript",
+	".mjs": "application/javascript",
+	".css": "text/css",
+	".json": "application/json",
+	".wasm": "application/wasm",
+	".map": "application/json",
+	".html": "text/html",
+	".svg": "image/svg+xml"
+};
+function getContentType(filePath) {
+	return MIME_TYPES[path.extname(filePath).toLowerCase()] ?? "application/octet-stream";
+}
+function createPowerhouseRouter(config, sse, webhooks) {
+	const cdn = new CdnCache(`http://localhost:${config.port}`, config.cdnCachePath);
+	const router = Router();
+	router.use((_req, res, next) => {
+		res.setHeader("Access-Control-Allow-Origin", "*");
+		next();
+	});
+	router.get("/-/events", (_req, res) => {
+		sse.addClient(res);
+	});
+	router.get("/-/webhooks", (_req, res) => {
+		res.json(webhooks.getWebhooks());
+	});
+	router.post("/-/webhooks", express.json(), (req, res) => {
+		const { endpoint, headers } = req.body;
+		if (!endpoint) {
+			res.status(400).json({ error: "Missing required field: endpoint" });
+			return;
+		}
+		webhooks.addWebhook({
+			endpoint,
+			headers
+		});
+		res.status(201).json({
+			endpoint,
+			headers
+		});
+	});
+	router.delete("/-/webhooks", express.json(), (req, res) => {
+		const { endpoint } = req.body;
+		if (!endpoint) {
+			res.status(400).json({ error: "Missing required field: endpoint" });
+			return;
+		}
+		if (!webhooks.removeWebhook(endpoint)) {
+			res.status(404).json({ error: "Webhook not found" });
+			return;
+		}
+		res.status(204).end();
+	});
+	router.get("/packages", (req, res) => {
+		const packages = scanPackages(config.cdnCachePath);
+		const documentType = req.query.documentType;
+		if (documentType) {
+			const filtered = packages.filter((pkg) => pkg.manifest?.documentModels?.some((m) => m.id === documentType));
+			res.json(filtered);
+			return;
+		}
+		res.json(packages);
+	});
+	router.get("/packages/by-document-type", (req, res) => {
+		const documentType = req.query.type;
+		if (typeof documentType !== "string" || !documentType) {
+			res.status(400).json({ error: "Missing required query parameter: type" });
+			return;
+		}
+		const packageNames = findPackagesByDocumentType(config.cdnCachePath, documentType).map((pkg) => pkg.name);
+		res.json(packageNames);
+	});
+	router.get("/packages/*name", (req, res) => {
+		const name = req.params.name.join("/");
+		const pkg = loadPackage(config.cdnCachePath, name);
+		if (!pkg) {
+			res.status(404).send("Package not found");
+			return;
+		}
+		res.json(pkg);
+	});
+	router.get("/-/cdn/*path", async (req, res) => {
+		const fullPath = req.params.path.join("/");
+		let packageName;
+		let filePath;
+		if (fullPath.startsWith("@")) {
+			const segments = fullPath.split("/");
+			if (segments.length < 2) {
+				res.status(400).send("Invalid package path");
+				return;
+			}
+			packageName = `${segments[0]}/${segments[1]}`;
+			filePath = segments.slice(2).join("/") || "index.js";
+		} else {
+			const segments = fullPath.split("/");
+			packageName = segments[0];
+			filePath = segments.slice(1).join("/") || "index.js";
+		}
+		const resolved = await cdn.getFile(packageName, filePath);
+		if (!resolved) {
+			res.status(404).send("File not found");
+			return;
+		}
+		res.setHeader("Content-Type", getContentType(filePath));
+		const content = fs.readFileSync(resolved);
+		res.send(content);
+	});
+	return router;
+}
+function createPublishHook(config, notifications) {
+	const cdn = new CdnCache(`http://localhost:${config.port}`, config.cdnCachePath);
+	return (req, res, next) => {
+		if (req.method !== "PUT") {
+			next();
+			return;
+		}
+		const originalEnd = res.end.bind(res);
+		res.end = function(chunk, encoding, cb) {
+			if (res.statusCode >= 200 && res.statusCode < 300) {
+				const urlPath = req.path.replace(/^\//, "");
+				if (urlPath && !urlPath.startsWith("-/")) {
+					const packageName = decodeURIComponent(urlPath);
+					console.log(`[registry] Invalidating CDN cache for ${packageName}`);
+					cdn.invalidate(packageName);
+					cdn.getLatestVersion(packageName).then((version) => {
+						if (version) {
+							console.log(`[registry] Extracting ${packageName}@${version} to CDN cache`);
+							return cdn.extractTarball(packageName, version).then(() => version);
+						}
+						return null;
+					}).then((version) => {
+						notifications.notifyPublish({
+							packageName,
+							version
+						});
+					}).catch((err) => {
+						console.error(`[registry] Failed to extract ${packageName} to CDN cache:`, err);
+					});
+				}
+			}
+			return originalEnd(chunk, encoding, cb);
+		};
+		next();
+	};
+}
+//#endregion
+//#region src/notifications/manager.ts
+var NotificationManager = class {
+	#channels;
+	constructor(channels) {
+		this.#channels = channels;
+	}
+	notifyPublish(event) {
+		for (const channel of this.#channels) channel.notifyPublish(event);
+	}
+};
+//#endregion
+//#region src/notifications/sse.ts
+var SSEChannel = class {
+	#clients = /* @__PURE__ */ new Set();
+	addClient(res) {
+		res.writeHead(200, {
+			"Content-Type": "text/event-stream",
+			"Cache-Control": "no-cache",
+			Connection: "keep-alive",
+			"Access-Control-Allow-Origin": "*"
+		});
+		res.write("event: connected\ndata: {}\n\n");
+		this.#clients.add(res);
+		res.on("close", () => {
+			this.#clients.delete(res);
+		});
+	}
+	notifyPublish(event) {
+		const payload = `event: publish\ndata: ${JSON.stringify(event)}\n\n`;
+		for (const client of this.#clients) try {
+			client.write(payload);
+		} catch (err) {
+			console.error("[registry] SSE client write failed:", err);
+			this.#clients.delete(client);
+		}
+	}
+};
+//#endregion
+//#region src/notifications/webhook.ts
+const WEBHOOKS_FILE = "webhooks.json";
+var WebhookChannel = class {
+	#predefined;
+	#dynamic;
+	#storagePath;
+	constructor(storagePath, config) {
+		this.#storagePath = storagePath;
+		this.#predefined = config?.webhooks ?? [];
+		this.#dynamic = this.#load();
+	}
+	getWebhooks() {
+		return [...this.#predefined, ...this.#dynamic];
+	}
+	addWebhook(webhook) {
+		if (this.getWebhooks().some((w) => w.endpoint === webhook.endpoint)) return;
+		this.#dynamic.push(webhook);
+		this.#save();
+	}
+	removeWebhook(endpoint) {
+		const before = this.#dynamic.length;
+		this.#dynamic = this.#dynamic.filter((w) => w.endpoint !== endpoint);
+		if (this.#dynamic.length === before) return false;
+		this.#save();
+		return true;
+	}
+	notifyPublish(event) {
+		for (const webhook of this.getWebhooks()) {
+			const headers = {
+				"Content-Type": "application/json",
+				...webhook.headers
+			};
+			fetch(webhook.endpoint, {
+				method: "POST",
+				headers,
+				body: JSON.stringify(event)
+			}).catch((err) => {
+				console.error(`[registry] Webhook to ${webhook.endpoint} failed:`, err);
+			});
+		}
+	}
+	#filePath() {
+		return path.join(this.#storagePath, WEBHOOKS_FILE);
+	}
+	#load() {
+		try {
+			const raw = fs.readFileSync(this.#filePath(), "utf-8");
+			return JSON.parse(raw);
+		} catch {
+			return [];
+		}
+	}
+	#save() {
+		fs.mkdirSync(this.#storagePath, { recursive: true });
+		fs.writeFileSync(this.#filePath(), JSON.stringify(this.#dynamic, null, 2));
+	}
+};
+//#endregion
+//#region src/verdaccio-config.ts
+function buildVerdaccioConfig(config) {
+	const htpasswdPath = path.join(config.storagePath, "htpasswd");
+	const base = {
+		storage: config.storagePath,
+		self_path: "./",
+		auth: { htpasswd: { file: htpasswdPath } },
+		uplinks: void 0,
+		packages: {
+			"@powerhousedao/*": {
+				access: "$all",
+				publish: "$authenticated",
+				unpublish: "$authenticated"
+			},
+			"**": {
+				access: "$all",
+				publish: "$authenticated",
+				unpublish: "$authenticated",
+				proxy: "npmjs"
+			}
+		},
+		web: {
+			enable: config.webEnabled !== false,
+			title: "Powerhouse Registry",
+			logo: "/app/static/logo.svg",
+			favicon: "/app/static/favicon.ico",
+			primary_color: "#38C780",
+			darkMode: true
+		},
+		server: { keepAliveTimeout: 60 },
+		log: {
+			type: "stdout",
+			format: "pretty",
+			level: "warn"
+		}
+	};
+	if (config.s3) base.store = { "aws-s3-storage": {
+		bucket: config.s3.bucket,
+		endpoint: config.s3.endpoint,
+		region: config.s3.region,
+		s3ForcePathStyle: config.s3.s3ForcePathStyle ?? true,
+		...config.s3.keyPrefix && { keyPrefix: config.s3.keyPrefix },
+		...config.s3.accessKeyId && { accessKeyId: config.s3.accessKeyId },
+		...config.s3.secretAccessKey && { secretAccessKey: config.s3.secretAccessKey }
+	} };
+	return base;
+}
+//#endregion
+//#region src/run.ts
+async function resolveDir(dir) {
+	if (path.isAbsolute(dir)) {
+		await mkdir(dir, { recursive: true });
+		return dir;
+	}
+	const found = await findUp(dir, { type: "directory" });
+	if (!found) {
+		await mkdir(dir, { recursive: true });
+		return dir;
+	}
+	return found;
+}
+async function runRegistry(args) {
+	const { port, storageDir, cdnCacheDir, uplink, webEnabled, webhooks, s3AccessKeyId, s3Bucket, s3Endpoint, s3ForcePathStyle, s3KeyPrefix, s3Region, s3SecretAccessKey } = args;
+	const storagePath = await resolveDir(storageDir);
+	const cdnCachePath = await resolveDir(cdnCacheDir);
+	console.log({
+		storagePath,
+		cdnCachePath
+	});
+	const webhookConfigs = webhooks?.split(",").map((url) => url.trim()).filter(Boolean).map((endpoint) => ({ endpoint }));
+	const config = {
+		port,
+		storagePath,
+		cdnCachePath,
+		uplink,
+		webEnabled,
+		...webhookConfigs?.length && { notify: { webhooks: webhookConfigs } },
+		...s3Bucket && s3Endpoint && s3Region && { s3: {
+			bucket: s3Bucket,
+			endpoint: s3Endpoint,
+			region: s3Region,
+			accessKeyId: s3AccessKeyId,
+			secretAccessKey: s3SecretAccessKey,
+			keyPrefix: s3KeyPrefix,
+			s3ForcePathStyle
+		} }
+	};
+	await mkdir(storagePath, { recursive: true });
+	await mkdir(cdnCachePath, { recursive: true });
+	const verdaccioHandler = (await runServer(buildVerdaccioConfig(config))).listeners("request")[0];
+	const app = express();
+	const sseChannel = new SSEChannel();
+	const webhookChannel = new WebhookChannel(config.storagePath, config.notify);
+	const notifications = new NotificationManager([sseChannel, webhookChannel]);
+	app.use(createPowerhouseRouter(config, sseChannel, webhookChannel));
+	app.use(createPublishHook(config, notifications));
+	app.use((req, res) => verdaccioHandler(req, res));
+	return app.listen(port, () => {
+		console.log(`Powerhouse Registry running on http://localhost:${port}`);
+		console.log(`  CDN:      http://localhost:${port}/-/cdn/`);
+		console.log(`  Packages: http://localhost:${port}/packages`);
+		console.log(`  npm:      http://localhost:${port}/`);
+		console.log(`  Storage:  ${storagePath}`);
+		console.log(`  CDN cache: ${cdnCachePath}`);
+		if (config.s3) console.log(`  S3:       ${config.s3.endpoint}/${config.s3.bucket}`);
+	});
+}
+//#endregion
+//#region cli.ts
+const registryCommand = command({
+	name: "Package registry",
+	args: {
+		port: option({
+			long: "port",
+			type: number,
+			defaultValue: () => Number(process.env.PORT) || 8080,
+			defaultValueIsSerializable: true
+		}),
+		storageDir: option({
+			long: "storage-dir",
+			type: string,
+			defaultValue: () => process.env.REGISTRY_STORAGE || "./storage",
+			defaultValueIsSerializable: true
+		}),
+		cdnCacheDir: option({
+			long: "cdn-cache-dir",
+			type: string,
+			defaultValue: () => process.env.REGISTRY_CDN_CACHE || "./cdn-cache",
+			defaultValueIsSerializable: true
+		}),
+		uplink: option({
+			long: "uplink",
+			type: optional(string),
+			defaultValue: () => process.env.REGISTRY_UPLINK,
+			defaultValueIsSerializable: true
+		}),
+		s3Bucket: option({
+			long: "s3-bucket",
+			type: optional(string),
+			defaultValue: () => process.env.S3_BUCKET,
+			defaultValueIsSerializable: true
+		}),
+		s3Endpoint: option({
+			long: "s3-endpoint",
+			type: optional(string),
+			defaultValue: () => process.env.S3_ENDPOINT,
+			defaultValueIsSerializable: true
+		}),
+		s3Region: option({
+			long: "s3-region",
+			type: optional(string),
+			defaultValue: () => process.env.S3_REGION,
+			defaultValueIsSerializable: true
+		}),
+		s3AccessKeyId: option({
+			long: "s3-access-key-id",
+			type: optional(string),
+			defaultValue: () => process.env.S3_ACCESS_KEY_ID,
+			defaultValueIsSerializable: true
+		}),
+		s3SecretAccessKey: option({
+			long: "s3-secret-access-key",
+			type: optional(string),
+			defaultValue: () => process.env.S3_SECRET_ACCESS_KEY,
+			defaultValueIsSerializable: true
+		}),
+		s3KeyPrefix: option({
+			long: "s3-key-prefix",
+			type: optional(string),
+			defaultValue: () => process.env.S3_KEY_PREFIX,
+			defaultValueIsSerializable: true
+		}),
+		s3ForcePathStyle: flag({
+			long: "s3-force-path-style",
+			defaultValue: () => process.env.S3_FORCE_PATH_STYLE !== "false",
+			defaultValueIsSerializable: true
+		}),
+		webEnabled: flag({
+			long: "web-enabled",
+			defaultValue: () => process.env.REGISTRY_WEB !== "false",
+			defaultValueIsSerializable: true
+		}),
+		webhooks: option({
+			long: "webhook",
+			type: optional(string),
+			description: "Comma-separated webhook URLs to notify on publish",
+			defaultValue: () => process.env.REGISTRY_WEBHOOKS,
+			defaultValueIsSerializable: true
+		})
+	},
+	handler: async (args) => {
+		console.log(args);
+		try {
+			await runRegistry(args);
+		} catch (error) {
+			console.error("Failed to start registry:");
+			console.error(error);
+			process.exit(1);
+		}
+	}
+});
+await run(binary(registryCommand), process.argv);
+//#endregion
+export { registryCommand };
+
+//# sourceMappingURL=cli.mjs.map