@ariestools/cli 0.1.8 → 0.1.9

package/dist/bin/daemons/chain-server.mjs

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+import { readFileSync } from "node:fs";
+import { mkdtemp, rm } from "node:fs/promises";
+import { tmpdir } from "node:os";
+import path from "node:path";
+import S3rver from "s3rver";
+//#region src/ChainBacking.ts
+const CHAIN_BACKINGS = ["memory"];
+function isChainBackingKind(value) {
+	return CHAIN_BACKINGS.includes(value);
+}
+function createMemoryBacking() {
+	let dir;
+	return {
+		description: "memory (ephemeral temp directory)",
+		get directory() {
+			if (dir === void 0) throw new Error("Memory backing not prepared");
+			return dir;
+		},
+		async prepare() {
+			dir ??= await mkdtemp(path.join(tmpdir(), "aries-chain-"));
+		},
+		async cleanup() {
+			if (dir !== void 0) await rm(dir, {
+				recursive: true,
+				force: true
+			});
+			dir = void 0;
+		}
+	};
+}
+function resolveBacking(kind) {
+	switch (kind) {
+		case "memory": return createMemoryBacking();
+	}
+}
+//#endregion
+//#region src/startChainServer.ts
+/**
+* The bucket-per-role split of the published chain layout. Path-style
+* addressing turns each bucket into a subfolder of the one origin —
+* `/blocks`, `/state`, `/indexes` — replacing the production sub-domains.
+*/
+const CHAIN_BUCKETS = [
+	"blocks",
+	"state",
+	"indexes"
+];
+const DEFAULT_HOST = "127.0.0.1";
+const DEFAULT_PORT = 8791;
+/** Allow browser RestBlockViewer clients to read the layout cross-origin. */
+const CORS_ALLOW_READS = `<CORSConfiguration>
+  <CORSRule>
+    <AllowedOrigin>*</AllowedOrigin>
+    <AllowedMethod>GET</AllowedMethod>
+    <AllowedMethod>HEAD</AllowedMethod>
+    <AllowedHeader>*</AllowedHeader>
+  </CORSRule>
+</CORSConfiguration>`;
+/**
+* Boots an S3-compatible server (s3rver) pre-configured with the three chain
+* layout buckets. Writers use the S3 API (any credentials are accepted);
+* readers fetch `/{bucket}/{layout-path}` over HTTP or optional TLS.
+*
+* DEV ONLY — this server is a local development fixture, not a production
+* chain host. It intentionally skips the production concerns the datalake
+* and signing-pool planes carry (auth, metrics, durable multi-instance
+* storage): any S3 credentials are accepted and the only backing is an
+* ephemeral temp directory. Production chains stay on the real sub-domain
+* layout (blocks/state/indexes origins backed by S3/R2).
+*/
+async function startChainServer(options) {
+	const host = options.host ?? DEFAULT_HOST;
+	const publicHost = options.publicHost ?? host;
+	await options.backing.prepare();
+	const server = new S3rver({
+		address: host,
+		allowMismatchedSignatures: true,
+		cert: options.tls?.cert,
+		configureBuckets: CHAIN_BUCKETS.map((name) => ({
+			name,
+			configs: [CORS_ALLOW_READS]
+		})),
+		directory: options.backing.directory,
+		key: options.tls?.key,
+		port: options.port ?? DEFAULT_PORT,
+		silent: options.silent ?? false,
+		vhostBuckets: false
+	});
+	try {
+		const { port } = await server.run();
+		return {
+			baseUrl: `${options.tls === void 0 ? "http" : "https"}://${publicHost}:${port}`,
+			port,
+			close: async () => {
+				await server.close();
+				await options.backing.cleanup();
+			}
+		};
+	} catch (error) {
+		await options.backing.cleanup();
+		throw error;
+	}
+}
+//#endregion
+//#region src/bin/chainServer.ts
+/**
+* Chain REST server daemon: serves an XL1/XYO published-chain layout from a
+* single origin using subfolders (/blocks, /state, /indexes) instead of the
+* production sub-domains. The subfolders are S3 buckets on an embedded
+* S3-compatible server, so the existing `xyo s3 ...` publish commands write
+* into it unchanged while readers (RestBlockViewer, curl) fetch the same
+* layout paths over HTTP or optional TLS.
+*/
+const PORT = Number(process.env.CHAIN_PORT ?? 8791);
+const HOST = process.env.HOST ?? "127.0.0.1";
+const BACKING = process.env.CHAIN_BACKING ?? "memory";
+const PUBLIC_HOST = process.env.CHAIN_PUBLIC_HOST;
+const TLS_CERT_PATH = process.env.CHAIN_TLS_CERT;
+const TLS_KEY_PATH = process.env.CHAIN_TLS_KEY;
+async function main() {
+	if (!isChainBackingKind(BACKING)) throw new Error(`Unsupported CHAIN_BACKING '${BACKING}' (supported: ${CHAIN_BACKINGS.join(", ")})`);
+	const backing = resolveBacking(BACKING);
+	if (TLS_CERT_PATH === void 0 !== (TLS_KEY_PATH === void 0)) throw new Error("CHAIN_TLS_CERT and CHAIN_TLS_KEY must be provided together");
+	const server = await startChainServer({
+		backing,
+		host: HOST,
+		port: PORT,
+		publicHost: PUBLIC_HOST,
+		tls: TLS_CERT_PATH === void 0 || TLS_KEY_PATH === void 0 ? void 0 : {
+			cert: readFileSync(TLS_CERT_PATH),
+			key: readFileSync(TLS_KEY_PATH)
+		}
+	});
+	console.log(`chain server listening at ${server.baseUrl}\n` + CHAIN_BUCKETS.map((bucket) => `  /${bucket.padEnd(7)} ${server.baseUrl}/${bucket}`).join("\n") + `\nbacking: ${backing.description} — ${backing.directory}`);
+	const shutdown = async () => {
+		await server.close();
+		process.exit(0);
+	};
+	process.on("SIGINT", () => {
+		shutdown();
+	});
+	process.on("SIGTERM", () => {
+		shutdown();
+	});
+}
+main().catch((error) => {
+	console.error(error);
+	process.exit(1);
+});
+//#endregion
+export {};