@buildepicshit/cli 0.0.1 → 0.0.3

package/src/orchestrator/runner/process.ts

@@ -0,0 +1,167 @@
+import { join } from "node:path";
+import { execa, type ResultPromise } from "execa";
+import type { BuiltCommand, ProcessStatus } from "../core/types.js";
+import { getRuntimeContext } from "./runtime-context.js";
+
+const KILL_TIMEOUT_MS = 5000;
+
+export interface OrchestratorProcess {
+	readonly id: string;
+	kill(): Promise<void>;
+	onOutput(listener: (line: string, stream: "stderr" | "stdout") => void): void;
+	readonly outputLines: string[];
+	readonly serviceName: string;
+	setStatus(status: ProcessStatus): void;
+	readonly status: ProcessStatus;
+	waitFor(condition: "completed" | "healthy" | "started"): Promise<void>;
+}
+
+export function spawnProcess(
+	id: string,
+	serviceName: string,
+	built: BuiltCommand,
+): OrchestratorProcess {
+	let currentStatus: ProcessStatus = "starting";
+	const outputLines: string[] = [];
+	const outputListeners: Array<
+		(line: string, stream: "stderr" | "stdout") => void
+	> = [];
+	const waiters = new Map<string, Array<() => void>>();
+
+	function setStatus(s: ProcessStatus) {
+		currentStatus = s;
+		const callbacks = waiters.get(s);
+		if (callbacks) {
+			for (const cb of callbacks) cb();
+			waiters.delete(s);
+		}
+	}
+
+	const fullCommand = [built.command, ...built.args].join(" ");
+
+	// Prepend node_modules/.bin from both the process cwd and the workspace root
+	// to PATH. This mirrors `pnpm exec` behavior: local binaries (tsx, next, etc.)
+	// resolve from the pnpm store with correct module resolution context.
+	const rtx = getRuntimeContext();
+	const localBin = join(built.cwd, "node_modules", ".bin");
+	const rootBin = join(rtx.root, "node_modules", ".bin");
+	const currentPath = process.env.PATH ?? "";
+	const enhancedPath = `${localBin}:${rootBin}:${currentPath}`;
+
+	const child: ResultPromise = execa({
+		cwd: built.cwd,
+		env: { ...process.env, ...built.env, FORCE_COLOR: "1", PATH: enhancedPath },
+		reject: false,
+		shell: true,
+		stderr: "pipe",
+		stdout: "pipe",
+	})`${fullCommand}`;
+
+	setStatus("running");
+
+	child.stdout?.on("data", (data: Buffer) => {
+		const text = data.toString();
+		for (const line of text.split("\n").filter(Boolean)) {
+			outputLines.push(line);
+			for (const listener of outputListeners) {
+				listener(line, "stdout");
+			}
+		}
+	});
+
+	child.stderr?.on("data", (data: Buffer) => {
+		const text = data.toString();
+		for (const line of text.split("\n").filter(Boolean)) {
+			outputLines.push(line);
+			for (const listener of outputListeners) {
+				listener(line, "stderr");
+			}
+		}
+	});
+
+	child.then((result) => {
+		if (currentStatus !== "failed") {
+			setStatus(result.exitCode === 0 ? "completed" : "failed");
+		}
+	});
+
+	return {
+		id,
+
+		async kill() {
+			const s = currentStatus;
+			if (s === "completed" || s === "failed") return;
+
+			child.kill("SIGTERM");
+
+			await Promise.race([
+				child,
+				new Promise<void>((resolve) => setTimeout(resolve, KILL_TIMEOUT_MS)),
+			]);
+
+			// Re-read: status may have changed during the await
+			const afterWait: ProcessStatus = currentStatus;
+			if (afterWait !== "completed" && afterWait !== "failed") {
+				child.kill("SIGKILL");
+			}
+		},
+
+		onOutput(listener) {
+			outputListeners.push(listener);
+		},
+		outputLines,
+		serviceName,
+		setStatus,
+
+		get status() {
+			return currentStatus;
+		},
+
+		async waitFor(condition) {
+			const satisfies = (s: ProcessStatus) => {
+				if (condition === "started") return s !== "pending" && s !== "starting";
+				if (condition === "healthy")
+					return s === "healthy" || s === "completed";
+				if (condition === "completed") return s === "completed";
+				return false;
+			};
+
+			if (satisfies(currentStatus)) return;
+			if (currentStatus === "failed") {
+				throw new Error(
+					`Process "${serviceName}" failed before reaching "${condition}"`,
+				);
+			}
+
+			return new Promise<void>((resolve, reject) => {
+				const tryResolve = (targetStatus: string) => {
+					const existing = waiters.get(targetStatus) ?? [];
+					existing.push(resolve);
+					waiters.set(targetStatus, existing);
+				};
+
+				if (condition === "started") {
+					tryResolve("running");
+					tryResolve("healthy");
+					tryResolve("completed");
+				} else if (condition === "healthy") {
+					tryResolve("healthy");
+					tryResolve("completed");
+				} else {
+					tryResolve("completed");
+				}
+
+				// Also listen for failure
+				const failCallbacks = waiters.get("failed") ?? [];
+				failCallbacks.push(() =>
+					reject(
+						new Error(
+							`Process "${serviceName}" failed before reaching "${condition}"`,
+						),
+					),
+				);
+				waiters.set("failed", failCallbacks);
+			});
+		},
+	};
+}

package/src/orchestrator/runner/runtime-context.ts

@@ -0,0 +1,51 @@
+import type { EnvSource } from "../core/types.js";
+import type { Logger } from "../logger/logger.js";
+import type { IEventBus } from "./event-bus.js";
+import type { OrchestratorProcess } from "./process.js";
+
+export interface Deferred {
+	promise: Promise<void>;
+	resolve: () => void;
+}
+
+export function createDeferred(): Deferred {
+	let resolve!: () => void;
+	const promise = new Promise<void>((r) => {
+		resolve = r;
+	});
+	return { promise, resolve };
+}
+
+export interface RuntimeContext {
+	dryRun: boolean;
+	eventBus: IEventBus;
+	/** Dir inherited from nearest parent compound that set .dir() */
+	inheritedDir: string | null;
+	/** Env sources inherited from parent compounds (outermost first) */
+	inheritedEnv: EnvSource[];
+	logger: Logger;
+	processes: Map<string, OrchestratorProcess>;
+	/** Resolved when a command finishes its health check / startup */
+	readyPromises: Map<string, Deferred>;
+	root: string;
+}
+
+const CONTEXT_KEY = "__bes_runtime_context__";
+
+export function setRuntimeContext(ctx: RuntimeContext): void {
+	(globalThis as Record<string, unknown>)[CONTEXT_KEY] = ctx;
+}
+
+export function getRuntimeContext(): RuntimeContext {
+	const ctx = (globalThis as Record<string, unknown>)[CONTEXT_KEY] as
+		| RuntimeContext
+		| undefined;
+	if (!ctx) {
+		throw new Error("No runtime context — are you running via the `bes` CLI?");
+	}
+	return ctx;
+}
+
+export function clearRuntimeContext(): void {
+	delete (globalThis as Record<string, unknown>)[CONTEXT_KEY];
+}

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

@@ -0,0 +1,88 @@
+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);
+	});
+});

package/src/orchestrator/utils/dna.ts

@@ -0,0 +1,44 @@
+import { createHash } from "node:crypto";
+import type { Token } from "../core/types.js";
+
+function computePort(
+	cwd: string,
+	suffix: string,
+	range = { max: 9999, min: 3000 },
+): number {
+	const hash = createHash("md5").update(`${cwd}:${suffix}`).digest("hex");
+	const num = Number.parseInt(hash.slice(0, 8), 16);
+	return range.min + (num % (range.max - range.min + 1));
+}
+
+export interface Identity {
+	localhostUrl: (path?: string) => Token;
+	readonly name: string;
+	port: () => Token;
+	url: (path?: string) => Token;
+}
+
+export function createIdentity(suffix?: string): Identity {
+	const name = suffix || "";
+
+	const urlToken = (pathValue?: string): Token => {
+		return async ({ cwd }) => {
+			const port = computePort(cwd, name);
+			const base = `http://localhost:${port}`;
+			return pathValue ? `${base}${pathValue}` : base;
+		};
+	};
+
+	return {
+		localhostUrl: urlToken,
+		name,
+		port: (): Token => {
+			return async ({ cwd }) => {
+				return computePort(cwd, name).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);
+}