@launchfile/macos-dev 0.1.4 → 0.3.0

package/src/health.ts

@@ -1,80 +0,0 @@
-/**
- * Health check polling for components.
- */
-
-import type { NormalizedHealth } from "@launchfile/sdk";
-import { shell } from "./shell.js";
-
-/** Parse a duration string like "30s", "1m", "500ms" to milliseconds */
-export function parseDuration(duration: string): number {
-	const match = /^(\d+)(ms|s|m)$/.exec(duration);
-	if (!match) return 0;
-	const value = Number.parseInt(match[1]!, 10);
-	switch (match[2]) {
-		case "ms":
-			return value;
-		case "s":
-			return value * 1000;
-		case "m":
-			return value * 60_000;
-		default:
-			return 0;
-	}
-}
-
-/**
- * Wait for a component to become healthy.
- * Returns true if healthy, false if timed out.
- */
-export async function waitForHealthy(
-	name: string,
-	health: NormalizedHealth,
-	port: number,
-	overallTimeout: number = 60_000,
-): Promise<boolean> {
-	const startPeriod = parseDuration(health.start_period ?? "0s");
-	const interval = parseDuration(health.interval ?? "3s");
-	const checkTimeout = parseDuration(health.timeout ?? "5s");
-
-	// Wait for start period
-	if (startPeriod > 0) {
-		console.log(`  [${name}] Waiting ${health.start_period} start period...`);
-		await sleep(startPeriod);
-	}
-
-	const deadline = Date.now() + overallTimeout;
-
-	while (Date.now() < deadline) {
-		try {
-			if (health.path) {
-				const resp = await fetch(`http://localhost:${port}${health.path}`, {
-					signal: AbortSignal.timeout(checkTimeout),
-				});
-				if (resp.ok) {
-					console.log(`  [${name}] Healthy`);
-					return true;
-				}
-			} else if (health.command) {
-				await shell(health.command, { timeout: checkTimeout, silent: true });
-				console.log(`  [${name}] Healthy`);
-				return true;
-			} else {
-				// No specific check — try connecting to the port
-				const resp = await fetch(`http://localhost:${port}/`, {
-					signal: AbortSignal.timeout(checkTimeout),
-				}).catch(() => null);
-				if (resp) return true;
-			}
-		} catch {
-			// Expected — service not ready yet
-		}
-		await sleep(interval);
-	}
-
-	console.error(`  [${name}] Health check timed out after ${overallTimeout}ms`);
-	return false;
-}
-
-function sleep(ms: number): Promise<void> {
-	return new Promise((resolve) => setTimeout(resolve, ms));
-}

package/src/index.ts

@@ -1,9 +0,0 @@
-/**
- * macOS Dev Provider for Launchfile.
- *
- * Run apps locally on macOS with brew services for databases
- * and native runtimes for the app itself.
- */
-
-export { launchUp, launchDown, launchStatus, launchEnv } from "./provider.js";
-export type { LaunchUpOpts } from "./provider.js";

package/src/lockfile-detect.ts

@@ -1,48 +0,0 @@
-/**
- * Detect the package manager from lockfile presence.
- */
-
-import { access } from "node:fs/promises";
-import { join } from "node:path";
-
-export interface PackageManager {
-	name: string;
-	installCommand: string;
-	lockfile: string;
-}
-
-const LOCKFILE_ORDER: PackageManager[] = [
-	{ name: "bun", installCommand: "bun install", lockfile: "bun.lockb" },
-	{ name: "bun", installCommand: "bun install", lockfile: "bun.lock" },
-	{ name: "pnpm", installCommand: "pnpm install", lockfile: "pnpm-lock.yaml" },
-	{ name: "yarn", installCommand: "yarn install", lockfile: "yarn.lock" },
-	{ name: "npm", installCommand: "npm install", lockfile: "package-lock.json" },
-	{ name: "bundler", installCommand: "bundle install", lockfile: "Gemfile.lock" },
-	{ name: "go", installCommand: "go mod download", lockfile: "go.sum" },
-	{ name: "cargo", installCommand: "cargo build", lockfile: "Cargo.lock" },
-	{ name: "pip", installCommand: "pip install -r requirements.txt", lockfile: "requirements.txt" },
-	{ name: "poetry", installCommand: "poetry install", lockfile: "poetry.lock" },
-	{ name: "uv", installCommand: "uv sync", lockfile: "uv.lock" },
-];
-
-async function fileExists(path: string): Promise<boolean> {
-	try {
-		await access(path);
-		return true;
-	} catch {
-		return false;
-	}
-}
-
-/**
- * Detect the package manager from lockfile presence in a directory.
- * Returns the first match in priority order, or null.
- */
-export async function detectPackageManager(projectDir: string): Promise<PackageManager | null> {
-	for (const pm of LOCKFILE_ORDER) {
-		if (await fileExists(join(projectDir, pm.lockfile))) {
-			return pm;
-		}
-	}
-	return null;
-}

package/src/port-allocator.ts

@@ -1,97 +0,0 @@
-/**
- * Deterministic port allocation for Launchfile apps.
- *
- * Ports are derived from a hash of the app name so they're stable across runs
- * and machines. If a port is in use, we scan upward for the next free one.
- */
-
-import { createServer } from "node:net";
-
-/** Base range for allocated ports */
-const PORT_RANGE_START = 10_000;
-const PORT_RANGE_SIZE = 10_000;
-
-/** Simple string hash → number in a range */
-function hashToRange(input: string, rangeSize: number): number {
-	let hash = 0;
-	for (let i = 0; i < input.length; i++) {
-		hash = (hash * 31 + input.charCodeAt(i)) | 0;
-	}
-	return Math.abs(hash) % rangeSize;
-}
-
-/** Check if a port is available by attempting to listen on it */
-async function isPortFree(port: number): Promise<boolean> {
-	return new Promise((resolve) => {
-		const server = createServer();
-		server.once("error", () => resolve(false));
-		server.once("listening", () => {
-			server.close(() => resolve(true));
-		});
-		server.listen(port, "127.0.0.1");
-	});
-}
-
-/**
- * Allocate a port for a given key (e.g., "myapp" or "myapp:backend").
- * Uses deterministic hashing for stability, with fallback scan.
- */
-export async function allocatePort(
-	key: string,
-	existingPorts: Set<number>,
-): Promise<number> {
-	const preferred = PORT_RANGE_START + hashToRange(key, PORT_RANGE_SIZE);
-
-	// Try the preferred port first
-	if (!existingPorts.has(preferred) && (await isPortFree(preferred))) {
-		return preferred;
-	}
-
-	// Scan upward for the next free port
-	for (let offset = 1; offset < PORT_RANGE_SIZE; offset++) {
-		const candidate = PORT_RANGE_START + ((preferred - PORT_RANGE_START + offset) % PORT_RANGE_SIZE);
-		if (!existingPorts.has(candidate) && (await isPortFree(candidate))) {
-			return candidate;
-		}
-	}
-
-	throw new Error(`No free port found in range ${PORT_RANGE_START}–${PORT_RANGE_START + PORT_RANGE_SIZE}`);
-}
-
-/**
- * Allocate ports for all components in a launch config.
- * Returns a map of component name → port.
- */
-export async function allocatePorts(
-	components: Record<string, { provides?: Array<{ port: number }> }>,
-	appName: string,
-	savedPorts?: Record<string, number>,
-): Promise<Record<string, number>> {
-	const allocated = new Set<number>();
-	const result: Record<string, number> = {};
-
-	for (const [name, component] of Object.entries(components)) {
-		// Reuse saved port if still free
-		const saved = savedPorts?.[name];
-		if (saved && (await isPortFree(saved))) {
-			result[name] = saved;
-			allocated.add(saved);
-			continue;
-		}
-
-		// Use the component's declared port if free
-		const declaredPort = component.provides?.[0]?.port;
-		if (declaredPort && !allocated.has(declaredPort) && (await isPortFree(declaredPort))) {
-			result[name] = declaredPort;
-			allocated.add(declaredPort);
-			continue;
-		}
-
-		// Fall back to deterministic allocation
-		const port = await allocatePort(`${appName}:${name}`, allocated);
-		result[name] = port;
-		allocated.add(port);
-	}
-
-	return result;
-}

package/src/prereqs.ts

@@ -1,32 +0,0 @@
-/**
- * Prerequisite checks for the macOS dev provider.
- */
-
-import { shellOk } from "./shell.js";
-
-export interface PrereqResult {
-	ok: boolean;
-	missing: string[];
-	warnings: string[];
-}
-
-export async function checkPrereqs(): Promise<PrereqResult> {
-	const missing: string[] = [];
-	const warnings: string[] = [];
-
-	// Homebrew is required
-	if (!(await shellOk("which brew"))) {
-		missing.push("Homebrew — install from https://brew.sh");
-	}
-
-	// Git is required (for cloning)
-	if (!(await shellOk("which git"))) {
-		missing.push("git — install via: brew install git");
-	}
-
-	return {
-		ok: missing.length === 0,
-		missing,
-		warnings,
-	};
-}

package/src/process-manager.ts

@@ -1,242 +0,0 @@
-/**
- * Lightweight process manager for multi-component Launchfile apps.
- *
- * Handles topological startup ordering, log multiplexing,
- * health check waits, and graceful shutdown.
- */
-
-import { spawn, type ChildProcess } from "node:child_process";
-import { createWriteStream, mkdirSync } from "node:fs";
-import { join } from "node:path";
-import type { NormalizedHealth, NormalizedDependsOnEntry } from "@launchfile/sdk";
-import { waitForHealthy } from "./health.js";
-
-// ANSI colors for log prefixing
-const COLORS = [
-	"\x1b[36m", // cyan
-	"\x1b[33m", // yellow
-	"\x1b[32m", // green
-	"\x1b[35m", // magenta
-	"\x1b[34m", // blue
-	"\x1b[31m", // red
-];
-const RESET = "\x1b[0m";
-
-interface ManagedProcess {
-	name: string;
-	command: string;
-	env: Record<string, string>;
-	cwd: string;
-	dependsOn: NormalizedDependsOnEntry[];
-	health?: NormalizedHealth;
-	port?: number;
-	process?: ChildProcess;
-	status: "pending" | "starting" | "running" | "healthy" | "failed" | "stopped";
-}
-
-export class ProcessManager {
-	private processes = new Map<string, ManagedProcess>();
-	private logDir: string;
-
-	constructor(projectDir: string) {
-		this.logDir = join(projectDir, ".launchfile", "logs");
-		// Security: restrict permissions — logs may contain sensitive output
-		mkdirSync(this.logDir, { recursive: true, mode: 0o700 });
-	}
-
-	register(
-		name: string,
-		config: {
-			command: string;
-			env: Record<string, string>;
-			cwd: string;
-			dependsOn?: NormalizedDependsOnEntry[];
-			health?: NormalizedHealth;
-			port?: number;
-		},
-	): void {
-		this.processes.set(name, {
-			name,
-			command: config.command,
-			env: config.env,
-			cwd: config.cwd,
-			dependsOn: config.dependsOn ?? [],
-			health: config.health,
-			port: config.port,
-			status: "pending",
-		});
-	}
-
-	/**
-	 * Start all registered processes respecting dependency order.
-	 */
-	async startAll(): Promise<void> {
-		const batches = this.topologicalSort();
-
-		for (const batch of batches) {
-			// Start all processes in this batch concurrently
-			await Promise.all(batch.map((name) => this.startOne(name)));
-		}
-
-		console.log("\n  All components started.");
-	}
-
-	private async startOne(name: string): Promise<void> {
-		const proc = this.processes.get(name);
-		if (!proc) throw new Error(`Unknown component: ${name}`);
-
-		// Wait for dependencies
-		for (const dep of proc.dependsOn) {
-			const depProc = this.processes.get(dep.component);
-			if (!depProc) continue;
-
-			if (dep.condition === "healthy") {
-				console.log(`  [${name}] Waiting for ${dep.component} to be healthy...`);
-				if (depProc.health && depProc.port) {
-					await waitForHealthy(dep.component, depProc.health, depProc.port);
-				}
-			}
-			// For "started" condition, the process is already spawned by the time we get here
-		}
-
-		proc.status = "starting";
-		console.log(`  [${name}] Starting: ${proc.command}`);
-
-		const logFile = createWriteStream(join(this.logDir, `${name}.log`), { flags: "a" });
-		const colorIdx = [...this.processes.keys()].indexOf(name) % COLORS.length;
-		const color = COLORS[colorIdx]!;
-		const maxNameLen = Math.max(...[...this.processes.keys()].map((n) => n.length));
-		const paddedName = name.padEnd(maxNameLen);
-
-		proc.process = spawn("sh", ["-c", proc.command], {
-			env: { ...process.env, ...proc.env },
-			cwd: proc.cwd,
-			stdio: ["ignore", "pipe", "pipe"],
-		});
-
-		// Pipe stdout with prefix
-		proc.process.stdout?.on("data", (data: Buffer) => {
-			const lines = data.toString().split("\n");
-			for (const line of lines) {
-				if (line) {
-					process.stdout.write(`${color}[${paddedName}]${RESET} ${line}\n`);
-					logFile.write(`${new Date().toISOString()} ${line}\n`);
-				}
-			}
-		});
-
-		// Pipe stderr with prefix
-		proc.process.stderr?.on("data", (data: Buffer) => {
-			const lines = data.toString().split("\n");
-			for (const line of lines) {
-				if (line) {
-					process.stderr.write(`${color}[${paddedName}]${RESET} \x1b[2m${line}${RESET}\n`);
-					logFile.write(`${new Date().toISOString()} ERR ${line}\n`);
-				}
-			}
-		});
-
-		proc.process.on("exit", (code) => {
-			proc.status = code === 0 ? "stopped" : "failed";
-			console.log(
-				`${color}[${paddedName}]${RESET} Process exited with code ${code}`,
-			);
-			logFile.end();
-		});
-
-		proc.status = "running";
-	}
-
-	/**
-	 * Graceful shutdown in reverse dependency order.
-	 */
-	async stopAll(): Promise<void> {
-		const batches = this.topologicalSort().reverse();
-
-		for (const batch of batches) {
-			await Promise.all(
-				batch.map((name) => {
-					const proc = this.processes.get(name);
-					if (!proc?.process || proc.status === "stopped") return Promise.resolve();
-					return this.stopOne(proc);
-				}),
-			);
-		}
-	}
-
-	private stopOne(proc: ManagedProcess): Promise<void> {
-		return new Promise((resolve) => {
-			if (!proc.process) {
-				resolve();
-				return;
-			}
-
-			const timeout = setTimeout(() => {
-				proc.process?.kill("SIGKILL");
-			}, 10_000);
-
-			proc.process.once("exit", () => {
-				clearTimeout(timeout);
-				proc.status = "stopped";
-				resolve();
-			});
-
-			proc.process.kill("SIGTERM");
-		});
-	}
-
-	/**
-	 * Topological sort based on depends_on.
-	 * Returns batches of component names that can start concurrently.
-	 */
-	private topologicalSort(): string[][] {
-		const names = [...this.processes.keys()];
-		const inDegree = new Map<string, number>();
-		const dependents = new Map<string, string[]>();
-
-		for (const name of names) {
-			inDegree.set(name, 0);
-			dependents.set(name, []);
-		}
-
-		for (const [name, proc] of this.processes) {
-			for (const dep of proc.dependsOn) {
-				if (this.processes.has(dep.component)) {
-					inDegree.set(name, (inDegree.get(name) ?? 0) + 1);
-					dependents.get(dep.component)!.push(name);
-				}
-			}
-		}
-
-		const batches: string[][] = [];
-		let remaining = new Set(names);
-
-		while (remaining.size > 0) {
-			const batch = [...remaining].filter((n) => (inDegree.get(n) ?? 0) === 0);
-			if (batch.length === 0) {
-				// Circular dependency — just add remaining
-				batches.push([...remaining]);
-				break;
-			}
-			batches.push(batch);
-			for (const name of batch) {
-				remaining.delete(name);
-				for (const dependent of dependents.get(name) ?? []) {
-					inDegree.set(dependent, (inDegree.get(dependent) ?? 0) - 1);
-				}
-			}
-		}
-
-		return batches;
-	}
-
-	/** Get status summary for all processes */
-	getStatus(): Array<{ name: string; status: string; pid?: number; port?: number }> {
-		return [...this.processes.entries()].map(([name, proc]) => ({
-			name,
-			status: proc.status,
-			pid: proc.process?.pid,
-			port: proc.port,
-		}));
-	}
-}