@launchfile/macos-dev 0.1.4 → 0.3.0

package/src/resources/redis.ts

@@ -1,58 +0,0 @@
-/**
- * Redis resource provisioner via Homebrew.
- */
-
-import type { NormalizedRequirement } from "@launchfile/sdk";
-import { shell, shellOk } from "../shell.js";
-import type { ResourceState } from "../state.js";
-import type { ProvisionOpts, ResourceProperties, ResourceProvisioner } from "./types.js";
-
-const DEFAULT_PORT = 6379;
-const DEFAULT_HOST = "localhost";
-
-export class RedisProvisioner implements ResourceProvisioner {
-	readonly type = "redis";
-
-	async isRunning(): Promise<boolean> {
-		return shellOk("redis-cli ping");
-	}
-
-	async provision(
-		req: NormalizedRequirement,
-		_opts: ProvisionOpts,
-		_existingState?: ResourceState,
-	): Promise<{ properties: ResourceProperties; state: ResourceState }> {
-		if (!(await this.isRunning())) {
-			console.log("  Starting Redis via brew...");
-			const started = await shellOk("brew services start redis");
-			if (!started) {
-				await shell("brew install redis");
-				await shell("brew services start redis");
-			}
-		}
-
-		const port = DEFAULT_PORT;
-		const resourceName = req.name ?? req.type;
-
-		const properties: ResourceProperties = {
-			url: `redis://${DEFAULT_HOST}:${port}/0`,
-			host: DEFAULT_HOST,
-			port,
-			password: "",
-		};
-
-		const state: ResourceState = {
-			type: "redis",
-			name: resourceName,
-			brewService: "redis",
-			port,
-		};
-
-		return { properties, state };
-	}
-
-	async destroy(_state: ResourceState): Promise<void> {
-		// Redis is shared, don't stop the service
-		// Could flush a specific database prefix, but not worth the complexity
-	}
-}

package/src/resources/sqlite.ts

@@ -1,52 +0,0 @@
-/**
- * SQLite resource provisioner — just creates a directory for the DB file.
- */
-
-import { mkdir } from "node:fs/promises";
-import { join } from "node:path";
-import type { NormalizedRequirement } from "@launchfile/sdk";
-import type { ResourceState } from "../state.js";
-import type { ProvisionOpts, ResourceProperties, ResourceProvisioner } from "./types.js";
-
-export class SqliteProvisioner implements ResourceProvisioner {
-	readonly type = "sqlite";
-
-	async isRunning(): Promise<boolean> {
-		return true; // SQLite is always available
-	}
-
-	async provision(
-		req: NormalizedRequirement,
-		opts: ProvisionOpts,
-	): Promise<{ properties: ResourceProperties; state: ResourceState }> {
-		const resourceName = req.name ?? req.type;
-		const safeName = opts.appName.replace(/-/g, "_");
-		const dataDir = join(opts.projectDir, ".launchfile", "data", "sqlite");
-		await mkdir(dataDir, { recursive: true });
-
-		const dbPath = join(dataDir, `${safeName}.db`);
-
-		const properties: ResourceProperties = {
-			url: `sqlite://${dbPath}`,
-			host: "",
-			port: 0,
-			path: dbPath,
-		};
-
-		const state: ResourceState = {
-			type: "sqlite",
-			name: resourceName,
-			port: 0,
-			dbName: dbPath,
-		};
-
-		return { properties, state };
-	}
-
-	async destroy(state: ResourceState): Promise<void> {
-		if (state.dbName) {
-			const { rm } = await import("node:fs/promises");
-			await rm(state.dbName, { force: true });
-		}
-	}
-}

package/src/resources/types.ts

@@ -1,47 +0,0 @@
-/**
- * Resource provisioner interface.
- *
- * Each resource type (postgres, redis, etc.) implements this interface
- * to handle install, start, database creation, and teardown.
- */
-
-import type { NormalizedRequirement } from "@launchfile/sdk";
-import type { ResourceState } from "../state.js";
-
-/** Properties that a provisioned resource exposes for expression resolution */
-export interface ResourceProperties {
-	url: string;
-	host: string;
-	port: number;
-	user?: string;
-	password?: string;
-	name?: string;
-	path?: string;
-	access_key?: string;
-	secret_key?: string;
-	bucket?: string;
-	region?: string;
-	[key: string]: string | number | undefined;
-}
-
-export interface ProvisionOpts {
-	appName: string;
-	projectDir: string;
-}
-
-export interface ResourceProvisioner {
-	readonly type: string;
-
-	/** Check if the service is already running */
-	isRunning(): Promise<boolean>;
-
-	/** Ensure the service is installed and running, create app-specific resources */
-	provision(
-		req: NormalizedRequirement,
-		opts: ProvisionOpts,
-		existingState?: ResourceState,
-	): Promise<{ properties: ResourceProperties; state: ResourceState }>;
-
-	/** Drop app-specific databases/users (destroy mode) */
-	destroy(state: ResourceState): Promise<void>;
-}

package/src/runtimes/bun.ts

@@ -1,25 +0,0 @@
-/**
- * Bun runtime installer via Homebrew.
- */
-
-import { shellOk, shell } from "../shell.js";
-import type { RuntimeInstaller } from "./types.js";
-
-export class BunInstaller implements RuntimeInstaller {
-	readonly runtime = "bun";
-
-	async detectVersion(_projectDir: string): Promise<string | undefined> {
-		// Bun doesn't have a standard version file yet; use whatever is installed
-		return undefined;
-	}
-
-	async install(_version: string): Promise<void> {
-		if (!(await shellOk("which bun"))) {
-			await shell("brew install bun");
-		}
-	}
-
-	async shellEnv(_version: string): Promise<Record<string, string>> {
-		return {};
-	}
-}

package/src/runtimes/index.ts

@@ -1,24 +0,0 @@
-/**
- * Runtime installer registry.
- */
-
-import type { Runtime } from "@launchfile/sdk";
-import type { RuntimeInstaller } from "./types.js";
-import { NodeInstaller } from "./node.js";
-import { BunInstaller } from "./bun.js";
-import { RubyInstaller } from "./ruby.js";
-import { PythonInstaller } from "./python.js";
-
-const installers: Partial<Record<Runtime, RuntimeInstaller>> = {
-	node: new NodeInstaller(),
-	bun: new BunInstaller(),
-	ruby: new RubyInstaller(),
-	python: new PythonInstaller(),
-	// go, rust, etc. can be added later
-};
-
-export function getRuntimeInstaller(runtime: Runtime): RuntimeInstaller | undefined {
-	return installers[runtime];
-}
-
-export type { RuntimeInstaller } from "./types.js";

package/src/runtimes/node.ts

@@ -1,71 +0,0 @@
-/**
- * Node.js runtime installer via fnm (or nvm fallback).
- */
-
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { shell, shellOk } from "../shell.js";
-import type { RuntimeInstaller } from "./types.js";
-
-export class NodeInstaller implements RuntimeInstaller {
-	readonly runtime = "node";
-
-	async detectVersion(projectDir: string): Promise<string | undefined> {
-		// Priority: .nvmrc > .node-version > package.json engines.node
-		for (const file of [".nvmrc", ".node-version"]) {
-			try {
-				const content = await readFile(join(projectDir, file), "utf8");
-				const version = content.trim();
-				if (version) return version;
-			} catch {
-				// File doesn't exist
-			}
-		}
-
-		try {
-			const pkg = JSON.parse(await readFile(join(projectDir, "package.json"), "utf8"));
-			if (pkg.engines?.node) return pkg.engines.node;
-		} catch {
-			// No package.json
-		}
-
-		return undefined;
-	}
-
-	async install(version: string): Promise<void> {
-		// Prefer fnm (faster), fall back to nvm
-		if (await shellOk("which fnm")) {
-			await shell(`fnm install ${version}`);
-		} else if (await shellOk("which nvm")) {
-			await shell(`nvm install ${version}`);
-		} else {
-			console.log("  Installing fnm via brew...");
-			await shell("brew install fnm");
-			await shell(`fnm install ${version}`);
-		}
-	}
-
-	async shellEnv(_version: string): Promise<Record<string, string>> {
-		if (await shellOk("which fnm")) {
-			try {
-				const result = await shell("fnm env --shell bash", { silent: true });
-				return parseShellEnv(result.stdout);
-			} catch {
-				return {};
-			}
-		}
-		return {};
-	}
-}
-
-/** Parse `export KEY="VALUE"` lines from fnm env output */
-function parseShellEnv(output: string): Record<string, string> {
-	const env: Record<string, string> = {};
-	for (const line of output.split("\n")) {
-		const match = /^export\s+(\w+)="?([^"]*)"?/.exec(line);
-		if (match) {
-			env[match[1]!] = match[2]!;
-		}
-	}
-	return env;
-}

package/src/runtimes/python.ts

@@ -1,42 +0,0 @@
-/**
- * Python runtime installer via pyenv.
- */
-
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { shell, shellOk } from "../shell.js";
-import type { RuntimeInstaller } from "./types.js";
-
-export class PythonInstaller implements RuntimeInstaller {
-	readonly runtime = "python";
-
-	async detectVersion(projectDir: string): Promise<string | undefined> {
-		try {
-			const content = await readFile(join(projectDir, ".python-version"), "utf8");
-			return content.trim() || undefined;
-		} catch {
-			return undefined;
-		}
-	}
-
-	async install(version: string): Promise<void> {
-		if (!(await shellOk("which pyenv"))) {
-			await shell("brew install pyenv");
-		}
-		if (!(await shellOk(`pyenv versions --bare | grep -q "^${version}$"`))) {
-			await shell(`pyenv install ${version}`);
-		}
-		await shell(`pyenv local ${version}`);
-	}
-
-	async shellEnv(_version: string): Promise<Record<string, string>> {
-		if (await shellOk("which pyenv")) {
-			const result = await shell("pyenv root", { silent: true, allowFailure: true });
-			if (result.exitCode === 0) {
-				const root = result.stdout.trim();
-				return { PATH: `${root}/shims:${process.env.PATH ?? ""}` };
-			}
-		}
-		return {};
-	}
-}

package/src/runtimes/ruby.ts

@@ -1,55 +0,0 @@
-/**
- * Ruby runtime installer via rbenv.
- */
-
-import { readFile } from "node:fs/promises";
-import { join } from "node:path";
-import { shell, shellOk } from "../shell.js";
-import type { RuntimeInstaller } from "./types.js";
-
-export class RubyInstaller implements RuntimeInstaller {
-	readonly runtime = "ruby";
-
-	async detectVersion(projectDir: string): Promise<string | undefined> {
-		try {
-			const content = await readFile(join(projectDir, ".ruby-version"), "utf8");
-			return content.trim() || undefined;
-		} catch {
-			return undefined;
-		}
-	}
-
-	async install(version: string): Promise<void> {
-		if (!(await shellOk("which rbenv"))) {
-			await shell("brew install rbenv ruby-build");
-		}
-		const installed = await shellOk(`rbenv versions --bare | grep -q "^${version}$"`);
-		if (!installed) {
-			await shell(`rbenv install ${version}`);
-		}
-		await shell(`rbenv local ${version}`);
-	}
-
-	async shellEnv(_version: string): Promise<Record<string, string>> {
-		if (await shellOk("which rbenv")) {
-			try {
-				const result = await shell("rbenv init - bash", { silent: true });
-				return parseRbenvEnv(result.stdout);
-			} catch {
-				return {};
-			}
-		}
-		return {};
-	}
-}
-
-function parseRbenvEnv(output: string): Record<string, string> {
-	const env: Record<string, string> = {};
-	for (const line of output.split("\n")) {
-		const match = /^export\s+(\w+)="?([^"]*)"?/.exec(line);
-		if (match) {
-			env[match[1]!] = match[2]!;
-		}
-	}
-	return env;
-}

package/src/runtimes/types.ts

@@ -1,16 +0,0 @@
-/**
- * Runtime installer interface.
- */
-
-export interface RuntimeInstaller {
-	readonly runtime: string;
-
-	/** Detect the version from project files (.nvmrc, .ruby-version, etc.) */
-	detectVersion(projectDir: string): Promise<string | undefined>;
-
-	/** Ensure the runtime version is installed */
-	install(version: string): Promise<void>;
-
-	/** Get any shell env modifications needed (PATH, etc.) */
-	shellEnv(version: string): Promise<Record<string, string>>;
-}

package/src/secret-generator.ts

@@ -1,32 +0,0 @@
-/**
- * Secret and value generators for Launchfile env vars.
- */
-
-import { randomBytes, randomUUID } from "node:crypto";
-import type { Generator } from "@launchfile/sdk";
-import { allocatePort } from "./port-allocator.js";
-
-/**
- * Generate a value based on the generator type.
- */
-export async function generateValue(
-	generator: Generator,
-	existingPorts?: Set<number>,
-): Promise<string> {
-	switch (generator) {
-		case "secret":
-			return randomBytes(32).toString("base64url");
-		case "uuid":
-			return randomUUID();
-		case "port": {
-			const port = await allocatePort(`generated-${Date.now()}`, existingPorts ?? new Set());
-			return String(port);
-		}
-	}
-}
-
-/** Generate a password suitable for database users */
-export function generatePassword(): string {
-	// URL-safe so it can go in connection strings without encoding
-	return randomBytes(24).toString("base64url");
-}

package/src/shell.ts

@@ -1,70 +0,0 @@
-/**
- * Shell execution helper with timeout, logging, and structured results.
- */
-
-import { exec as cpExec, type ExecOptions } from "node:child_process";
-
-export interface ShellResult {
-	exitCode: number;
-	stdout: string;
-	stderr: string;
-}
-
-export interface ShellOpts {
-	cwd?: string;
-	env?: Record<string, string>;
-	timeout?: number;
-	/** If true, don't log the command being run */
-	silent?: boolean;
-}
-
-/**
- * Run a shell command and return structured output.
- * Throws on non-zero exit code unless `allowFailure` is set.
- */
-export async function shell(
-	command: string,
-	opts: ShellOpts & { allowFailure?: boolean } = {},
-): Promise<ShellResult> {
-	if (!opts.silent) {
-		console.log(`  $ ${command}`);
-	}
-
-	const execOpts: ExecOptions = {
-		cwd: opts.cwd,
-		env: opts.env ? { ...process.env, ...opts.env } : undefined,
-		timeout: opts.timeout ?? 120_000,
-		maxBuffer: 10 * 1024 * 1024,
-	};
-
-	return new Promise((resolve, reject) => {
-		cpExec(command, execOpts, (error, stdout, stderr) => {
-			const result: ShellResult = {
-				exitCode: error?.code ?? (typeof error?.code === "number" ? error.code : 0),
-				stdout: typeof stdout === "string" ? stdout : "",
-				stderr: typeof stderr === "string" ? stderr : "",
-			};
-
-			// Node's exec sets error.code to the exit code on non-zero
-			if (error && result.exitCode === 0) {
-				result.exitCode = 1;
-			}
-
-			if (error && !opts.allowFailure) {
-				reject(
-					Object.assign(new Error(`Command failed: ${command}\n${result.stderr}`), {
-						result,
-					}),
-				);
-			} else {
-				resolve(result);
-			}
-		});
-	});
-}
-
-/** Run a command, return true if exit code is 0 */
-export async function shellOk(command: string, opts?: ShellOpts): Promise<boolean> {
-	const result = await shell(command, { ...opts, allowFailure: true, silent: true });
-	return result.exitCode === 0;
-}

package/src/state.ts

@@ -1,92 +0,0 @@
-/**
- * State management for the macOS dev provider.
- *
- * Persists secrets, ports, and resource state in .launchfile/state.json
- * so credentials and ports are stable across restarts.
- */
-
-import { readFile, writeFile, mkdir } from "node:fs/promises";
-import { join } from "node:path";
-import { createHash } from "node:crypto";
-
-export interface ResourceState {
-	type: string;
-	name: string;
-	brewService?: string;
-	port: number;
-	dbName?: string;
-	user?: string;
-	password?: string;
-}
-
-export interface LaunchState {
-	version: 1;
-	appName: string;
-	launchfileHash: string;
-	createdAt: string;
-	updatedAt: string;
-	resources: Record<string, ResourceState>;
-	secrets: Record<string, string>;
-	ports: Record<string, number>;
-}
-
-const STATE_DIR = ".launchfile";
-const STATE_FILE = "state.json";
-
-function stateDir(projectDir: string): string {
-	return join(projectDir, STATE_DIR);
-}
-
-function statePath(projectDir: string): string {
-	return join(stateDir(projectDir), STATE_FILE);
-}
-
-export function hashLaunchfile(content: string): string {
-	return createHash("sha256").update(content).digest("hex").slice(0, 16);
-}
-
-/** Load state from disk, or return null if none exists */
-export async function loadState(projectDir: string): Promise<LaunchState | null> {
-	try {
-		const raw = await readFile(statePath(projectDir), "utf8");
-		return JSON.parse(raw) as LaunchState;
-	} catch {
-		return null;
-	}
-}
-
-/** Create a fresh state object */
-export function initState(appName: string, launchfileContent: string): LaunchState {
-	const now = new Date().toISOString();
-	return {
-		version: 1,
-		appName,
-		launchfileHash: hashLaunchfile(launchfileContent),
-		createdAt: now,
-		updatedAt: now,
-		resources: {},
-		secrets: {},
-		ports: {},
-	};
-}
-
-/** Save state to disk */
-export async function saveState(projectDir: string, state: LaunchState): Promise<void> {
-	state.updatedAt = new Date().toISOString();
-	// Security: restrict directory/file permissions — state.json contains
-	// database passwords and generated secrets in plaintext.
-	await mkdir(stateDir(projectDir), { recursive: true, mode: 0o700 });
-	await writeFile(statePath(projectDir), JSON.stringify(state, null, 2) + "\n", { mode: 0o600 });
-}
-
-/** Ensure .launchfile directories exist */
-export async function ensureDirs(projectDir: string): Promise<void> {
-	const dirs = ["storage", "tmp", "logs", "data", "env"];
-	// Security: restrict permissions — these dirs contain secrets, logs, env files
-	await Promise.all(
-		dirs.map((d) => mkdir(join(projectDir, STATE_DIR, d), { recursive: true, mode: 0o700 })),
-	);
-	// Safety net: write a .gitignore inside .launchfile/ so secrets aren't
-	// accidentally committed even if the project's .gitignore doesn't exclude it.
-	await writeFile(join(projectDir, STATE_DIR, ".gitignore"), "*\n", { mode: 0o644 });
-}

package/src/storage.ts

@@ -1,67 +0,0 @@
-/**
- * Local storage provisioning for Launchfile volumes.
- *
- * Maps container paths to local directories under .launchfile/.
- */
-
-import { mkdir, rm } from "node:fs/promises";
-import { join } from "node:path";
-import type { StorageVolume } from "@launchfile/sdk";
-
-const STATE_DIR = ".launchfile";
-
-/**
- * Create local directories for a component's storage volumes.
- * Returns a map of container path → local path.
- */
-export async function provisionStorage(
-	storage: Record<string, StorageVolume> | undefined,
-	componentName: string,
-	projectDir: string,
-): Promise<Record<string, string>> {
-	if (!storage) return {};
-
-	const volumeMap: Record<string, string> = {};
-
-	for (const [name, volume] of Object.entries(storage)) {
-		const persistent = volume.persistent !== false; // default true
-		const subdir = persistent ? "storage" : "tmp";
-		const localPath = join(projectDir, STATE_DIR, subdir, componentName, name);
-
-		await mkdir(localPath, { recursive: true });
-		volumeMap[volume.path] = localPath;
-	}
-
-	return volumeMap;
-}
-
-/** Clean up ephemeral (non-persistent) storage for a component */
-export async function cleanEphemeralStorage(
-	storage: Record<string, StorageVolume> | undefined,
-	componentName: string,
-	projectDir: string,
-): Promise<void> {
-	if (!storage) return;
-
-	for (const [name, volume] of Object.entries(storage)) {
-		if (volume.persistent === false) {
-			const localPath = join(projectDir, STATE_DIR, "tmp", componentName, name);
-			await rm(localPath, { recursive: true, force: true });
-		}
-	}
-}
-
-/** Clean up all storage (persistent + ephemeral) for a component */
-export async function destroyStorage(
-	componentName: string,
-	projectDir: string,
-): Promise<void> {
-	await rm(join(projectDir, STATE_DIR, "storage", componentName), {
-		recursive: true,
-		force: true,
-	});
-	await rm(join(projectDir, STATE_DIR, "tmp", componentName), {
-		recursive: true,
-		force: true,
-	});
-}

package/tsconfig.json

@@ -1,18 +0,0 @@
-{
-  "compilerOptions": {
-    "target": "ESNext",
-    "module": "ESNext",
-    "moduleResolution": "bundler",
-    "strict": true,
-    "noUncheckedIndexedAccess": true,
-    "isolatedModules": true,
-    "declaration": true,
-    "declarationMap": true,
-    "sourceMap": true,
-    "rootDir": "src",
-    "outDir": "dist",
-    "types": ["bun-types", "vitest/globals"],
-    "skipLibCheck": true
-  },
-  "include": ["src/**/*.ts"]
-}