@launchfile/macos-dev 0.1.4 → 0.3.0

package/dist/process-stopper.js

@@ -0,0 +1,165 @@
+/**
+ * Cross-session app-process termination for `launch down`.
+ *
+ * The foreground `launch up` session kills its children directly via the
+ * ProcessManager on Ctrl+C. But `launch down` may run from a *different* shell
+ * (or after the up-session has exited), so it has no live ChildProcess handles —
+ * only the pids recorded in `.launchfile/state.json`. This module signals those
+ * recorded process groups, with liveness + identity checks to avoid killing an
+ * unrelated process that happens to have inherited a recycled pid.
+ *
+ * ## pid-reuse identity guarantee (read this before trusting the kill)
+ *
+ * macOS recycles pids. A pid we recorded at `up` time may, by `down` time,
+ * belong to a completely unrelated process. Before sending any signal we:
+ *
+ *   1. **Liveness** — `process.kill(pid, 0)` throws ESRCH if no such process
+ *      exists. If it's dead, we skip (already stopped).
+ *   2. **Identity** — we compare the recorded spawn time against the live
+ *      process's actual start time via `ps -o lstart= -p <pid>`. If the live
+ *      process started meaningfully later than we recorded, the pid was
+ *      recycled and we REFUSE to signal it.
+ *
+ * This is a best-effort guarantee, not a cryptographic one. Its honest limits:
+ *   - `ps lstart` has ~1s resolution, so we allow a small tolerance window. A
+ *     recycled process that started within that window of the original spawn
+ *     could theoretically slip through — vanishingly unlikely in practice.
+ *   - If `ps` is unavailable/fails, we fall back to liveness-only and signal
+ *     conservatively ONLY the process group (never a bare pid), accepting the
+ *     small residual risk rather than orphaning the user's processes forever.
+ *   - We signal the process GROUP (negative pgid) to also reap children the app
+ *     spawned, matching the foreground SIGINT behavior. A recycled *group*
+ *     leader is the residual risk the start-time check exists to close.
+ */
+import { execFile } from "node:child_process";
+/**
+ * Identity tolerance: how much later than `startedAt` a live process may report
+ * having started before we treat it as a recycled pid. `ps lstart` rounds to
+ * whole seconds and there's scheduling slop between our `Date.now()` snapshot
+ * and the kernel's recorded start, so we allow a few seconds of forward drift.
+ */
+const START_TIME_TOLERANCE_MS = 3000;
+/** Default real implementation backed by `process.kill` and `ps`. */
+export const realSignalFns = {
+    kill: (pid, signal) => {
+        process.kill(pid, signal);
+    },
+    startTime: (pid) => queryStartTime(pid),
+};
+/**
+ * Query a process's start time via `ps -o lstart= -p <pid>` using array args
+ * (no shell, no interpolation). Returns epoch ms, or null on any failure.
+ */
+function queryStartTime(pid) {
+    return new Promise((resolve) => {
+        execFile("ps", ["-o", "lstart=", "-p", String(pid)], (error, stdout) => {
+            if (error) {
+                resolve(null);
+                return;
+            }
+            const text = stdout.trim();
+            if (!text) {
+                resolve(null);
+                return;
+            }
+            const parsed = Date.parse(text);
+            resolve(Number.isNaN(parsed) ? null : parsed);
+        });
+    });
+}
+/**
+ * Verify a recorded process is still the one we started.
+ *
+ * Returns:
+ *   - "alive-verified": process exists AND start time is consistent → safe to signal
+ *   - "alive-unverified": process exists but start time couldn't be read → signal group only, cautiously
+ *   - "dead": no such process (ESRCH) → already stopped, skip
+ *   - "mismatch": process exists but started too late → recycled pid, DO NOT signal
+ */
+export async function checkIdentity(rec, fns) {
+    // Liveness probe.
+    try {
+        fns.kill(rec.pid, 0);
+    }
+    catch (err) {
+        if (isErrno(err) && err.code === "ESRCH")
+            return "dead";
+        // EPERM means it exists but we can't signal it — treat as alive-unverified.
+        if (isErrno(err) && err.code === "EPERM")
+            return "alive-unverified";
+        return "dead";
+    }
+    const liveStart = await fns.startTime(rec.pid);
+    if (liveStart === null)
+        return "alive-unverified";
+    const recordedStart = Date.parse(rec.startedAt);
+    if (Number.isNaN(recordedStart))
+        return "alive-unverified";
+    // If the live process started meaningfully *after* we recorded the spawn,
+    // the original exited and the pid was recycled. Refuse to signal it.
+    if (liveStart > recordedStart + START_TIME_TOLERANCE_MS)
+        return "mismatch";
+    return "alive-verified";
+}
+/**
+ * Stop one recorded process: graceful SIGTERM to the group, then escalate to
+ * SIGKILL after `graceMs` if it's still alive. Always targets the process GROUP
+ * (negative pgid) so child processes the app spawned die too.
+ */
+export async function stopProcess(component, rec, fns, opts = {}) {
+    const graceMs = opts.graceMs ?? 5000;
+    const sleep = opts.sleep ?? ((ms) => new Promise((r) => setTimeout(r, ms)));
+    const identity = await checkIdentity(rec, fns);
+    if (identity === "dead")
+        return { component, result: "already-dead" };
+    if (identity === "mismatch")
+        return { component, result: "identity-mismatch" };
+    // Target the process group. pgid is the leader pid because we spawned detached.
+    const groupTarget = -rec.pgid;
+    try {
+        fns.kill(groupTarget, "SIGTERM");
+    }
+    catch (err) {
+        if (isErrno(err) && err.code === "ESRCH")
+            return { component, result: "already-dead" };
+        return { component, result: "error", error: errMessage(err) };
+    }
+    // Wait for graceful exit, then escalate if the leader is still alive.
+    await sleep(graceMs);
+    let stillAlive = true;
+    try {
+        fns.kill(rec.pid, 0);
+    }
+    catch {
+        stillAlive = false;
+    }
+    if (stillAlive) {
+        try {
+            fns.kill(groupTarget, "SIGKILL");
+        }
+        catch (err) {
+            if (!(isErrno(err) && err.code === "ESRCH")) {
+                return { component, result: "error", error: errMessage(err) };
+            }
+        }
+    }
+    return { component, result: "stopped" };
+}
+/**
+ * Stop every recorded process. Pure orchestration over `stopProcess`; returns
+ * one outcome per component so the caller can report and tests can assert.
+ */
+export async function stopRecordedProcesses(processes, fns = realSignalFns, opts = {}) {
+    const outcomes = [];
+    for (const [component, rec] of Object.entries(processes)) {
+        outcomes.push(await stopProcess(component, rec, fns, opts));
+    }
+    return outcomes;
+}
+function isErrno(err) {
+    return typeof err === "object" && err !== null && "code" in err;
+}
+function errMessage(err) {
+    return err instanceof Error ? err.message : String(err);
+}
+//# sourceMappingURL=process-stopper.js.map

package/dist/provider.d.ts

@@ -4,12 +4,30 @@
  * Reads a Launchfile, provisions resources, resolves env vars,
  * installs runtimes, and starts all components.
  */
+import { type NormalizedComponent } from "@launchfile/sdk";
+/**
+ * Source-mode run resolution (D-38, precedence `dev` > `image` > `start`).
+ * This provider runs apps from source. A component is source-runnable when it
+ * declares `dev`, or a `start` with no `image` — an `image` without a `dev`
+ * override stays artifact-mode, which this source-only provider can't launch.
+ */
+export declare function isSourceRunnable(component: NormalizedComponent): boolean;
+/** The command run from source, or undefined if the component resolves to its artifact. */
+export declare function sourceRunCommand(component: NormalizedComponent): string | undefined;
 export interface LaunchUpOpts {
     withOptional?: boolean;
     noBuild?: boolean;
     detach?: boolean;
     dryRun?: boolean;
     projectDir?: string;
+    /**
+     * Component selector (#77): if non-empty, these components plus their
+     * transitive downward `depends_on` closure are started (D-41), and the
+     * `requires` of every closure member are provisioned. The start-set is the
+     * SDK's `selectionClosure` — the same definition the Docker provider uses —
+     * so both yield the identical running topology (P-5). Empty = all components.
+     */
+    components?: string[];
 }
 export declare function launchUp(opts?: LaunchUpOpts): Promise<void>;
 export declare function launchDown(opts?: {

package/dist/provider.js

@@ -6,21 +6,39 @@
  */
 import { readFile } from "node:fs/promises";
 import { join } from "node:path";
-import { readLaunch } from "@launchfile/sdk";
+import { readLaunch, selectionClosure } from "@launchfile/sdk";
+/**
+ * Source-mode run resolution (D-38, precedence `dev` > `image` > `start`).
+ * This provider runs apps from source. A component is source-runnable when it
+ * declares `dev`, or a `start` with no `image` — an `image` without a `dev`
+ * override stays artifact-mode, which this source-only provider can't launch.
+ */
+export function isSourceRunnable(component) {
+    return Boolean(component.commands?.dev || (component.commands?.start && !component.image));
+}
+/** The command run from source, or undefined if the component resolves to its artifact. */
+export function sourceRunCommand(component) {
+    if (component.commands?.dev?.command)
+        return component.commands.dev.command;
+    if (component.image)
+        return undefined; // image, no `dev` override → artifact
+    return component.commands?.start?.command;
+}
 import { checkPrereqs } from "./prereqs.js";
 import { loadState, initState, saveState, ensureDirs } from "./state.js";
-import { buildResolverContext, resolveComponentEnv, generateSecrets, resolveGenerators, writeEnvFile, } from "./env-writer.js";
+import { buildResolverContext, computeAppProperties, resolveComponentEnv, generateSecrets, resolveGenerators, writeEnvFile, } from "./env-writer.js";
 import { getProvisioner } from "./resources/index.js";
 import { allocatePorts } from "./port-allocator.js";
 import { getRuntimeInstaller } from "./runtimes/index.js";
 import { detectPackageManager } from "./lockfile-detect.js";
-import { provisionStorage } from "./storage.js";
+import { provisionStorage, storagePaths } from "./storage.js";
 import { ProcessManager } from "./process-manager.js";
+import { stopRecordedProcesses } from "./process-stopper.js";
 import { shell } from "./shell.js";
+import { parseDuration } from "./bootstrap.js";
 export async function launchUp(opts = {}) {
     const projectDir = opts.projectDir ?? process.cwd();
     // 1. Check prerequisites
-    console.log("Checking prerequisites...");
     const prereqs = await checkPrereqs();
     if (!prereqs.ok) {
         console.error("Missing prerequisites:");
@@ -29,7 +47,6 @@ export async function launchUp(opts = {}) {
         process.exit(1);
     }
     // 2. Read and parse Launchfile
-    console.log("Reading Launchfile...");
     const launchfilePath = join(projectDir, "Launchfile");
     let launchfileContent;
     try {
@@ -40,9 +57,52 @@ export async function launchUp(opts = {}) {
         process.exit(1);
     }
     const launch = readLaunch(launchfileContent);
-    console.log(`  App: ${launch.name}`);
+    const allComponentNames = Object.keys(launch.components);
+    // Resolve component selector (#77) into its D-41 start-set: selected
+    // components + their transitive downward `depends_on` closure (and, by
+    // narrowing to that set, every closure member's `requires`). Narrowing
+    // launch.components here makes every downstream phase loop in launchUp honor
+    // the closure without per-loop edits — dropping it would hand back an app
+    // missing the very dependencies a selected component needs to start (D-16).
+    // down/status/env re-read the file, so they are unaffected.
+    const selection = selectionClosure(launch, opts.components ?? []);
+    if (selection.unknown.length > 0 || selection.resources.length > 0) {
+        console.error(`\nCannot select: ${[...selection.unknown, ...selection.resources].join(", ")}`);
+        for (const r of selection.resources) {
+            console.error(`  - "${r}" is a backing resource, not a component; select the component that requires it.`);
+        }
+        for (const u of selection.unknown) {
+            console.error(`  - "${u}" matches no component. Available: ${allComponentNames.join(", ")}`);
+        }
+        process.exit(1);
+    }
+    if (opts.components && opts.components.length > 0) {
+        const startSet = new Set(selection.start);
+        launch.components = Object.fromEntries(Object.entries(launch.components).filter(([n]) => startSet.has(n)));
+    }
     const componentNames = Object.keys(launch.components);
-    console.log(`  Components: ${componentNames.join(", ")}`);
+    // 2b. Source-mode guard (D-38) — fail fast before provisioning anything.
+    // Run precedence is `dev` > `image` > `start`: a component runs from source
+    // when it declares `dev`, or a `start` with no `image`. An `image` without a
+    // `dev` override stays artifact-mode — which this source-only provider can't
+    // launch. If nothing is source-runnable, the app belongs on `launchfile up`.
+    const sourceRunnable = Object.values(launch.components).filter(isSourceRunnable);
+    if (sourceRunnable.length === 0) {
+        const hasImage = Object.values(launch.components).some((c) => c.image);
+        console.error("Nothing to run from source: no component declares `dev` (or a `start` without an `image`).");
+        console.error(hasImage
+            ? "This app runs from an image — use `launchfile up` to launch the built artifact."
+            : "Add a `dev` (or `start`) command to run it from source.");
+        process.exit(1);
+    }
+    // Mixed app: warn about artifact components (image, no `dev` override) that
+    // this source-only provider can't launch — they need `launchfile up`.
+    for (const [name, c] of Object.entries(launch.components)) {
+        if (!isSourceRunnable(c) && c.image) {
+            console.warn(`  ! [${name}] has an image and no \`dev\` override — runs as an artifact, ` +
+                "skipped in source mode; use `launchfile up` to run it.");
+        }
+    }
     // 3. Load or init state
     let state = await loadState(projectDir);
     if (!state) {
@@ -51,10 +111,8 @@ export async function launchUp(opts = {}) {
     // 4. Ensure directories
     await ensureDirs(projectDir);
     // 5. Generate secrets
-    console.log("Generating secrets...");
     state.secrets = await generateSecrets(launch.secrets, state.secrets);
     // 6. Provision required resources
-    console.log("Provisioning resources...");
     const resourceMap = {};
     for (const [_compName, component] of Object.entries(launch.components)) {
         for (const req of component.requires ?? []) {
@@ -63,7 +121,7 @@ export async function launchUp(opts = {}) {
                 continue; // Already provisioned
             const provisioner = getProvisioner(req.type);
             if (!provisioner) {
-                console.warn(`  No provisioner for resource type: ${req.type} (skipping)`);
+                console.warn(`  ! No provisioner for resource type: ${req.type} (skipping)`);
                 continue;
             }
             if (opts.dryRun) {
@@ -71,11 +129,12 @@ export async function launchUp(opts = {}) {
                 resourceMap[resourceName] = { url: "", host: "localhost", port: 0 }; // placeholder for dedup
                 continue;
             }
-            console.log(`  Provisioning ${req.type} (${resourceName})...`);
+            process.stdout.write(`  \u2193 Provisioning ${req.type}...`);
             const existing = state.resources[resourceName];
             const result = await provisioner.provision(req, { appName: launch.name, projectDir }, existing);
             resourceMap[resourceName] = result.properties;
             state.resources[resourceName] = result.state;
+            console.log(" done");
         }
         // Optional supports resources
         if (opts.withOptional) {
@@ -84,45 +143,44 @@ export async function launchUp(opts = {}) {
                 if (resourceMap[resourceName])
                     continue;
                 const provisioner = getProvisioner(sup.type);
-                if (!provisioner) {
-                    console.log(`  Optional resource ${sup.type} not supported (skipping)`);
+                if (!provisioner)
                     continue;
-                }
                 if (opts.dryRun) {
                     console.log(`  [dry-run] Would provision optional ${sup.type} as "${resourceName}"`);
                     resourceMap[resourceName] = { url: "", host: "localhost", port: 0 };
                     continue;
                 }
                 try {
-                    console.log(`  Provisioning optional ${sup.type} (${resourceName})...`);
+                    process.stdout.write(`  \u2193 Provisioning ${sup.type} (optional)...`);
                     const existing = state.resources[resourceName];
                     const result = await provisioner.provision(sup, { appName: launch.name, projectDir }, existing);
                     resourceMap[resourceName] = result.properties;
                     state.resources[resourceName] = result.state;
+                    console.log(" done");
                 }
-                catch (err) {
-                    console.log(`  Optional resource ${sup.type} failed to provision (skipping): ${err}`);
+                catch {
+                    console.log(" skipped");
                 }
             }
         }
     }
     // 7. Allocate ports
-    console.log("Allocating ports...");
     const componentPorts = await allocatePorts(launch.components, launch.name, state.ports);
     state.ports = componentPorts;
-    // 8. Build resolver context
-    const context = buildResolverContext(resourceMap, componentPorts, state.secrets);
+    // 8. Build resolver context (including $app.* properties from D-33)
+    const appProperties = computeAppProperties(launch, componentPorts);
+    const context = buildResolverContext(resourceMap, componentPorts, state.secrets, appProperties);
     // 9. Install runtimes
     for (const [name, component] of Object.entries(launch.components)) {
         if (!component.runtime) {
             if (!component.image) {
-                console.warn(`  [${name}] No runtime declared — cannot run natively`);
+                console.warn(`  ! [${name}] No runtime declared — cannot run natively`);
             }
             continue;
         }
         const installer = getRuntimeInstaller(component.runtime);
         if (!installer) {
-            console.warn(`  [${name}] No installer for runtime: ${component.runtime}`);
+            console.warn(`  ! [${name}] No installer for runtime: ${component.runtime}`);
             continue;
         }
         if (opts.dryRun) {
@@ -131,28 +189,31 @@ export async function launchUp(opts = {}) {
         }
         const version = await installer.detectVersion(projectDir);
         if (version) {
-            console.log(`  [${name}] Runtime ${component.runtime} ${version}`);
+            console.log(`  \u2193 Installing ${component.runtime} ${version}... done`);
             await installer.install(version);
         }
         else {
-            console.log(`  [${name}] Runtime ${component.runtime} (using system default)`);
+            console.log(`  \u2193 Using system ${component.runtime}`);
         }
     }
     // 10. Detect package manager
     const pm = await detectPackageManager(projectDir);
-    if (pm) {
-        console.log(`  Package manager: ${pm.name} (${pm.lockfile})`);
-    }
-    // 11. Create storage directories
+    // 11. Create storage directories, capturing each volume's resolved local path
+    // so it can be injected as $storage.<name>.path (D-39). Scoped per component.
+    const componentStorage = {};
     for (const [name, component] of Object.entries(launch.components)) {
-        await provisionStorage(component.storage, name, projectDir);
+        const volumeMap = await provisionStorage(component.storage, name, projectDir);
+        const storageCtx = {};
+        for (const [volName, localPath] of Object.entries(volumeMap)) {
+            storageCtx[volName] = { path: localPath };
+        }
+        componentStorage[name] = storageCtx;
     }
     // 12. Resolve env vars and write .env files
-    console.log("Resolving environment variables...");
     const allEnvs = {};
     const isSingleComponent = componentNames.length === 1 && componentNames[0] === "default";
     for (const [name, component] of Object.entries(launch.components)) {
-        const env = resolveComponentEnv(component, context, resourceMap);
+        const env = resolveComponentEnv(component, context, resourceMap, componentStorage[name]);
         await resolveGenerators(component, env);
         const port = componentPorts[name];
         if (port && !env.PORT) {
@@ -165,13 +226,13 @@ export async function launchUp(opts = {}) {
         }
         if (isSingleComponent) {
             await writeEnvFile(join(projectDir, ".env.local"), env);
-            console.log(`  Wrote .env.local (${Object.keys(env).length} vars)`);
+            console.log(`  \u2193 Wiring environment variables... done (${Object.keys(env).length} vars)`);
         }
         else {
             const { mkdir } = await import("node:fs/promises");
             await mkdir(join(projectDir, ".launchfile", "env"), { recursive: true });
             await writeEnvFile(join(projectDir, ".launchfile", "env", `${name}.env`), env);
-            console.log(`  Wrote .launchfile/env/${name}.env (${Object.keys(env).length} vars)`);
+            console.log(`  \u2193 Wiring ${name} environment... done (${Object.keys(env).length} vars)`);
         }
     }
     // 13. Save state before build (in case build fails, we still have resource state)
@@ -181,80 +242,84 @@ export async function launchUp(opts = {}) {
         printSummary(launch, componentPorts, resourceMap);
         return;
     }
-    // 14. Run build commands
+    // 14. Run source-mode prepare \u2014 `install ?? build` (D-38), on demand
     if (!opts.noBuild) {
         for (const [name, component] of Object.entries(launch.components)) {
-            const buildCmd = component.commands?.build?.command;
-            const cmd = buildCmd ?? pm?.installCommand;
+            const prepare = component.commands?.install ?? component.commands?.build;
+            const cmd = prepare?.command ?? pm?.installCommand;
             if (cmd) {
-                console.log(`\n  [${name}] Building: ${cmd}`);
+                console.log(`  \u2193 Preparing${componentNames.length > 1 ? ` [${name}]` : ""}...`);
                 await shell(cmd, {
-                    cwd: projectDir,
+                    cwd: join(projectDir, component.source ?? component.build?.context ?? "."),
                     env: allEnvs[name],
+                    // Installs/compiles routinely exceed the 2-minute shell default;
+                    // honor a declared timeout, else allow 10 minutes.
+                    timeout: prepare?.timeout ? parseDuration(prepare.timeout) : 600_000,
                 });
             }
         }
     }
-    // 15. Run release commands (migrations)
+    // 15. Run release commands (migrations) \u2014 mode-invariant (D-38)
     for (const [name, component] of Object.entries(launch.components)) {
-        const releaseCmd = component.commands?.release?.command;
-        if (releaseCmd) {
-            console.log(`\n  [${name}] Release: ${releaseCmd}`);
-            await shell(releaseCmd, {
-                cwd: projectDir,
+        const release = component.commands?.release;
+        if (release?.command) {
+            console.log(`  \u2193 Running release${componentNames.length > 1 ? ` [${name}]` : ""}...`);
+            await shell(release.command, {
+                cwd: join(projectDir, component.source ?? component.build?.context ?? "."),
                 env: allEnvs[name],
+                timeout: release.timeout ? parseDuration(release.timeout) : undefined,
             });
         }
     }
-    // 16. Start all components
-    console.log("\nStarting components...");
+    // 16. Run components from source \u2014 `dev` over `start` (D-38; this provider ignores `image`)
+    process.stdout.write(`  \u2193 Starting services...`);
     const pm2 = new ProcessManager(projectDir);
     for (const [name, component] of Object.entries(launch.components)) {
-        const startCmd = component.commands?.start?.command;
-        if (!startCmd) {
-            console.warn(`  [${name}] No start command — skipping`);
+        // Resolve the source-mode run command (D-38 precedence `dev` > `image` >
+        // `start`). Artifact components (image, no `dev` override) resolve to
+        // undefined — they were warned by the guard; skip them.
+        const startCmd = sourceRunCommand(component);
+        if (!startCmd)
             continue;
-        }
         pm2.register(name, {
             command: startCmd,
             env: { ...process.env, ...allEnvs[name] },
-            cwd: projectDir,
+            cwd: join(projectDir, component.source ?? component.build?.context ?? "."),
             dependsOn: component.depends_on,
             health: component.health,
             port: componentPorts[name],
         });
     }
     // Handle Ctrl+C gracefully
+    const finalState = state;
     process.on("SIGINT", async () => {
         console.log("\n\nShutting down...");
         await pm2.stopAll();
-        await saveState(projectDir, state);
+        // Processes are now dead; clear the recorded pids so a later `launch down`
+        // doesn't try to signal stale (and possibly recycled) pids.
+        finalState.processes = {};
+        await saveState(projectDir, finalState);
         process.exit(0);
     });
     await pm2.startAll();
+    console.log("");
+    console.log(`  \u2713 All components started`);
+    // Record spawned pids so `launch down` can stop them from another shell or
+    // after this foreground session ends (closes #49). Backward compatible: the
+    // field is optional and absent in pre-existing state files.
+    state.processes = pm2.getRecordedProcesses();
     // 17. Print summary
     printSummary(launch, componentPorts, resourceMap);
-    // Save final state
+    // Save final state (now including recorded pids)
     await saveState(projectDir, state);
 }
-function printSummary(launch, ports, resources) {
-    console.log("\n" + "=".repeat(60));
-    console.log(`  ${launch.name} is running`);
-    console.log("=".repeat(60));
+function printSummary(launch, ports, _resources) {
+    console.log("");
     for (const [name, port] of Object.entries(ports)) {
-        const component = launch.components[name];
-        const exposed = component?.provides?.some((p) => p.exposed);
-        const label = exposed ? "(public)" : "(internal)";
-        console.log(`  ${name}: http://localhost:${port} ${label}`);
-    }
-    if (Object.keys(resources).length > 0) {
-        console.log("\n  Resources:");
-        for (const [name, props] of Object.entries(resources)) {
-            console.log(`    ${name}: ${props.url}`);
-        }
+        const label = name === "default" ? launch.name : name;
+        console.log(`  ${label} is running at http://localhost:${port}`);
     }
     console.log("\n  Press Ctrl+C to stop all processes.");
-    console.log("=".repeat(60));
 }
 export async function launchDown(opts = {}) {
     const projectDir = opts.projectDir ?? process.cwd();
@@ -263,6 +328,35 @@ export async function launchDown(opts = {}) {
         console.log("No active launch state found.");
         return;
     }
+    // Stop recorded app processes (closes #49). Backward compatible: state files
+    // written before pid persistence simply have no `processes`, so we skip this
+    // and behave exactly as before (resources-only down).
+    const recorded = state.processes ?? {};
+    if (Object.keys(recorded).length > 0) {
+        console.log("Stopping app processes...");
+        const outcomes = await stopRecordedProcesses(recorded);
+        for (const o of outcomes) {
+            switch (o.result) {
+                case "stopped":
+                    console.log(`  Stopped ${o.component}`);
+                    break;
+                case "already-dead":
+                    console.log(`  ${o.component} was not running`);
+                    break;
+                case "identity-mismatch":
+                    console.log(`  Skipped ${o.component} (pid recycled — left untouched)`);
+                    break;
+                case "error":
+                    console.log(`  Failed to stop ${o.component}: ${o.error}`);
+                    break;
+            }
+        }
+        // Clear recorded pids now that we've handled them.
+        state.processes = {};
+        if (!opts.destroy) {
+            await saveState(projectDir, state);
+        }
+    }
     if (opts.destroy) {
         console.log("Destroying resources...");
         for (const [name, resourceState] of Object.entries(state.resources)) {
@@ -281,6 +375,11 @@ export async function launchDown(opts = {}) {
         console.log("Stopped. Resources are still running (use --destroy to remove them).");
     }
 }
+// --detach is intentionally left as a follow-up: persisting pids (this PR) is
+// the prerequisite for it. With pids now recorded and a working cross-session
+// `down`, detach becomes "spawn detached + unref + don't install the SIGINT
+// foreground loop, then return" — a self-contained change best done separately
+// so the kill-path fix lands reviewable on its own.
 export async function launchStatus(opts = {}) {
     const projectDir = opts.projectDir ?? process.cwd();
     const state = await loadState(projectDir);
@@ -324,11 +423,18 @@ export async function launchEnv(opts = {}) {
             resourceMap[name] = result.properties;
         }
     }
-    const context = buildResolverContext(resourceMap, state.ports, state.secrets);
+    const appProperties = computeAppProperties(launch, state.ports);
+    const context = buildResolverContext(resourceMap, state.ports, state.secrets, appProperties);
     for (const [name, component] of Object.entries(launch.components)) {
         if (opts.component && name !== opts.component)
             continue;
-        const env = resolveComponentEnv(component, context, resourceMap);
+        // Resolved storage paths (D-39) — computed, not provisioned (no mkdir):
+        // `launchfile env` only prints, and the dirs already exist from `up`.
+        const storageCtx = {};
+        for (const [volName, localPath] of Object.entries(storagePaths(component.storage, name, projectDir))) {
+            storageCtx[volName] = { path: localPath };
+        }
+        const env = resolveComponentEnv(component, context, resourceMap, storageCtx);
         await resolveGenerators(component, env);
         const port = state.ports[name];
         if (port && !env.PORT)

package/dist/shell.js

@@ -19,7 +19,7 @@ export async function shell(command, opts = {}) {
     return new Promise((resolve, reject) => {
         cpExec(command, execOpts, (error, stdout, stderr) => {
             const result = {
-                exitCode: error?.code ?? (typeof error?.code === "number" ? error.code : 0),
+                exitCode: typeof error?.code === "number" ? error.code : 0,
                 stdout: typeof stdout === "string" ? stdout : "",
                 stderr: typeof stderr === "string" ? stderr : "",
             };