@launchfile/macos-dev 0.1.4 → 0.2.0

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

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

package/dist/__tests__/bootstrap.test.js

@@ -0,0 +1,90 @@
+import { describe, it, expect } from "vitest";
+import { extractCaptures, parseDuration } from "../bootstrap.js";
+describe("extractCaptures (D-34)", () => {
+    it("extracts a single-group regex from stdout", () => {
+        const captures = {
+            invite_link: {
+                pattern: "https?://\\S+",
+                description: "One-time invite link",
+                sensitive: true,
+            },
+        };
+        const stdout = "Admin created.\nInvite URL: https://example.com/invite/abc123\n";
+        expect(extractCaptures(stdout, captures)).toEqual({
+            invite_link: "https://example.com/invite/abc123",
+        });
+    });
+    it("uses first capture group when present", () => {
+        const captures = {
+            password: {
+                pattern: "Admin password: (.+)",
+            },
+        };
+        const stdout = "Admin password: s3cret!\n";
+        expect(extractCaptures(stdout, captures)).toEqual({
+            password: "s3cret!",
+        });
+    });
+    it("returns empty result when no patterns match", () => {
+        const captures = {
+            token: { pattern: "token=(\\S+)" },
+        };
+        expect(extractCaptures("nothing to see here", captures)).toEqual({});
+    });
+    it("strips ANSI escape codes before matching", () => {
+        const captures = {
+            url: { pattern: "https?://\\S+" },
+        };
+        // Simulates colorized output from a CLI tool that detects a TTY
+        const stdout = "\x1b[32mSuccess:\x1b[0m visit \x1b[4mhttps://example.com/admin\x1b[0m to continue";
+        expect(extractCaptures(stdout, captures)).toEqual({
+            url: "https://example.com/admin",
+        });
+    });
+    it("skips invalid regex without throwing", () => {
+        const captures = {
+            bad: { pattern: "(unclosed" },
+            good: { pattern: "ok" },
+        };
+        const result = extractCaptures("ok here", captures);
+        // good matches; bad is skipped
+        expect(result.good).toBe("ok");
+        expect(result.bad).toBeUndefined();
+    });
+    it("handles multiple captures in one stdout", () => {
+        const captures = {
+            user: { pattern: "user=(\\S+)" },
+            pw: { pattern: "pw=(\\S+)" },
+        };
+        const stdout = "Created user=alice pw=hunter2 expires=1h\n";
+        expect(extractCaptures(stdout, captures)).toEqual({
+            user: "alice",
+            pw: "hunter2",
+        });
+    });
+    it("returns full match when pattern has no capture group", () => {
+        const captures = {
+            hash: { pattern: "[a-f0-9]{8}" },
+        };
+        const stdout = "Commit: deadbeef\n";
+        expect(extractCaptures(stdout, captures)).toEqual({
+            hash: "deadbeef",
+        });
+    });
+});
+describe("parseDuration", () => {
+    it("parses ms, s, m, h units", () => {
+        expect(parseDuration("500ms")).toBe(500);
+        expect(parseDuration("30s")).toBe(30_000);
+        expect(parseDuration("5m")).toBe(300_000);
+        expect(parseDuration("2h")).toBe(7_200_000);
+    });
+    it("tolerates whitespace", () => {
+        expect(parseDuration(" 10s ")).toBe(10_000);
+    });
+    it("falls back to default for invalid input", () => {
+        expect(parseDuration("bogus")).toBe(120_000);
+        expect(parseDuration("")).toBe(120_000);
+    });
+});
+//# sourceMappingURL=bootstrap.test.js.map

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

@@ -1,18 +1,28 @@
 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_DIR = join(import.meta.dirname, "../../../../catalog/drafts");
+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(join(CATALOG_DIR, "miniflux/Launchfile"), "utf8");
+        const yaml = await readFile(catalogPath("miniflux"), "utf8");
         const launch = readLaunch(yaml);
         expect(launch.name).toBe("miniflux");
         expect(Object.keys(launch.components)).toEqual(["default"]);
@@ -33,7 +43,7 @@ describe("dry-run against catalog", () => {
             },
         };
         const ports = await allocatePorts(launch.components, "miniflux");
-        const context = buildResolverContext(resourceMap, ports, {});
+        const context = buildResolverContext(resourceMap, ports, {}, {});
         const env = resolveComponentEnv(component, context, resourceMap);
         await resolveGenerators(component, env);
         // DATABASE_URL should be resolved from postgres $url
@@ -47,7 +57,7 @@ describe("dry-run against catalog", () => {
         expect(env.ADMIN_PASSWORD.length).toBeGreaterThan(10);
     });
     it("resolves langfuse Launchfile", async () => {
-        const yaml = await readFile(join(CATALOG_DIR, "langfuse/Launchfile"), "utf8");
+        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)) {
@@ -59,7 +69,7 @@ describe("dry-run against catalog", () => {
         }
     });
     it("resolves chatwoot multi-component Launchfile", async () => {
-        const yaml = await readFile(join(CATALOG_DIR, "chatwoot/Launchfile"), "utf8");
+        const yaml = await readFile(catalogPath("chatwoot"), "utf8");
         const launch = readLaunch(yaml);
         expect(launch.name).toBe("chatwoot");
         const componentNames = Object.keys(launch.components);
@@ -88,7 +98,7 @@ describe("dry-run against catalog", () => {
                 secrets[name] = `test-secret-${name}`;
             }
         }
-        const context = buildResolverContext(resourceMap, ports, secrets);
+        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);
@@ -100,11 +110,13 @@ describe("dry-run against catalog", () => {
     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 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 apps) {
+        for (const app of allApps) {
             try {
-                const yaml = await readFile(join(CATALOG_DIR, app, "Launchfile"), "utf8");
+                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 ?? [])]) {

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

@@ -1,7 +1,8 @@
 import { describe, it, expect } from "vitest";
-import { buildResolverContext, resolveComponentEnv, generateSecrets, } from "../env-writer.js";
+import { buildResolverContext, computeAppProperties, resolveComponentEnv, generateSecrets, } from "../env-writer.js";
+const NO_APP = {};
 describe("buildResolverContext", () => {
-    it("builds context from resources, ports, and secrets", () => {
+    it("builds context from resources, ports, secrets, and app properties", () => {
         const resources = {
             postgres: {
                 url: "postgresql://user:pass@localhost:5432/mydb",
@@ -14,7 +15,8 @@ describe("buildResolverContext", () => {
         };
         const ports = { backend: 3000, frontend: 3001 };
         const secrets = { "jwt-secret": "abc123" };
-        const ctx = buildResolverContext(resources, ports, secrets);
+        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",
@@ -22,6 +24,78 @@ describe("buildResolverContext", () => {
         });
         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", () => {
@@ -44,7 +118,7 @@ describe("resolveComponentEnv", () => {
                 port: 5432,
             },
         };
-        const context = buildResolverContext(resourceMap, {}, {});
+        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");
@@ -56,7 +130,7 @@ describe("resolveComponentEnv", () => {
                 LOG_LEVEL: { default: "info" },
             },
         };
-        const context = buildResolverContext({}, {}, {});
+        const context = buildResolverContext({}, {}, {}, NO_APP);
         const env = resolveComponentEnv(component, context, {});
         expect(env.PORT).toBe("8080");
         expect(env.LOG_LEVEL).toBe("info");
@@ -67,7 +141,7 @@ describe("resolveComponentEnv", () => {
                 BACKEND_URL: { default: "$components.backend.url" },
             },
         };
-        const context = buildResolverContext({}, { backend: 3000 }, {});
+        const context = buildResolverContext({}, { backend: 3000 }, {}, NO_APP);
         const env = resolveComponentEnv(component, context, {});
         expect(env.BACKEND_URL).toBe("http://localhost:3000");
     });
@@ -77,7 +151,7 @@ describe("resolveComponentEnv", () => {
                 SECRET_KEY: { default: "$secrets.my-key" },
             },
         };
-        const context = buildResolverContext({}, {}, { "my-key": "super-secret" });
+        const context = buildResolverContext({}, {}, { "my-key": "super-secret" }, NO_APP);
         const env = resolveComponentEnv(component, context, {});
         expect(env.SECRET_KEY).toBe("super-secret");
     });
@@ -100,7 +174,7 @@ describe("resolveComponentEnv", () => {
                 port: 5432,
             },
         };
-        const context = buildResolverContext(resourceMap, {}, {});
+        const context = buildResolverContext(resourceMap, {}, {}, NO_APP);
         const env = resolveComponentEnv(component, context, resourceMap);
         expect(env.DATABASE_URL).toBe("postgresql://real-url");
     });

package/dist/bootstrap.d.ts

@@ -0,0 +1,58 @@
+/**
+ * Bootstrap command execution for the macOS Dev provider.
+ *
+ * Implements the `commands.bootstrap` lifecycle stage introduced by D-34:
+ * user-invoked, runs after `start` against the running component, captures
+ * stdout via regex patterns, re-runnable, and reports failures rather than
+ * deploy-failing. Spec: /spec/SPEC.md § Bootstrap stage.
+ *
+ * The command is split into argv via whitespace and run through spawn()
+ * with shell:false to avoid shell-injection exposure. This means shell
+ * metacharacters (pipes, redirects, &&, quoted args with spaces) are not
+ * supported — apps that need shell features should wrap them in an
+ * image-level script and invoke that script.
+ */
+import { type CaptureEntry } from "@launchfile/sdk";
+/**
+ * Result of running one bootstrap command. Captures may be empty even on
+ * success (the command may not produce matching output), and may be
+ * partially populated even on failure (some patterns matched before
+ * the command errored out).
+ */
+export interface BootstrapResult {
+    component: string;
+    command: string;
+    ok: boolean;
+    exitCode: number;
+    captures: Record<string, string>;
+    /** Per-capture metadata (description, sensitive) for display. */
+    captureMeta: Record<string, CaptureEntry>;
+    stdout: string;
+    stderr: string;
+}
+/**
+ * Apply a set of capture patterns to a command's stdout. If a pattern has
+ * a capture group, the first group is used; otherwise the full match is
+ * used. Invalid regexes are skipped (schema validation catches them earlier).
+ *
+ * Exported for unit testing.
+ */
+export declare function extractCaptures(stdout: string, captures: Record<string, CaptureEntry>): Record<string, string>;
+/** Parse a simple duration string like "5m", "30s", "1h" into milliseconds. Exported for unit testing. */
+export declare function parseDuration(s: string): number;
+/**
+ * Public entry point for `launch bootstrap`. Loads the Launchfile, rebuilds
+ * the resolver context from persisted state (so $app.url resolves to the
+ * same value the running component sees), resolves $-expressions in each
+ * bootstrap command, runs them in declaration order, and returns structured
+ * results.
+ *
+ * Does not fail the process on command error — the caller (CLI) decides
+ * how to display failures. This matches the "reported, not deploy-failing"
+ * semantics in SPEC.md § Bootstrap stage.
+ */
+export declare function launchBootstrap(opts?: {
+    component?: string;
+    projectDir?: string;
+}): Promise<BootstrapResult[]>;
+//# sourceMappingURL=bootstrap.d.ts.map

package/dist/bootstrap.js

@@ -0,0 +1,221 @@
+/**
+ * Bootstrap command execution for the macOS Dev provider.
+ *
+ * Implements the `commands.bootstrap` lifecycle stage introduced by D-34:
+ * user-invoked, runs after `start` against the running component, captures
+ * stdout via regex patterns, re-runnable, and reports failures rather than
+ * deploy-failing. Spec: /spec/SPEC.md § Bootstrap stage.
+ *
+ * The command is split into argv via whitespace and run through spawn()
+ * with shell:false to avoid shell-injection exposure. This means shell
+ * metacharacters (pipes, redirects, &&, quoted args with spaces) are not
+ * supported — apps that need shell features should wrap them in an
+ * image-level script and invoke that script.
+ */
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { spawn } from "node:child_process";
+import { readLaunch, resolveExpression, } from "@launchfile/sdk";
+import { loadState } from "./state.js";
+import { buildResolverContext, computeAppProperties, resolveComponentEnv, resolveGenerators, } from "./env-writer.js";
+import { getProvisioner } from "./resources/index.js";
+/**
+ * Strip ANSI escape sequences from captured stdout before regex matching.
+ * CLI tools that detect a TTY will emit color codes that would otherwise
+ * break simple patterns like `https?://\S+`.
+ */
+function stripAnsi(s) {
+    // biome-ignore lint/suspicious/noControlCharactersInRegex: intentional ANSI match
+    return s.replace(/\x1b\[[0-9;]*[a-zA-Z]|\x1b\][^\x07]*\x07/g, "");
+}
+/**
+ * Apply a set of capture patterns to a command's stdout. If a pattern has
+ * a capture group, the first group is used; otherwise the full match is
+ * used. Invalid regexes are skipped (schema validation catches them earlier).
+ *
+ * Exported for unit testing.
+ */
+export function extractCaptures(stdout, captures) {
+    const result = {};
+    const clean = stripAnsi(stdout);
+    for (const [name, def] of Object.entries(captures)) {
+        try {
+            const match = clean.match(new RegExp(def.pattern));
+            if (match) {
+                result[name] = (match[1] ?? match[0] ?? "").trim();
+            }
+        }
+        catch {
+            // Invalid regex — skip. CaptureEntrySchema validation catches this.
+        }
+    }
+    return result;
+}
+/** Parse a simple duration string like "5m", "30s", "1h" into milliseconds. Exported for unit testing. */
+export function parseDuration(s) {
+    const match = /^(\d+)\s*(ms|s|m|h)$/.exec(s.trim());
+    if (!match)
+        return 120_000;
+    const n = Number.parseInt(match[1], 10);
+    switch (match[2]) {
+        case "ms": return n;
+        case "s": return n * 1000;
+        case "m": return n * 60 * 1000;
+        case "h": return n * 60 * 60 * 1000;
+        default: return 120_000;
+    }
+}
+/**
+ * Run one command using argv-split (no-shell) execution. Returns the
+ * structured result; does not throw on command failure.
+ */
+async function runOnce(command, opts) {
+    const parts = command.trim().split(/\s+/).filter(Boolean);
+    if (parts.length === 0) {
+        return { exitCode: 1, stdout: "", stderr: "empty command" };
+    }
+    const [file, ...args] = parts;
+    return new Promise((resolveP) => {
+        const child = spawn(file, args, {
+            cwd: opts.cwd,
+            env: { ...process.env, ...opts.env },
+            shell: false,
+            stdio: ["ignore", "pipe", "pipe"],
+        });
+        let stdout = "";
+        let stderr = "";
+        let settled = false;
+        const timer = setTimeout(() => {
+            if (!settled) {
+                settled = true;
+                child.kill("SIGTERM");
+                resolveP({
+                    exitCode: 124,
+                    stdout,
+                    stderr: stderr + `\n(killed after ${opts.timeoutMs}ms timeout)`,
+                });
+            }
+        }, opts.timeoutMs);
+        child.stdout?.on("data", (chunk) => {
+            stdout += String(chunk);
+        });
+        child.stderr?.on("data", (chunk) => {
+            stderr += String(chunk);
+        });
+        child.on("error", (err) => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                resolveP({ exitCode: 1, stdout, stderr: `${stderr}\n${err.message}` });
+            }
+        });
+        child.on("close", (code) => {
+            if (!settled) {
+                settled = true;
+                clearTimeout(timer);
+                resolveP({ exitCode: code ?? 1, stdout, stderr });
+            }
+        });
+    });
+}
+/**
+ * Public entry point for `launch bootstrap`. Loads the Launchfile, rebuilds
+ * the resolver context from persisted state (so $app.url resolves to the
+ * same value the running component sees), resolves $-expressions in each
+ * bootstrap command, runs them in declaration order, and returns structured
+ * results.
+ *
+ * Does not fail the process on command error — the caller (CLI) decides
+ * how to display failures. This matches the "reported, not deploy-failing"
+ * semantics in SPEC.md § Bootstrap stage.
+ */
+export async function launchBootstrap(opts = {}) {
+    const projectDir = opts.projectDir ?? process.cwd();
+    const launchfileContent = await readFile(join(projectDir, "Launchfile"), "utf8");
+    const launch = readLaunch(launchfileContent);
+    const state = await loadState(projectDir);
+    if (!state) {
+        throw new Error("No active launch state. Run `launch up` first.");
+    }
+    // Rebuild resource map from state so the resolver context has real
+    // values at invocation time (same pattern as launchEnv). This calls
+    // provisioner.provision() on already-provisioned resources to retrieve
+    // their current property values — relies on every provisioner being
+    // idempotent: re-running provision() must not corrupt state or
+    // re-create the resource. All current provisioners satisfy this; new
+    // provisioners must as well.
+    const resourceMap = {};
+    for (const [name, res] of Object.entries(state.resources)) {
+        const provisioner = getProvisioner(res.type);
+        if (provisioner) {
+            const result = await provisioner.provision({ type: res.type, name: res.name }, { appName: state.appName, projectDir }, res);
+            resourceMap[name] = result.properties;
+        }
+    }
+    const appProperties = computeAppProperties(launch, state.ports);
+    const context = buildResolverContext(resourceMap, state.ports, state.secrets, appProperties);
+    const results = [];
+    for (const [name, component] of Object.entries(launch.components)) {
+        if (opts.component && name !== opts.component)
+            continue;
+        const bootstrap = component.commands?.bootstrap;
+        if (!bootstrap)
+            continue;
+        // Resolve $-expressions in the command string (e.g. $app.url) at
+        // invocation time. Bootstrap runs after start, so the resolved URL
+        // already reflects the actual allocated port.
+        const resolvedCommand = resolveExpression(bootstrap.command, context);
+        // Resolve env vars so the subprocess gets the same environment as
+        // the running component.
+        const env = resolveComponentEnv(component, context, resourceMap);
+        await resolveGenerators(component, env);
+        const port = state.ports[name];
+        if (port && !env.PORT)
+            env.PORT = String(port);
+        console.log(`\n  \u2193 Bootstrap [${name}]`);
+        console.log(`    $ ${resolvedCommand}`);
+        const { exitCode, stdout, stderr } = await runOnce(resolvedCommand, {
+            cwd: projectDir,
+            env,
+            timeoutMs: bootstrap.timeout ? parseDuration(bootstrap.timeout) : 120_000,
+        });
+        const captures = bootstrap.capture
+            ? extractCaptures(stdout, bootstrap.capture)
+            : {};
+        const result = {
+            component: name,
+            command: resolvedCommand,
+            ok: exitCode === 0,
+            exitCode,
+            captures,
+            captureMeta: bootstrap.capture ?? {},
+            stdout,
+            stderr,
+        };
+        results.push(result);
+        // Print captures inline so the user sees them immediately.
+        if (Object.keys(captures).length > 0) {
+            console.log("\n  Captured:");
+            for (const [key, value] of Object.entries(captures)) {
+                const meta = bootstrap.capture?.[key];
+                const displayValue = meta?.sensitive ? "***" : value;
+                const desc = meta?.description ? ` — ${meta.description}` : "";
+                console.log(`    ${key}: ${displayValue}${desc}`);
+            }
+        }
+        if (exitCode !== 0) {
+            console.error(`  \u2717 Bootstrap [${name}] failed with exit code ${exitCode}`);
+            if (stderr)
+                console.error(stderr);
+        }
+        else {
+            console.log(`  \u2713 Bootstrap [${name}] complete`);
+        }
+    }
+    if (results.length === 0) {
+        const target = opts.component ? ` for component "${opts.component}"` : "";
+        console.log(`No bootstrap command declared${target}.`);
+    }
+    return results;
+}
+//# sourceMappingURL=bootstrap.js.map

package/dist/env-writer.d.ts

@@ -4,22 +4,25 @@
  * Connects provisioned resource properties to the SDK's expression resolver,
  * then writes the results to .env files.
  */
-import { type NormalizedComponent, type NormalizedLaunch, type Secret } from "@launchfile/sdk";
+import { type NormalizedComponent, type NormalizedLaunch, type ResolverContext, type Secret } from "@launchfile/sdk";
 import type { ResourceProperties } from "./resources/types.js";
+export type { ResolverContext };
 /**
- * Context for the SDK's resolveExpression().
- * Mirrors the interface from sdk/src/resolver.ts since it's not exported.
+ * Compute the $app.* property set for a Launchfile under the macos-dev
+ * provider. The app's "primary" port comes from the first component (in
+ * declaration order) that has at least one `exposed: true` provides entry.
+ * Apps with no exposed component get `port: 0` and `url: ""`.
+ *
+ * For multi-exposed-component apps that need a specific component's URL,
+ * use `$components.<name>.url` instead — `$app.*` always points at the
+ * first exposed component to give a single, predictable answer.
  */
-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>;
-}
+export declare function computeAppProperties(launch: NormalizedLaunch, componentPorts: Record<string, number>): Record<string, string | number>;
 /**
- * Build a ResolverContext from provisioned resources, component ports, and secrets.
+ * Build a ResolverContext from provisioned resources, component ports,
+ * secrets, and (D-33) the platform-injected app properties.
  */
-export declare function buildResolverContext(resourceMap: Record<string, ResourceProperties>, componentPorts: Record<string, number>, secrets: Record<string, string>): ResolverContext;
+export declare function buildResolverContext(resourceMap: Record<string, ResourceProperties>, componentPorts: Record<string, number>, secrets: Record<string, string>, app: Record<string, string | number>): ResolverContext;
 /**
  * Resolve all environment variables for a single component.
  */