@buildepicshit/cli 0.0.2 → 0.0.4

package/src/orchestrator/utils/__tests__/dna.test.ts

@@ -0,0 +1,133 @@
+import { describe, expect, it } from "vitest";
+import type { ComputeContext } from "../../core/types.js";
+import { identity } from "../dna.js";
+
+const ctx: ComputeContext = {
+	cwd: "/projects/myapp",
+	env: {},
+	root: "/projects/myapp",
+};
+
+async function resolveToken(
+	token: ReturnType<ReturnType<typeof identity>["port"]>,
+	context: ComputeContext,
+): Promise<string> {
+	return typeof token === "function" ? token(context) : token;
+}
+
+describe("DNA", () => {
+	it("port() returns a number in range 3000–9999", async () => {
+		const result = await resolveToken(identity("hono").port(), ctx);
+		const port = Number.parseInt(result, 10);
+		expect(port).toBeGreaterThanOrEqual(3000);
+		expect(port).toBeLessThanOrEqual(9999);
+	});
+
+	it("port() is deterministic for same cwd + suffix", async () => {
+		const r1 = await resolveToken(identity("hono").port(), ctx);
+		const r2 = await resolveToken(identity("hono").port(), ctx);
+		expect(r1).toBe(r2);
+	});
+
+	it("port() differs for different suffixes", async () => {
+		const r1 = await resolveToken(identity("hono").port(), ctx);
+		const r2 = await resolveToken(identity("next").port(), ctx);
+		expect(r1).not.toBe(r2);
+	});
+
+	it("port() differs for different cwds", async () => {
+		const ctx2: ComputeContext = { cwd: "/other/project", env: {}, root: "/" };
+		const r1 = await resolveToken(identity("hono").port(), ctx);
+		const r2 = await resolveToken(identity("hono").port(), ctx2);
+		expect(r1).not.toBe(r2);
+	});
+
+	it("url() returns http://localhost:{port}", async () => {
+		const result = await resolveToken(identity("hono").url(), ctx);
+		expect(result).toMatch(/^http:\/\/localhost:\d+$/);
+	});
+
+	it("url(path) appends the path", async () => {
+		const result = await resolveToken(identity("hono").url("/health"), ctx);
+		expect(result).toMatch(/^http:\/\/localhost:\d+\/health$/);
+	});
+
+	it("url() port matches port()", async () => {
+		const port = await resolveToken(identity("hono").port(), ctx);
+		const url = await resolveToken(identity("hono").url("/api"), ctx);
+		expect(url).toBe(`http://localhost:${port}/api`);
+	});
+
+	it("has a name property matching the suffix", () => {
+		expect(identity("server").name).toBe("server");
+	});
+
+	it("has an empty name when no suffix is provided", () => {
+		expect(identity().name).toBe("");
+	});
+
+	it("localhostUrl() returns http://localhost:{port}", async () => {
+		const result = await resolveToken(identity("hono").localhostUrl(), ctx);
+		expect(result).toMatch(/^http:\/\/localhost:\d+$/);
+	});
+
+	it("localhostUrl(path) appends the path", async () => {
+		const result = await resolveToken(
+			identity("hono").localhostUrl("/health"),
+			ctx,
+		);
+		expect(result).toMatch(/^http:\/\/localhost:\d+\/health$/);
+	});
+
+	it("localhostUrl() matches url() output", async () => {
+		const id = identity("hono");
+		const fromUrl = await resolveToken(id.url("/api"), ctx);
+		const fromLocalhostUrl = await resolveToken(id.localhostUrl("/api"), ctx);
+		expect(fromLocalhostUrl).toBe(fromUrl);
+	});
+
+	it("port(identityName) computes port for a different identity", async () => {
+		const id = identity("infra");
+		const ownPort = await resolveToken(id.port(), ctx);
+		const dbPort = await resolveToken(id.port("database"), ctx);
+		expect(ownPort).not.toBe(dbPort);
+		const port = Number.parseInt(dbPort, 10);
+		expect(port).toBeGreaterThanOrEqual(3000);
+		expect(port).toBeLessThanOrEqual(9999);
+	});
+
+	it("port(identityName) is deterministic", async () => {
+		const id = identity("infra");
+		const r1 = await resolveToken(id.port("database"), ctx);
+		const r2 = await resolveToken(id.port("database"), ctx);
+		expect(r1).toBe(r2);
+	});
+
+	it("port(identityName) matches standalone identity port", async () => {
+		const infra = identity("infra");
+		const db = identity("database");
+		const fromSub = await resolveToken(infra.port("database"), ctx);
+		const fromStandalone = await resolveToken(db.port(), ctx);
+		expect(fromSub).toBe(fromStandalone);
+	});
+
+	it("url with portIdentity option uses different port", async () => {
+		const id = identity("infra");
+		const minioPort = await resolveToken(id.port("minio"), ctx);
+		const url = await resolveToken(
+			id.url("/health", { portIdentity: "minio" }),
+			ctx,
+		);
+		expect(url).toBe(`http://localhost:${minioPort}/health`);
+	});
+
+	it("localhostUrl with portIdentity option uses different port", async () => {
+		const id = identity("infra");
+		const minioPort = await resolveToken(id.port("minio"), ctx);
+		const url = await resolveToken(
+			id.localhostUrl("/health", { portIdentity: "minio" }),
+			ctx,
+		);
+		expect(url).toBe(`http://localhost:${minioPort}/health`);
+	});
+});

package/src/orchestrator/utils/dna.ts

@@ -0,0 +1,85 @@
+import { createHash } from "node:crypto";
+import type { Token } from "../core/types.js";
+
+// Well-known/reserved ports in the 3000-9999 range to avoid
+const RESERVED_PORTS = new Set([
+	3306, // MySQL
+	3389, // RDP
+	4369, // Erlang EPMD
+	5432, // PostgreSQL
+	5433, // PostgreSQL alt
+	5672, // AMQP (RabbitMQ)
+	5984, // CouchDB
+	6379, // Redis
+	6380, // Redis alt
+	6660, 6661, 6662, 6663, 6664, 6665, 6666, 6667, 6668, 6669, // IRC
+	6697, // IRC over TLS (ircs-u)
+	7474, // Neo4j
+	8080, // HTTP alternate
+	8443, // HTTPS alternate
+	8888, // Common dev port
+	9042, // Cassandra
+	9090, // Prometheus
+	9200, // Elasticsearch HTTP
+	9300, // Elasticsearch transport
+	9418, // Git
+]);
+
+function computePort(
+	cwd: string,
+	suffix: string,
+	range = { max: 9999, min: 3000 },
+): number {
+	const span = range.max - range.min + 1;
+	for (let attempt = 0; attempt < 10; attempt++) {
+		const input = attempt === 0 ? `${cwd}:${suffix}` : `${cwd}:${suffix}:${attempt}`;
+		const hash = createHash("md5").update(input).digest("hex");
+		const num = Number.parseInt(hash.slice(0, 8), 16);
+		const port = range.min + (num % span);
+		if (!RESERVED_PORTS.has(port)) return port;
+	}
+	// Extremely unlikely fallback — just offset from the last attempt
+	const hash = createHash("md5").update(`${cwd}:${suffix}:fallback`).digest("hex");
+	const num = Number.parseInt(hash.slice(0, 8), 16);
+	return range.min + (num % span);
+}
+
+export interface Identity {
+	localhostUrl: (
+		path?: string,
+		options?: { portIdentity?: string },
+	) => Token;
+	readonly name: string;
+	port: (identityName?: string) => Token;
+	url: (path?: string, options?: { portIdentity?: string }) => Token;
+}
+
+export function createIdentity(suffix?: string): Identity {
+	const name = suffix || "";
+
+	const urlToken = (
+		pathValue?: string,
+		options?: { portIdentity?: string },
+	): Token => {
+		return async ({ cwd }) => {
+			const portName = options?.portIdentity ?? name;
+			const port = computePort(cwd, portName);
+			const base = `http://localhost:${port}`;
+			return pathValue ? `${base}${pathValue}` : base;
+		};
+	};
+
+	return {
+		localhostUrl: urlToken,
+		name,
+		port: (identityName?: string): Token => {
+			return async ({ cwd }) => {
+				const portName = identityName ?? name;
+				return computePort(cwd, portName).toString();
+			};
+		},
+		url: urlToken,
+	};
+}
+
+export const identity = createIdentity;

package/src/project.ts

@@ -0,0 +1,40 @@
+import { randomUUID } from "node:crypto";
+import { existsSync, mkdirSync, readFileSync, writeFileSync } from "node:fs";
+import { basename, join } from "node:path";
+
+export interface ProjectMeta {
+	uid: string;
+}
+
+function besDir(cwd: string): string {
+	return join(cwd, ".bes");
+}
+
+function projectMetaPath(cwd: string): string {
+	return join(besDir(cwd), "project.json");
+}
+
+export function readOrCreateProjectMeta(cwd: string): ProjectMeta {
+	const path = projectMetaPath(cwd);
+	if (existsSync(path)) {
+		return JSON.parse(readFileSync(path, "utf-8")) as ProjectMeta;
+	}
+	const meta: ProjectMeta = { uid: randomUUID() };
+	const dir = besDir(cwd);
+	if (!existsSync(dir)) mkdirSync(dir, { recursive: true });
+	writeFileSync(path, JSON.stringify(meta, null, "\t"));
+	return meta;
+}
+
+export function readProjectName(cwd: string): string {
+	const pkgPath = join(cwd, "package.json");
+	if (existsSync(pkgPath)) {
+		try {
+			const pkg = JSON.parse(readFileSync(pkgPath, "utf-8")) as {
+				name?: string;
+			};
+			if (pkg.name) return pkg.name;
+		} catch {}
+	}
+	return basename(cwd);
+}