@launchfile/macos-dev 0.1.3

package/src/__tests__/dry-run.test.ts

@@ -0,0 +1,157 @@
+import { describe, it, expect } from "vitest";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { readLaunch } from "@launchfile/sdk";
+import {
+	buildResolverContext,
+	resolveComponentEnv,
+	resolveGenerators,
+} from "../env-writer.js";
+import { getProvisioner } from "../resources/index.js";
+import type { ResourceProperties } from "../resources/types.js";
+import { allocatePorts } from "../port-allocator.js";
+
+const CATALOG_DIR = join(import.meta.dirname, "../../../../catalog/drafts");
+
+/**
+ * Dry-run test: parse a catalog Launchfile, simulate provisioning,
+ * resolve env vars, and verify the output makes sense.
+ */
+describe("dry-run against catalog", () => {
+	it("resolves miniflux Launchfile", async () => {
+		const yaml = await readFile(join(CATALOG_DIR, "miniflux/Launchfile"), "utf8");
+		const launch = readLaunch(yaml);
+
+		expect(launch.name).toBe("miniflux");
+		expect(Object.keys(launch.components)).toEqual(["default"]);
+
+		const component = launch.components.default!;
+
+		// Verify requires
+		expect(component.requires).toHaveLength(1);
+		expect(component.requires![0]!.type).toBe("postgres");
+		expect(component.requires![0]!.set_env?.DATABASE_URL).toBe("$url");
+
+		// Simulate provisioned postgres
+		const resourceMap: Record<string, ResourceProperties> = {
+			postgres: {
+				url: "postgresql://launchfile_miniflux:secret@localhost:5432/launchfile_miniflux",
+				host: "localhost",
+				port: 5432,
+				user: "launchfile_miniflux",
+				password: "secret",
+				name: "launchfile_miniflux",
+			},
+		};
+
+		const ports = await allocatePorts(launch.components, "miniflux");
+		const context = buildResolverContext(resourceMap, ports, {});
+
+		const env = resolveComponentEnv(component, context, resourceMap);
+		await resolveGenerators(component, env);
+
+		// DATABASE_URL should be resolved from postgres $url
+		expect(env.DATABASE_URL).toBe(
+			"postgresql://launchfile_miniflux:secret@localhost:5432/launchfile_miniflux",
+		);
+		// Default env vars should be resolved
+		expect(env.RUN_MIGRATIONS).toBe("1");
+		expect(env.CREATE_ADMIN).toBe("1");
+		expect(env.ADMIN_USERNAME).toBe("admin");
+		// ADMIN_PASSWORD has generator: secret, so it should be generated
+		expect(env.ADMIN_PASSWORD).toBeTruthy();
+		expect(env.ADMIN_PASSWORD!.length).toBeGreaterThan(10);
+	});
+
+	it("resolves langfuse Launchfile", async () => {
+		const yaml = await readFile(join(CATALOG_DIR, "langfuse/Launchfile"), "utf8");
+		const launch = readLaunch(yaml);
+
+		expect(launch.name).toBe("langfuse");
+
+		for (const [name, component] of Object.entries(launch.components)) {
+			// Every required resource should have a known provisioner
+			for (const req of component.requires ?? []) {
+				const provisioner = getProvisioner(req.type);
+				expect(provisioner, `No provisioner for ${req.type} in ${name}`).toBeDefined();
+			}
+		}
+	});
+
+	it("resolves chatwoot multi-component Launchfile", async () => {
+		const yaml = await readFile(join(CATALOG_DIR, "chatwoot/Launchfile"), "utf8");
+		const launch = readLaunch(yaml);
+
+		expect(launch.name).toBe("chatwoot");
+		const componentNames = Object.keys(launch.components);
+		expect(componentNames.length).toBeGreaterThan(1);
+
+		// Simulate resources
+		const resourceMap: Record<string, ResourceProperties> = {
+			postgres: {
+				url: "postgresql://user:pass@localhost:5432/chatwoot",
+				host: "localhost",
+				port: 5432,
+				user: "user",
+				password: "pass",
+				name: "chatwoot",
+			},
+			redis: {
+				url: "redis://localhost:6379/0",
+				host: "localhost",
+				port: 6379,
+			},
+		};
+
+		const ports = await allocatePorts(launch.components, "chatwoot");
+		const secrets: Record<string, string> = {};
+
+		// Generate secrets from launch.secrets
+		if (launch.secrets) {
+			for (const [name] of Object.entries(launch.secrets)) {
+				secrets[name] = `test-secret-${name}`;
+			}
+		}
+
+		const context = buildResolverContext(resourceMap, ports, secrets);
+
+		// Resolve env for each component — should not throw
+		for (const [name, component] of Object.entries(launch.components)) {
+			const env = resolveComponentEnv(component, context, resourceMap);
+			await resolveGenerators(component, env);
+			// Every component should have at least some env vars
+			expect(Object.keys(env).length, `${name} should have env vars`).toBeGreaterThan(0);
+		}
+	});
+
+	it("identifies unsupported resource types", async () => {
+		// Check all catalog Launchfiles for resource types we support
+		const { readdir } = await import("node:fs/promises");
+		const apps = await readdir(CATALOG_DIR);
+		const unsupported = new Set<string>();
+
+		for (const app of apps) {
+			try {
+				const yaml = await readFile(join(CATALOG_DIR, app, "Launchfile"), "utf8");
+				const launch = readLaunch(yaml);
+
+				for (const component of Object.values(launch.components)) {
+					for (const req of [...(component.requires ?? []), ...(component.supports ?? [])]) {
+						if (!getProvisioner(req.type)) {
+							unsupported.add(req.type);
+						}
+					}
+				}
+			} catch {
+				// Skip apps that can't be parsed
+			}
+		}
+
+		// Log unsupported types for visibility
+		if (unsupported.size > 0) {
+			console.log(`  Unsupported resource types in catalog: ${[...unsupported].join(", ")}`);
+		}
+		// This test is informational — it doesn't fail
+		expect(true).toBe(true);
+	});
+});

package/src/__tests__/env-writer.test.ts

@@ -0,0 +1,156 @@
+import { describe, it, expect } from "vitest";
+import {
+	buildResolverContext,
+	resolveComponentEnv,
+	generateSecrets,
+} from "../env-writer.js";
+import type { NormalizedComponent, Secret } from "@launchfile/sdk";
+import type { ResourceProperties } from "../resources/types.js";
+
+describe("buildResolverContext", () => {
+	it("builds context from resources, ports, and secrets", () => {
+		const resources: Record<string, ResourceProperties> = {
+			postgres: {
+				url: "postgresql://user:pass@localhost:5432/mydb",
+				host: "localhost",
+				port: 5432,
+				user: "user",
+				password: "pass",
+				name: "mydb",
+			},
+		};
+		const ports = { backend: 3000, frontend: 3001 };
+		const secrets = { "jwt-secret": "abc123" };
+
+		const ctx = buildResolverContext(resources, ports, secrets);
+
+		expect(ctx.components?.backend).toEqual({
+			url: "http://localhost:3000",
+			host: "localhost",
+			port: 3000,
+		});
+		expect(ctx.resources?.postgres?.url).toBe("postgresql://user:pass@localhost:5432/mydb");
+		expect(ctx.secrets?.["jwt-secret"]).toBe("abc123");
+	});
+});
+
+describe("resolveComponentEnv", () => {
+	it("resolves set_env from requires", () => {
+		const component: NormalizedComponent = {
+			requires: [
+				{
+					type: "postgres",
+					set_env: {
+						DATABASE_URL: "$url",
+						DB_HOST: "$host",
+					},
+				},
+			],
+		};
+		const resourceMap: Record<string, ResourceProperties> = {
+			postgres: {
+				url: "postgresql://user:pass@localhost:5432/mydb",
+				host: "localhost",
+				port: 5432,
+			},
+		};
+		const context = buildResolverContext(resourceMap, {}, {});
+
+		const env = resolveComponentEnv(component, context, resourceMap);
+
+		expect(env.DATABASE_URL).toBe("postgresql://user:pass@localhost:5432/mydb");
+		expect(env.DB_HOST).toBe("localhost");
+	});
+
+	it("resolves component-level env defaults", () => {
+		const component: NormalizedComponent = {
+			env: {
+				PORT: { default: "8080" },
+				LOG_LEVEL: { default: "info" },
+			},
+		};
+		const context = buildResolverContext({}, {}, {});
+
+		const env = resolveComponentEnv(component, context, {});
+
+		expect(env.PORT).toBe("8080");
+		expect(env.LOG_LEVEL).toBe("info");
+	});
+
+	it("resolves cross-component references", () => {
+		const component: NormalizedComponent = {
+			env: {
+				BACKEND_URL: { default: "$components.backend.url" },
+			},
+		};
+		const context = buildResolverContext({}, { backend: 3000 }, {});
+
+		const env = resolveComponentEnv(component, context, {});
+
+		expect(env.BACKEND_URL).toBe("http://localhost:3000");
+	});
+
+	it("resolves secrets references", () => {
+		const component: NormalizedComponent = {
+			env: {
+				SECRET_KEY: { default: "$secrets.my-key" },
+			},
+		};
+		const context = buildResolverContext({}, {}, { "my-key": "super-secret" });
+
+		const env = resolveComponentEnv(component, context, {});
+
+		expect(env.SECRET_KEY).toBe("super-secret");
+	});
+
+	it("set_env takes precedence over component env", () => {
+		const component: NormalizedComponent = {
+			requires: [
+				{
+					type: "postgres",
+					set_env: { DATABASE_URL: "$url" },
+				},
+			],
+			env: {
+				DATABASE_URL: { default: "fallback" },
+			},
+		};
+		const resourceMap: Record<string, ResourceProperties> = {
+			postgres: {
+				url: "postgresql://real-url",
+				host: "localhost",
+				port: 5432,
+			},
+		};
+		const context = buildResolverContext(resourceMap, {}, {});
+
+		const env = resolveComponentEnv(component, context, resourceMap);
+
+		expect(env.DATABASE_URL).toBe("postgresql://real-url");
+	});
+});
+
+describe("generateSecrets", () => {
+	it("generates new secrets", async () => {
+		const defs: Record<string, Secret> = {
+			"jwt-secret": { generator: "secret" },
+			"app-uuid": { generator: "uuid" },
+		};
+
+		const secrets = await generateSecrets(defs, {});
+
+		expect(secrets["jwt-secret"]).toBeTruthy();
+		expect(secrets["app-uuid"]).toMatch(/^[0-9a-f-]+$/);
+	});
+
+	it("reuses existing secrets", async () => {
+		const defs: Record<string, Secret> = {
+			"jwt-secret": { generator: "secret" },
+		};
+		const existing = { "jwt-secret": "keep-this" };
+
+		const secrets = await generateSecrets(defs, existing);
+
+		expect(secrets["jwt-secret"]).toBe("keep-this");
+	});
+});

package/src/__tests__/lockfile-detect.test.ts

@@ -0,0 +1,74 @@
+import { describe, it, expect } from "vitest";
+import { detectPackageManager } from "../lockfile-detect.js";
+import { mkdtemp, writeFile, rm } from "node:fs/promises";
+import { join } from "node:path";
+import { tmpdir } from "node:os";
+
+describe("detectPackageManager", () => {
+	it("returns null for empty directory", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "lf-test-"));
+		try {
+			const pm = await detectPackageManager(dir);
+			expect(pm).toBeNull();
+		} finally {
+			await rm(dir, { recursive: true });
+		}
+	});
+
+	it("detects bun from bun.lockb", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "lf-test-"));
+		try {
+			await writeFile(join(dir, "bun.lockb"), "");
+			const pm = await detectPackageManager(dir);
+			expect(pm?.name).toBe("bun");
+			expect(pm?.installCommand).toBe("bun install");
+		} finally {
+			await rm(dir, { recursive: true });
+		}
+	});
+
+	it("detects yarn from yarn.lock", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "lf-test-"));
+		try {
+			await writeFile(join(dir, "yarn.lock"), "");
+			const pm = await detectPackageManager(dir);
+			expect(pm?.name).toBe("yarn");
+		} finally {
+			await rm(dir, { recursive: true });
+		}
+	});
+
+	it("detects pnpm from pnpm-lock.yaml", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "lf-test-"));
+		try {
+			await writeFile(join(dir, "pnpm-lock.yaml"), "");
+			const pm = await detectPackageManager(dir);
+			expect(pm?.name).toBe("pnpm");
+		} finally {
+			await rm(dir, { recursive: true });
+		}
+	});
+
+	it("detects bundler from Gemfile.lock", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "lf-test-"));
+		try {
+			await writeFile(join(dir, "Gemfile.lock"), "");
+			const pm = await detectPackageManager(dir);
+			expect(pm?.name).toBe("bundler");
+		} finally {
+			await rm(dir, { recursive: true });
+		}
+	});
+
+	it("prefers bun over yarn when both present", async () => {
+		const dir = await mkdtemp(join(tmpdir(), "lf-test-"));
+		try {
+			await writeFile(join(dir, "bun.lockb"), "");
+			await writeFile(join(dir, "yarn.lock"), "");
+			const pm = await detectPackageManager(dir);
+			expect(pm?.name).toBe("bun");
+		} finally {
+			await rm(dir, { recursive: true });
+		}
+	});
+});

package/src/__tests__/port-allocator.test.ts

@@ -0,0 +1,59 @@
+import { describe, it, expect } from "vitest";
+import { allocatePort, allocatePorts } from "../port-allocator.js";
+
+describe("allocatePort", () => {
+	it("returns a port in the expected range", async () => {
+		const port = await allocatePort("test-app", new Set());
+		expect(port).toBeGreaterThanOrEqual(10_000);
+		expect(port).toBeLessThan(20_000);
+	});
+
+	it("is deterministic for the same key", async () => {
+		const port1 = await allocatePort("my-app", new Set());
+		const port2 = await allocatePort("my-app", new Set());
+		expect(port1).toBe(port2);
+	});
+
+	it("avoids ports already in use", async () => {
+		const port1 = await allocatePort("collision-test", new Set());
+		const port2 = await allocatePort("collision-test", new Set([port1]));
+		expect(port2).not.toBe(port1);
+	});
+
+	it("produces different ports for different keys", async () => {
+		const port1 = await allocatePort("app-a", new Set());
+		const port2 = await allocatePort("app-b", new Set());
+		// Not guaranteed but overwhelmingly likely for different inputs
+		expect(port1).not.toBe(port2);
+	});
+});
+
+describe("allocatePorts", () => {
+	it("allocates ports for all components", async () => {
+		const components = {
+			backend: { provides: [{ port: 3000 }] },
+			frontend: { provides: [{ port: 3001 }] },
+		};
+		const ports = await allocatePorts(components, "test-app");
+		expect(ports.backend).toBeDefined();
+		expect(ports.frontend).toBeDefined();
+		expect(ports.backend).not.toBe(ports.frontend);
+	});
+
+	it("prefers the declared port if free", async () => {
+		const components = {
+			api: { provides: [{ port: 4567 }] },
+		};
+		const ports = await allocatePorts(components, "test-app");
+		expect(ports.api).toBe(4567);
+	});
+
+	it("reuses saved ports when available", async () => {
+		const components = {
+			api: { provides: [{ port: 3000 }] },
+		};
+		const saved = { api: 9876 };
+		const ports = await allocatePorts(components, "test-app", saved);
+		expect(ports.api).toBe(9876);
+	});
+});

package/src/__tests__/secret-generator.test.ts

@@ -0,0 +1,31 @@
+import { describe, it, expect } from "vitest";
+import { generateValue, generatePassword } from "../secret-generator.js";
+
+describe("generateValue", () => {
+	it("generates a base64url secret", async () => {
+		const value = await generateValue("secret");
+		expect(value).toMatch(/^[A-Za-z0-9_-]+$/);
+		expect(value.length).toBeGreaterThan(20);
+	});
+
+	it("generates a UUID", async () => {
+		const value = await generateValue("uuid");
+		expect(value).toMatch(
+			/^[0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[89ab][0-9a-f]{3}-[0-9a-f]{12}$/,
+		);
+	});
+
+	it("generates unique values each time", async () => {
+		const a = await generateValue("secret");
+		const b = await generateValue("secret");
+		expect(a).not.toBe(b);
+	});
+});
+
+describe("generatePassword", () => {
+	it("generates a URL-safe password", () => {
+		const pw = generatePassword();
+		expect(pw).toMatch(/^[A-Za-z0-9_-]+$/);
+		expect(pw.length).toBeGreaterThan(10);
+	});
+});

package/src/__tests__/state.test.ts

@@ -0,0 +1,33 @@
+import { describe, it, expect } from "vitest";
+import { initState, hashLaunchfile } from "../state.js";
+
+describe("initState", () => {
+	it("creates a state with correct app name", () => {
+		const state = initState("my-app", "name: my-app");
+		expect(state.appName).toBe("my-app");
+		expect(state.version).toBe(1);
+		expect(state.resources).toEqual({});
+		expect(state.secrets).toEqual({});
+		expect(state.ports).toEqual({});
+	});
+
+	it("hashes launchfile content", () => {
+		const state = initState("app", "some yaml content");
+		expect(state.launchfileHash).toBeTruthy();
+		expect(state.launchfileHash.length).toBe(16);
+	});
+});
+
+describe("hashLaunchfile", () => {
+	it("is deterministic", () => {
+		const a = hashLaunchfile("hello");
+		const b = hashLaunchfile("hello");
+		expect(a).toBe(b);
+	});
+
+	it("differs for different content", () => {
+		const a = hashLaunchfile("hello");
+		const b = hashLaunchfile("world");
+		expect(a).not.toBe(b);
+	});
+});

package/src/cli.ts

@@ -0,0 +1,78 @@
+#!/usr/bin/env bun
+/**
+ * CLI entry point for the macOS dev provider.
+ *
+ * Usage:
+ *   launch up [--with-optional] [--no-build] [--dry-run]
+ *   launch down [--destroy]
+ *   launch status
+ *   launch env [component]
+ */
+
+import { launchUp, launchDown, launchStatus, launchEnv } from "./provider.js";
+
+const args = process.argv.slice(2);
+const command = args[0];
+
+function hasFlag(flag: string): boolean {
+	return args.includes(`--${flag}`);
+}
+
+function getArg(index: number): string | undefined {
+	return args[index];
+}
+
+async function main(): Promise<void> {
+	switch (command) {
+		case "up":
+			await launchUp({
+				withOptional: hasFlag("with-optional"),
+				noBuild: hasFlag("no-build"),
+				dryRun: hasFlag("dry-run"),
+				detach: hasFlag("detach"),
+			});
+			break;
+
+		case "down":
+			await launchDown({
+				destroy: hasFlag("destroy"),
+			});
+			break;
+
+		case "status":
+			await launchStatus();
+			break;
+
+		case "env":
+			await launchEnv({
+				component: getArg(1),
+			});
+			break;
+
+		default:
+			console.log(`launch — macOS dev provider for Launchfile
+
+Usage:
+  launch up [--with-optional] [--no-build] [--dry-run]
+    Provision resources, install deps, and start the app.
+
+  launch down [--destroy]
+    Stop processes. --destroy also drops databases and cleans up.
+
+  launch status
+    Show status of components and resources.
+
+  launch env [component]
+    Print resolved environment variables.
+`);
+			if (command && command !== "help" && command !== "--help") {
+				console.error(`Unknown command: ${command}`);
+				process.exit(1);
+			}
+	}
+}
+
+main().catch((err) => {
+	console.error(err.message ?? err);
+	process.exit(1);
+});