@launchfile/macos-dev 0.2.0 → 0.3.0

package/dist/__tests__/dry-run.test.js

@@ -1,141 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { readFile } from "node:fs/promises";
-import { existsSync } from "node:fs";
-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 { allocatePorts } from "../port-allocator.js";
-const CATALOG_ROOT = join(import.meta.dirname, "../../../../catalog");
-const CATALOG_APPS = join(CATALOG_ROOT, "apps");
-const CATALOG_DRAFTS = join(CATALOG_ROOT, "drafts");
-/** Find a Launchfile in apps/ or drafts/ */
-function catalogPath(app) {
-    const appsPath = join(CATALOG_APPS, app, "Launchfile");
-    if (existsSync(appsPath))
-        return appsPath;
-    return join(CATALOG_DRAFTS, app, "Launchfile");
-}
-/**
- * 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(catalogPath("miniflux"), "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 = {
-            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(catalogPath("langfuse"), "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(catalogPath("chatwoot"), "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 = {
-            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 = {};
-        // 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 appsEntries = await readdir(CATALOG_APPS).catch(() => []);
-        const draftsEntries = await readdir(CATALOG_DRAFTS).catch(() => []);
-        const allApps = [...new Set([...appsEntries, ...draftsEntries])];
-        const unsupported = new Set();
-        for (const app of allApps) {
-            try {
-                const yaml = await readFile(catalogPath(app), "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);
-    });
-});
-//# sourceMappingURL=dry-run.test.js.map

package/dist/__tests__/env-writer.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=env-writer.test.d.ts.map

package/dist/__tests__/env-writer.test.js

@@ -1,201 +0,0 @@
-import { describe, it, expect } from "vitest";
-import { buildResolverContext, computeAppProperties, resolveComponentEnv, generateSecrets, } from "../env-writer.js";
-const NO_APP = {};
-describe("buildResolverContext", () => {
-    it("builds context from resources, ports, secrets, and app properties", () => {
-        const resources = {
-            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 app = { name: "my-app", host: "localhost", port: 3000, url: "http://localhost:3000" };
-        const ctx = buildResolverContext(resources, ports, secrets, app);
-        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");
-        expect(ctx.app?.url).toBe("http://localhost:3000");
-        expect(ctx.app?.name).toBe("my-app");
-    });
-});
-describe("computeAppProperties (D-33)", () => {
-    const baseLaunch = (overrides) => ({
-        name: "my-app",
-        components: {},
-        ...overrides,
-    });
-    it("uses the first exposed component's port for $app.port and $app.url", () => {
-        const launch = baseLaunch({
-            components: {
-                default: {
-                    provides: [{ protocol: "http", port: 3000, exposed: true }],
-                },
-            },
-        });
-        const app = computeAppProperties(launch, { default: 10042 });
-        expect(app.name).toBe("my-app");
-        expect(app.host).toBe("localhost");
-        expect(app.port).toBe(10042);
-        expect(app.url).toBe("http://localhost:10042");
-    });
-    it("picks the first exposed component in declaration order for multi-component apps", () => {
-        const launch = baseLaunch({
-            components: {
-                api: {
-                    provides: [{ protocol: "http", port: 4000, exposed: true }],
-                },
-                worker: {
-                    provides: [],
-                },
-                ui: {
-                    provides: [{ protocol: "http", port: 5000, exposed: true }],
-                },
-            },
-        });
-        const app = computeAppProperties(launch, { api: 10043, ui: 10044 });
-        // Picks "api" because it's first in declaration order with exposed: true.
-        expect(app.port).toBe(10043);
-        expect(app.url).toBe("http://localhost:10043");
-    });
-    it("returns port 0 and empty url when no component is exposed", () => {
-        const launch = baseLaunch({
-            components: {
-                worker: {
-                    provides: [],
-                },
-            },
-        });
-        const app = computeAppProperties(launch, {});
-        expect(app.port).toBe(0);
-        expect(app.url).toBe("");
-        expect(app.name).toBe("my-app");
-    });
-    // End-to-end: a component env var that uses $app.url resolves to the
-    // computed app URL. This is the contract that makes Firefly III's
-    // `APP_URL: default: $app.url` actually work end-to-end on macos-dev.
-    it("$app.url in component env defaults resolves to the computed URL", () => {
-        const launch = baseLaunch({
-            components: {
-                default: {
-                    provides: [{ protocol: "http", port: 3000, exposed: true }],
-                    env: { PUBLIC_URL: { default: "$app.url" } },
-                },
-            },
-        });
-        const app = computeAppProperties(launch, { default: 10042 });
-        const ctx = buildResolverContext({}, { default: 10042 }, {}, app);
-        const env = resolveComponentEnv(launch.components.default, ctx, {});
-        expect(env.PUBLIC_URL).toBe("http://localhost:10042");
-    });
-});
-describe("resolveComponentEnv", () => {
-    it("resolves set_env from requires", () => {
-        const component = {
-            requires: [
-                {
-                    type: "postgres",
-                    set_env: {
-                        DATABASE_URL: "$url",
-                        DB_HOST: "$host",
-                    },
-                },
-            ],
-        };
-        const resourceMap = {
-            postgres: {
-                url: "postgresql://user:pass@localhost:5432/mydb",
-                host: "localhost",
-                port: 5432,
-            },
-        };
-        const context = buildResolverContext(resourceMap, {}, {}, NO_APP);
-        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 = {
-            env: {
-                PORT: { default: "8080" },
-                LOG_LEVEL: { default: "info" },
-            },
-        };
-        const context = buildResolverContext({}, {}, {}, NO_APP);
-        const env = resolveComponentEnv(component, context, {});
-        expect(env.PORT).toBe("8080");
-        expect(env.LOG_LEVEL).toBe("info");
-    });
-    it("resolves cross-component references", () => {
-        const component = {
-            env: {
-                BACKEND_URL: { default: "$components.backend.url" },
-            },
-        };
-        const context = buildResolverContext({}, { backend: 3000 }, {}, NO_APP);
-        const env = resolveComponentEnv(component, context, {});
-        expect(env.BACKEND_URL).toBe("http://localhost:3000");
-    });
-    it("resolves secrets references", () => {
-        const component = {
-            env: {
-                SECRET_KEY: { default: "$secrets.my-key" },
-            },
-        };
-        const context = buildResolverContext({}, {}, { "my-key": "super-secret" }, NO_APP);
-        const env = resolveComponentEnv(component, context, {});
-        expect(env.SECRET_KEY).toBe("super-secret");
-    });
-    it("set_env takes precedence over component env", () => {
-        const component = {
-            requires: [
-                {
-                    type: "postgres",
-                    set_env: { DATABASE_URL: "$url" },
-                },
-            ],
-            env: {
-                DATABASE_URL: { default: "fallback" },
-            },
-        };
-        const resourceMap = {
-            postgres: {
-                url: "postgresql://real-url",
-                host: "localhost",
-                port: 5432,
-            },
-        };
-        const context = buildResolverContext(resourceMap, {}, {}, NO_APP);
-        const env = resolveComponentEnv(component, context, resourceMap);
-        expect(env.DATABASE_URL).toBe("postgresql://real-url");
-    });
-});
-describe("generateSecrets", () => {
-    it("generates new secrets", async () => {
-        const defs = {
-            "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 = {
-            "jwt-secret": { generator: "secret" },
-        };
-        const existing = { "jwt-secret": "keep-this" };
-        const secrets = await generateSecrets(defs, existing);
-        expect(secrets["jwt-secret"]).toBe("keep-this");
-    });
-});
-//# sourceMappingURL=env-writer.test.js.map

package/dist/__tests__/lockfile-detect.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=lockfile-detect.test.d.ts.map

package/dist/__tests__/lockfile-detect.test.js

@@ -1,75 +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 });
-        }
-    });
-});
-//# sourceMappingURL=lockfile-detect.test.js.map

package/dist/__tests__/port-allocator.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=port-allocator.test.d.ts.map

package/dist/__tests__/port-allocator.test.js

@@ -1,53 +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);
-    });
-});
-//# sourceMappingURL=port-allocator.test.js.map

package/dist/__tests__/secret-generator.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=secret-generator.test.d.ts.map

package/dist/__tests__/secret-generator.test.js

@@ -1,26 +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);
-    });
-});
-//# sourceMappingURL=secret-generator.test.js.map

package/dist/__tests__/state.test.d.ts

@@ -1,2 +0,0 @@
-export {};
-//# sourceMappingURL=state.test.d.ts.map

package/dist/__tests__/state.test.js

@@ -1,30 +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);
-    });
-});
-//# sourceMappingURL=state.test.js.map