@buildepicshit/cli 0.0.5 → 0.0.7

package/package.json

@@ -7,11 +7,13 @@
 		"commander": "^13.1.0",
 		"execa": "^9.6.1",
 		"jiti": "^2.4.2",
+		"omelette": "^0.4.17",
 		"open": "^10.1.2",
 		"ws": "^8.18.2",
 		"zx": "^8.8.5"
 	},
 	"devDependencies": {
+		"@types/omelette": "^0.4.5",
 		"@types/ws": "^8.18.1",
 		"esbuild": "^0.25.5"
 	},
@@ -35,5 +37,5 @@
 		"typecheck": "tsc --noEmit"
 	},
 	"type": "module",
-	"version": "0.0.5"
+	"version": "0.0.7"
 }

package/src/bes.ts

@@ -1,4 +1,5 @@
 import { Command } from "commander";
+import { setupCompletion } from "./completion.js";
 import { loadConfig } from "./config-loader.js";
 import { createLazyLogger } from "./orchestrator/logger/logger.js";
 import { createEventBus } from "./orchestrator/runner/event-bus.js";
@@ -18,6 +19,16 @@ program
 
 async function main() {
 	const { root, commands } = await loadConfig();
+	const commandNames = Object.keys(commands);
+
+	// Setup shell autocomplete (handles completion requests and exits)
+	const completion = setupCompletion(commandNames);
+
+	// bes --setup-completion → install shell init file and exit
+	if (process.argv.includes("--setup-completion")) {
+		completion.setupShellInitFile();
+		return;
+	}
 
 	// Register each exported function as a CLI command
 	for (const [name, fn] of Object.entries(commands)) {

package/src/completion.ts

@@ -0,0 +1,12 @@
+import omelette from "omelette";
+
+export function setupCompletion(commandNames: string[]) {
+	const completion = omelette("bes <command>");
+
+	completion.on("command", ({ reply }) => {
+		reply([...commandNames, "--dry"]);
+	});
+
+	completion.init();
+	return completion;
+}

package/src/orchestrator/core/__tests__/command.test.ts

@@ -154,6 +154,32 @@ describe("command identity", () => {
 		expect(withId.identity.name).toBe("custom");
 	});
 
+	it("throws a helpful error when .identity is called as a function", () => {
+		const c = cmd("node server.js");
+		expect(() => {
+			(c.identity as unknown as (s: string) => void)("api");
+		}).toThrow(
+			'.identity("api") is not a function. To set identity, use .withIdentity("api") instead.',
+		);
+	});
+
+	it("throws a helpful error when .identity is called without args", () => {
+		const c = cmd("node server.js");
+		expect(() => {
+			(c.identity as unknown as () => void)();
+		}).toThrow(
+			".identity() is not a function. To set identity, use .withIdentity() instead.",
+		);
+	});
+
+	it("identity proxy still exposes .port() and .url()", async () => {
+		const c = cmd("node server.js").withIdentity("api");
+		expect(c.identity.name).toBe("api");
+		expect(typeof c.identity.port()).toBe("function");
+		expect(typeof c.identity.url("/health")).toBe("function");
+		expect(typeof c.identity.localhostUrl()).toBe("function");
+	});
+
 	it("identity.port() returns a token", async () => {
 		const c = cmd("node server.js").withIdentity("api").dir("apps/api");
 		const token = c.identity.port();
@@ -185,8 +211,12 @@ describe("command identity", () => {
 		const c = cmd("docker compose").withIdentity("infra");
 		const dbPortToken = c.identity.port("database");
 		const infraPortToken = c.identity.port();
-		const dbPort = await (dbPortToken as (ctx: ComputeContext) => Promise<string>)(ctx);
-		const infraPort = await (infraPortToken as (ctx: ComputeContext) => Promise<string>)(ctx);
+		const dbPort = await (
+			dbPortToken as (ctx: ComputeContext) => Promise<string>
+		)(ctx);
+		const infraPort = await (
+			infraPortToken as (ctx: ComputeContext) => Promise<string>
+		)(ctx);
 		// Named sub-identity should produce a different port
 		expect(dbPort).not.toBe(infraPort);
 		expect(Number.parseInt(dbPort, 10)).toBeGreaterThanOrEqual(3000);
@@ -194,13 +224,19 @@ describe("command identity", () => {
 
 	it("identity.localhostUrl with portIdentity option", async () => {
 		const c = cmd("docker compose").withIdentity("infra");
-		const urlToken = c.identity.localhostUrl("/health", { portIdentity: "minio" });
-		const url = await (urlToken as (ctx: ComputeContext) => Promise<string>)(ctx);
+		const urlToken = c.identity.localhostUrl("/health", {
+			portIdentity: "minio",
+		});
+		const url = await (urlToken as (ctx: ComputeContext) => Promise<string>)(
+			ctx,
+		);
 		expect(url).toMatch(/^http:\/\/localhost:\d+\/health$/);
 
 		// Port in the URL should match minio identity, not infra
 		const minioPortToken = c.identity.port("minio");
-		const minioPort = await (minioPortToken as (ctx: ComputeContext) => Promise<string>)(ctx);
+		const minioPort = await (
+			minioPortToken as (ctx: ComputeContext) => Promise<string>
+		)(ctx);
 		expect(url).toBe(`http://localhost:${minioPort}/health`);
 	});
 });
@@ -262,3 +298,31 @@ describe("env callback form", () => {
 		expect(Number.parseInt(built.env.PORT, 10)).toBeGreaterThanOrEqual(3000);
 	});
 });
+
+describe("logs", () => {
+	it("logs({ silent: true }) builds without error", async () => {
+		const c = cmd("node server.js").logs({ silent: true });
+		const built = await c.build(ctx);
+		expect(built).toBeDefined();
+	});
+
+	it("logs state propagates through builder chain", async () => {
+		const c = cmd("node server.js")
+			.logs({ silent: true })
+			.dir("apps/api")
+			.env({ KEY: "value" })
+			.flag("verbose");
+		const built = await c.build(ctx);
+		expect(built).toBeDefined();
+	});
+
+	it("is immutable — logs does not affect original", async () => {
+		const base = cmd("node server.js");
+		const silent = base.logs({ silent: true });
+		// Both should build fine — they are independent instances
+		const built1 = await base.build(ctx);
+		const built2 = await silent.build(ctx);
+		expect(built1).toBeDefined();
+		expect(built2).toBeDefined();
+	});
+});

package/src/orchestrator/core/command.ts

@@ -5,7 +5,7 @@ import {
 	createDeferred,
 	getRuntimeContext,
 } from "../runner/runtime-context.js";
-import { createIdentity } from "../utils/dna.js";
+import { createIdentity, type Identity } from "../utils/dna.js";
 import { resolveToken } from "./token.js";
 import {
 	type BuiltCommand,
@@ -30,6 +30,7 @@ interface CommandState {
 	readonly flags: readonly { name: string; value?: Token }[];
 	readonly healthChecks: readonly HealthCheck[];
 	readonly identitySuffix: string | null;
+	readonly logsSilent: boolean;
 }
 
 class Command implements ICommand {
@@ -40,16 +41,41 @@ class Command implements ICommand {
 		this.state = state;
 	}
 
-	get identity() {
-		return createIdentity(
-			this.state.identitySuffix ?? this.deriveName(),
-		);
+	get identity(): Identity {
+		const id = createIdentity(this.state.identitySuffix ?? this.deriveName());
+
+		function throwOnCall(...args: unknown[]): never {
+			const hint = typeof args[0] === "string" ? `("${args[0]}")` : "()";
+			throw new TypeError(
+				`.identity${hint} is not a function. To set identity, use .withIdentity${hint} instead. ` +
+					`.identity is a read-only property that provides access to .port() and .url().`,
+			);
+		}
+
+		return new Proxy(throwOnCall, {
+			apply(_target, _thisArg, args) {
+				throwOnCall(...(args as unknown[]));
+			},
+			get(_target, prop, receiver) {
+				return Reflect.get(id, prop, receiver);
+			},
+			has(_target, prop) {
+				return prop in id;
+			},
+		}) as unknown as Identity;
 	}
 
 	withIdentity(suffix: string): ICommand {
 		return new Command({ ...this.state, identitySuffix: suffix });
 	}
 
+	logs(options: { silent?: boolean }): ICommand {
+		return new Command({
+			...this.state,
+			logsSilent: options.silent ?? false,
+		});
+	}
+
 	flag(name: string, value?: Token): ICommand {
 		return new Command({
 			...this.state,
@@ -183,9 +209,7 @@ class Command implements ICommand {
 				rtx.logger.system(`    env: ${JSON.stringify(built.env)}`);
 			}
 			if (this.state.healthChecks.length > 0) {
-				const types = this.state.healthChecks
-					.map((hc) => hc.type)
-					.join(", ");
+				const types = this.state.healthChecks.map((hc) => hc.type).join(", ");
 				rtx.logger.system(`    waitFor: ${types}`);
 			}
 			if (this.state.dependencies.length > 0) {
@@ -199,7 +223,9 @@ class Command implements ICommand {
 			return;
 		}
 
+		const fullCmd = [built.command, ...built.args].join(" ");
 		rtx.logger.starting(name, name);
+		rtx.logger.system(`  ${fullCmd}`);
 
 		const proc = spawnProcess(name, name, built);
 		rtx.processes.set(name, proc);
@@ -215,17 +241,19 @@ class Command implements ICommand {
 		});
 
 		proc.onOutput((line, stream) => {
-			rtx.logger.output(name, line, stream);
-			rtx.eventBus.emit({
-				data: {
-					id: name,
-					line,
-					serviceName: name,
-					stream,
-					timestamp: Date.now(),
-				},
-				type: "log",
-			});
+			if (!this.state.logsSilent) {
+				rtx.logger.output(name, line, stream);
+				rtx.eventBus.emit({
+					data: {
+						id: name,
+						line,
+						serviceName: name,
+						stream,
+						timestamp: Date.now(),
+					},
+					type: "log",
+				});
+			}
 		});
 
 		if (this.state.healthChecks.length > 0) {
@@ -319,5 +347,6 @@ export function cmd(base: string): ICommand {
 		flags: [],
 		healthChecks: [],
 		identitySuffix: null,
+		logsSilent: false,
 	});
 }

package/src/orchestrator/core/index.ts

@@ -29,7 +29,6 @@ export type {
 	HealthCheckCallback,
 	ICommand,
 	ICompound,
-
 	LazyEnvSource,
 	ProcessStatus,
 	Runnable,

package/src/orchestrator/core/types.ts

@@ -57,6 +57,7 @@ export interface ICommand {
 	env(source: EnvSource): ICommand;
 	flag(name: string, value?: Token): ICommand;
 	readonly identity: Identity;
+	logs(options: { silent?: boolean }): ICommand;
 	run(): Promise<void>;
 	waitFor(check: HealthCheck | HealthCheckCallback): ICommand;
 	withIdentity(suffix: string): ICommand;

package/src/orchestrator/index.ts

@@ -25,7 +25,6 @@ export type {
 	HealthCheckCallback,
 	ICommand,
 	ICompound,
-
 	ProcessStatus,
 	Runnable,
 	Token,
@@ -34,7 +33,12 @@ export type {
 export type { Logger } from "./logger/logger.js";
 export { createLazyLogger, createLogger } from "./logger/logger.js";
 // Presets
-export type { IDockerCompose, IDrizzle, INextjs, NextPreset } from "./presets/index.js";
+export type {
+	IDockerCompose,
+	IDrizzle,
+	INextjs,
+	NextPreset,
+} from "./presets/index.js";
 export {
 	docker,
 	dockerCompose,

package/src/orchestrator/presets/docker.ts

@@ -13,6 +13,7 @@ import type { Identity } from "../utils/dna.js";
 
 export interface IDockerCompose extends ICommand {
 	file(path: string): IDockerCompose;
+	logs(options: { silent?: boolean }): IDockerCompose;
 	up(options?: { detach?: boolean }): IDockerCompose;
 	withIdentity(suffix: string): IDockerCompose;
 }
@@ -58,6 +59,10 @@ class DockerCompose implements IDockerCompose {
 		return new DockerCompose(this.inner.withIdentity(suffix), this.dcState);
 	}
 
+	logs(options: { silent?: boolean }): IDockerCompose {
+		return new DockerCompose(this.inner.logs(options), this.dcState);
+	}
+
 	flag(name: string, value?: Token): IDockerCompose {
 		return new DockerCompose(this.inner.flag(name, value), this.dcState);
 	}
@@ -83,10 +88,7 @@ class DockerCompose implements IDockerCompose {
 	}
 
 	dependsOn(...deps: Runnable[]): IDockerCompose {
-		return new DockerCompose(
-			this.inner.dependsOn(...deps),
-			this.dcState,
-		);
+		return new DockerCompose(this.inner.dependsOn(...deps), this.dcState);
 	}
 
 	collectNames(): string[] {
@@ -101,7 +103,7 @@ class DockerCompose implements IDockerCompose {
 		}
 		command = command.arg("up");
 		if (this.dcState.detach) {
-			command = command.flag("detach");
+			command = command.arg("-d");
 		}
 		return command.build(ctx);
 	}
@@ -114,7 +116,7 @@ class DockerCompose implements IDockerCompose {
 		}
 		command = command.arg("up");
 		if (this.dcState.detach) {
-			command = command.flag("detach");
+			command = command.arg("-d");
 		}
 		return command.run();
 	}
@@ -142,7 +144,7 @@ export function docker(options?: {
 	command = command.arg("up");
 
 	if (options?.detach) {
-		command = command.flag("detach");
+		command = command.arg("-d");
 	}
 
 	if (options?.service) {

package/src/orchestrator/presets/index.ts

@@ -1,5 +1,5 @@
-export { type IDockerCompose, docker, dockerCompose } from "./docker.js";
-export { type IDrizzle, drizzle } from "./drizzle.js";
+export { docker, dockerCompose, type IDockerCompose } from "./docker.js";
+export { drizzle, type IDrizzle } from "./drizzle.js";
 export { esbuild, esbuildWatch } from "./esbuild.js";
 export { hono } from "./hono.js";
 export { type INextjs, type NextPreset, next, nextjs } from "./nextjs.js";

package/src/orchestrator/presets/nextjs.ts

@@ -12,6 +12,7 @@ import type {
 import type { Identity } from "../utils/dna.js";
 
 export interface INextjs extends ICommand {
+	logs(options: { silent?: boolean }): INextjs;
 	withIdentity(suffix: string): INextjs;
 }
 
@@ -36,6 +37,10 @@ class Nextjs implements INextjs {
 		return new Nextjs(this.inner.withIdentity(suffix));
 	}
 
+	logs(options: { silent?: boolean }): INextjs {
+		return new Nextjs(this.inner.logs(options));
+	}
+
 	flag(name: string, value?: Token): INextjs {
 		return new Nextjs(this.inner.flag(name, value));
 	}

package/src/orchestrator/utils/dna.ts

@@ -12,7 +12,16 @@ const RESERVED_PORTS = new Set([
 	5984, // CouchDB
 	6379, // Redis
 	6380, // Redis alt
-	6660, 6661, 6662, 6663, 6664, 6665, 6666, 6667, 6668, 6669, // IRC
+	6660,
+	6661,
+	6662,
+	6663,
+	6664,
+	6665,
+	6666,
+	6667,
+	6668,
+	6669, // IRC
 	6697, // IRC over TLS (ircs-u)
 	7474, // Neo4j
 	8080, // HTTP alternate
@@ -32,23 +41,23 @@ function computePort(
 ): 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 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 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;
+	localhostUrl: (path?: string, options?: { portIdentity?: string }) => Token;
 	readonly name: string;
 	port: (identityName?: string) => Token;
 	url: (path?: string, options?: { portIdentity?: string }) => Token;