@launchfile/macos-dev 0.1.4 → 0.3.0

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

@@ -1,156 +0,0 @@
-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

@@ -1,74 +0,0 @@
-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

@@ -1,59 +0,0 @@
-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

@@ -1,31 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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

@@ -1,78 +0,0 @@
-#!/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);
-});

package/src/env-writer.ts

@@ -1,231 +0,0 @@
-/**
- * Environment variable resolver and writer.
- *
- * Connects provisioned resource properties to the SDK's expression resolver,
- * then writes the results to .env files.
- */
-
-import { writeFile, mkdir } from "node:fs/promises";
-import { join } from "node:path";
-import {
-	resolveExpression,
-	isExpression,
-	type NormalizedComponent,
-	type NormalizedLaunch,
-	type Secret,
-} from "@launchfile/sdk";
-import type { ResourceProperties } from "./resources/types.js";
-import { generateValue } from "./secret-generator.js";
-
-/**
- * Context for the SDK's resolveExpression().
- * Mirrors the interface from sdk/src/resolver.ts since it's not exported.
- */
-export interface ResolverContext {
-	resource?: Record<string, string | number>;
-	resources?: Record<string, Record<string, string | number>>;
-	components?: Record<string, Record<string, string | number>>;
-	secrets?: Record<string, string>;
-}
-
-/**
- * Build a ResolverContext from provisioned resources, component ports, and secrets.
- */
-export function buildResolverContext(
-	resourceMap: Record<string, ResourceProperties>,
-	componentPorts: Record<string, number>,
-	secrets: Record<string, string>,
-): ResolverContext {
-	// Build components map from ports
-	const components: Record<string, Record<string, string | number>> = {};
-	for (const [name, port] of Object.entries(componentPorts)) {
-		components[name] = {
-			url: `http://localhost:${port}`,
-			host: "localhost",
-			port,
-		};
-	}
-
-	// Build named resources map
-	const resources: Record<string, Record<string, string | number>> = {};
-	for (const [name, props] of Object.entries(resourceMap)) {
-		const record: Record<string, string | number> = {};
-		for (const [k, v] of Object.entries(props)) {
-			if (v !== undefined) {
-				record[k] = v;
-			}
-		}
-		resources[name] = record;
-	}
-
-	return { resources, components, secrets };
-}
-
-/**
- * Resolve all environment variables for a single component.
- */
-export function resolveComponentEnv(
-	component: NormalizedComponent,
-	context: ResolverContext,
-	resourceMap: Record<string, ResourceProperties>,
-): Record<string, string> {
-	const env: Record<string, string> = {};
-
-	// 1. Resolve set_env from requires
-	for (const req of component.requires ?? []) {
-		const resourceName = req.name ?? req.type;
-		const props = resourceMap[resourceName];
-		if (!req.set_env || !props) continue;
-
-		// Build resource-scoped context (enclosing resource)
-		const resourceRecord: Record<string, string | number> = {};
-		for (const [k, v] of Object.entries(props)) {
-			if (v !== undefined) resourceRecord[k] = v;
-		}
-		const scopedContext: ResolverContext = {
-			...context,
-			resource: resourceRecord,
-		};
-
-		for (const [envKey, expr] of Object.entries(req.set_env)) {
-			env[envKey] = resolveExpression(expr, scopedContext);
-		}
-	}
-
-	// 2. Resolve set_env from supports (only if resource was provisioned)
-	for (const sup of component.supports ?? []) {
-		const resourceName = sup.name ?? sup.type;
-		const props = resourceMap[resourceName];
-		if (!sup.set_env || !props) continue;
-
-		const resourceRecord: Record<string, string | number> = {};
-		for (const [k, v] of Object.entries(props)) {
-			if (v !== undefined) resourceRecord[k] = v;
-		}
-		const scopedContext: ResolverContext = {
-			...context,
-			resource: resourceRecord,
-		};
-
-		for (const [envKey, expr] of Object.entries(sup.set_env)) {
-			env[envKey] = resolveExpression(expr, scopedContext);
-		}
-	}
-
-	// 3. Resolve component-level env vars
-	if (component.env) {
-		for (const [key, envVar] of Object.entries(component.env)) {
-			if (env[key] !== undefined) continue; // set_env takes precedence
-
-			if (envVar.default !== undefined) {
-				const defaultStr = String(envVar.default);
-				if (isExpression(defaultStr)) {
-					env[key] = resolveExpression(defaultStr, context);
-				} else {
-					env[key] = defaultStr;
-				}
-			}
-			// required + no default + no generator → left unset (provider should prompt)
-		}
-	}
-
-	return env;
-}
-
-/**
- * Generate all app-wide secrets, reusing values from state when available.
- */
-export async function generateSecrets(
-	secretDefs: Record<string, Secret> | undefined,
-	existingSecrets: Record<string, string>,
-): Promise<Record<string, string>> {
-	if (!secretDefs) return { ...existingSecrets };
-
-	const secrets = { ...existingSecrets };
-	for (const [name, def] of Object.entries(secretDefs)) {
-		if (!secrets[name]) {
-			secrets[name] = await generateValue(def.generator);
-		}
-	}
-	return secrets;
-}
-
-/**
- * Generate values for env vars that have generators.
- * Mutates the env record in place.
- */
-export async function resolveGenerators(
-	component: NormalizedComponent,
-	env: Record<string, string>,
-): Promise<void> {
-	if (!component.env) return;
-
-	for (const [key, envVar] of Object.entries(component.env)) {
-		if (env[key] !== undefined) continue;
-		if (envVar.generator) {
-			env[key] = await generateValue(envVar.generator);
-		}
-	}
-}
-
-/**
- * Write resolved env vars to a .env file.
- */
-export async function writeEnvFile(
-	filePath: string,
-	env: Record<string, string>,
-): Promise<void> {
-	const lines = Object.entries(env)
-		.sort(([a], [b]) => a.localeCompare(b))
-		.map(([key, value]) => {
-			// Quote values that contain spaces, #, or newlines
-			if (/[\s#\n]/.test(value)) {
-				return `${key}="${value.replace(/"/g, '\\"')}"`;
-			}
-			return `${key}=${value}`;
-		});
-
-	const content = `# Generated by launch up — do not edit manually\n${lines.join("\n")}\n`;
-	// Security: env files contain database URLs with passwords and generated secrets
-	await writeFile(filePath, content, { mode: 0o600 });
-}
-
-/**
- * Resolve and write env files for all components.
- * Single-component → .env.local at project root.
- * Multi-component → .launchfile/env/<component>.env per component.
- */
-export async function writeAllEnvFiles(
-	launch: NormalizedLaunch,
-	context: ResolverContext,
-	resourceMap: Record<string, ResourceProperties>,
-	componentPorts: Record<string, number>,
-	projectDir: string,
-): Promise<Record<string, Record<string, string>>> {
-	const allEnvs: Record<string, Record<string, string>> = {};
-	const componentNames = Object.keys(launch.components);
-	const isSingleComponent = componentNames.length === 1 && componentNames[0] === "default";
-
-	for (const [name, component] of Object.entries(launch.components)) {
-		const env = resolveComponentEnv(component, context, resourceMap);
-		await resolveGenerators(component, env);
-
-		// Inject PORT if not already set and component has provides
-		const port = componentPorts[name];
-		if (port && !env.PORT) {
-			env.PORT = String(port);
-		}
-
-		allEnvs[name] = env;
-
-		if (isSingleComponent) {
-			await writeEnvFile(join(projectDir, ".env.local"), env);
-		} else {
-			const envDir = join(projectDir, ".launchfile", "env");
-			await mkdir(envDir, { recursive: true });
-			await writeEnvFile(join(envDir, `${name}.env`), env);
-		}
-	}
-
-	return allEnvs;
-}