@launchfile/macos-dev 0.11.0 → 0.13.0

package/dist/https-origin.js

@@ -10,7 +10,8 @@
  * D-56 rule 3 stands — the provider does not verify the origin exists or is
  * ready.
  */
-import { suppliedAppAddress, } from "@launchfile/sdk";
+import { suppliedAppAddress, UNPUBLISHED_APP_ENDPOINT, useKeys, } from "@launchfile/sdk";
+import { uncoveredUses, withCoveredUses } from "./resources/index.js";
 /** The backing-service type that declares the app's public HTTPS origin (D-60). */
 export const HTTPS_ORIGIN = "https-origin";
 /**
@@ -22,6 +23,14 @@ export const HTTPS_ORIGIN = "https-origin";
 export function httpsOriginSatisfied(appUrl) {
     return appUrl !== undefined && suppliedAppAddress(appUrl).scheme === "https";
 }
+/**
+ * The uses an `https-origin` entry declares that this provider cannot cover,
+ * spelled as the file spells them. Asked of the use registry, never assumed:
+ * a use registered for the type later is covered with no change here.
+ */
+export function uncoveredOriginUses(entry) {
+    return entry.uses ? uncoveredUses(entry.type, useKeys(entry.uses)) : [];
+}
 /**
  * Why one `https-origin` entry is not satisfied, for a refusal or a degraded
  * note — the same two reasons `@launchfile/docker` gives, so one Launchfile
@@ -34,21 +43,38 @@ export function httpsOriginShortfall(entry, appUrl) {
         : `${label}: the supplied publication URL's scheme is "${suppliedAppAddress(appUrl).scheme}", not https`;
 }
 /**
- * The component an `https-origin` entry sits on, when the file declares one
+ * The `$app.*` address of a primary whose component is refused (D-72):
+ * every field `""` — the answer D-63 rule 4 gives an endpoint the provider
+ * publishes no address for — with `tls` reading `false`, as D-63 rule 3 has
+ * a listener with no origin read it, so a literal on/off flag
+ * (`USE_SSL: $app.tls`) still receives a boolean. The same object
+ * `@launchfile/docker` resolves (P-5).
+ */
+export const REFUSED_PRIMARY_ADDRESS = Object.freeze({ ...UNPUBLISHED_APP_ENDPOINT, tls: "false" });
+/**
+ * The primary an `https-origin` entry declares, when the file declares one
  * (D-60 rule 3), else `undefined`. **Declaration** fixes the primary, not
  * fulfillment: a `supports:` entry this provider leaves unsatisfied still
- * names it, so `$app.*` does not change value with the provider's capability.
- * The SDK caps the app at one such entry and requires it to sit on the
- * component that owns the named endpoint, so the first match is the only one.
+ * names it, and so does a `requires:` entry whose component this provider
+ * refuses — `refused` says which, and `computeAppProperties` then resolves
+ * the empty address rather than a surviving sibling's (D-72). Either way
+ * `$app.*` does not move with the provider's capability. The SDK caps the app
+ * at one such entry and requires it to sit on the component that owns the
+ * named endpoint, so the first match is the only one.
+ *
+ * `up` reads this before its refusals remove anything from
+ * `launch.components`; `env` and `bootstrap` read the file whole. `appUrl` is
+ * the effective publication context — supplied or recorded — normalized.
  */
-export function declaredPrimaryComponent(launch) {
+export function declaredPrimary(launch, appUrl) {
     for (const [name, component] of Object.entries(launch.components)) {
-        for (const entry of [
-            ...(component.requires ?? []),
-            ...(component.supports ?? []),
-        ]) {
+        for (const entry of component.requires ?? []) {
             if (entry.type === HTTPS_ORIGIN && entry.endpoint !== undefined)
-                return name;
+                return { component: name, refused: !httpsOriginSatisfied(appUrl) };
+        }
+        for (const entry of component.supports ?? []) {
+            if (entry.type === HTTPS_ORIGIN && entry.endpoint !== undefined)
+                return { component: name, refused: false };
         }
     }
     return undefined;
@@ -56,10 +82,13 @@ export function declaredPrimaryComponent(launch) {
 /**
  * Register every satisfied `https-origin` entry as a resource so its `set_env`
  * resolves. One registered property, `url` (D-60 rule 4), holding the same
- * string as `$app.url`. Mutates `resourceMap`; a no-op when the recorded
- * publication URL does not satisfy the type, so an unsatisfied entry's
- * `set_env` stays absent (never `""`) exactly as for any other resource this
- * provider did not provision.
+ * string as `$app.url`, plus the properties of each declared use. Mutates
+ * `resourceMap`; a no-op when the recorded publication URL does not satisfy
+ * the type, so an unsatisfied entry's `set_env` stays absent (never `""`)
+ * exactly as for any other resource this provider did not provision. An entry
+ * declaring a use this provider cannot cover is unsatisfied the same way
+ * (D-65): a `supports:` entry runs degraded, and a `requires:` one refused its
+ * component before launch.
  */
 export function wireHttpsOrigins(launch, resourceMap, appUrl) {
     if (appUrl === undefined)
@@ -74,7 +103,9 @@ export function wireHttpsOrigins(launch, resourceMap, appUrl) {
         ]) {
             if (entry.type !== HTTPS_ORIGIN)
                 continue;
-            resourceMap[entry.name ?? entry.type] = { url };
+            if (uncoveredOriginUses(entry).length > 0)
+                continue;
+            resourceMap[entry.name ?? entry.type] = withCoveredUses(entry.type, entry.uses ? useKeys(entry.uses) : undefined, { url }, {});
         }
     }
 }

package/dist/lockfile-detect.d.ts

@@ -6,6 +6,14 @@ export interface PackageManager {
     installCommand: string;
     lockfile: string;
 }
+/**
+ * Every lockfile name this provider knows, deduplicated. Dependency-change
+ * detection (D-38 on-demand prepare) reads them all rather than only the one
+ * `detectPackageManager` selects: a polyglot component can carry more than one,
+ * and priority order decides which install command to run, not which files
+ * count as dependency inputs.
+ */
+export declare function lockfileNames(): string[];
 /**
  * Detect the package manager from lockfile presence in a directory.
  * Returns the first match in priority order, or null.

package/dist/lockfile-detect.js

@@ -16,6 +16,16 @@ const LOCKFILE_ORDER = [
     { name: "poetry", installCommand: "poetry install", lockfile: "poetry.lock" },
     { name: "uv", installCommand: "uv sync", lockfile: "uv.lock" },
 ];
+/**
+ * Every lockfile name this provider knows, deduplicated. Dependency-change
+ * detection (D-38 on-demand prepare) reads them all rather than only the one
+ * `detectPackageManager` selects: a polyglot component can carry more than one,
+ * and priority order decides which install command to run, not which files
+ * count as dependency inputs.
+ */
+export function lockfileNames() {
+    return [...new Set(LOCKFILE_ORDER.map((pm) => pm.lockfile))];
+}
 async function fileExists(path) {
     try {
         await access(path);

package/dist/prepare-fingerprint.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Dependency fingerprinting for the source-mode `prepare` slot (D-38).
+ *
+ * D-38 requires prepare (`install ?? build`) to run "on demand (first launch or
+ * a detected dependency change), never on every `dev`". The detection is a
+ * fingerprint of the prepare inputs: the command string plus the contents of
+ * every dependency manifest and lockfile in the directory the command runs in.
+ * A run records its fingerprint in state; a later `up` that computes the same
+ * fingerprint has nothing to install.
+ *
+ * Scope: files in the prepare working directory only. Dependency files nested
+ * deeper (a monorepo's per-workspace manifests) do not move the fingerprint, so
+ * editing one alone does not trigger a reinstall.
+ */
+/**
+ * Fingerprint the inputs of one component's prepare run.
+ *
+ * The command string is part of the digest, so editing `install:`/`build:` in
+ * the Launchfile re-runs prepare even when no dependency file moved. A missing
+ * file contributes nothing to the digest, so creating or deleting one changes it.
+ */
+export declare function prepareFingerprint(dir: string, command: string): Promise<string>;
+//# sourceMappingURL=prepare-fingerprint.d.ts.map

package/dist/prepare-fingerprint.js

@@ -0,0 +1,63 @@
+/**
+ * Dependency fingerprinting for the source-mode `prepare` slot (D-38).
+ *
+ * D-38 requires prepare (`install ?? build`) to run "on demand (first launch or
+ * a detected dependency change), never on every `dev`". The detection is a
+ * fingerprint of the prepare inputs: the command string plus the contents of
+ * every dependency manifest and lockfile in the directory the command runs in.
+ * A run records its fingerprint in state; a later `up` that computes the same
+ * fingerprint has nothing to install.
+ *
+ * Scope: files in the prepare working directory only. Dependency files nested
+ * deeper (a monorepo's per-workspace manifests) do not move the fingerprint, so
+ * editing one alone does not trigger a reinstall.
+ */
+import { createHash } from "node:crypto";
+import { readFile } from "node:fs/promises";
+import { join } from "node:path";
+import { lockfileNames } from "./lockfile-detect.js";
+/**
+ * Dependency manifests — the hand-edited half of the pair. They are read
+ * alongside lockfiles so a project that commits no lockfile still gets change
+ * detection, and so an edited manifest counts as a change before the install
+ * that would regenerate the lockfile has run.
+ */
+const MANIFEST_FILES = [
+    "package.json",
+    "Gemfile",
+    "go.mod",
+    "Cargo.toml",
+    "pyproject.toml",
+    "Pipfile",
+    "setup.py",
+    "composer.json",
+];
+/** Every file whose content is a prepare input, deduplicated and ordered. */
+function dependencyFiles() {
+    return [...new Set([...lockfileNames(), ...MANIFEST_FILES])].sort();
+}
+/**
+ * Fingerprint the inputs of one component's prepare run.
+ *
+ * The command string is part of the digest, so editing `install:`/`build:` in
+ * the Launchfile re-runs prepare even when no dependency file moved. A missing
+ * file contributes nothing to the digest, so creating or deleting one changes it.
+ */
+export async function prepareFingerprint(dir, command) {
+    const hash = createHash("sha256");
+    hash.update(`command ${command} `);
+    for (const name of dependencyFiles()) {
+        let content;
+        try {
+            content = await readFile(join(dir, name));
+        }
+        catch {
+            continue;
+        }
+        hash.update(`file ${name} `);
+        hash.update(createHash("sha256").update(content).digest("hex"));
+        hash.update(" ");
+    }
+    return hash.digest("hex").slice(0, 16);
+}
+//# sourceMappingURL=prepare-fingerprint.js.map

package/dist/process-manager.d.ts

@@ -5,6 +5,34 @@
  * health check waits, and graceful shutdown.
  */
 import type { NormalizedHealth, NormalizedDependsOnEntry } from "@launchfile/sdk";
+/**
+ * How long a component gets to report healthy before `up` fails. A
+ * provider-side budget: SPEC.md § Failure semantics binds the disposition of
+ * the failure, not the number of seconds (P-11). Documented in CLAUDE.md as
+ * PROVIDERS.md §10 rule 10 requires.
+ */
+export declare const HEALTH_TIMEOUT_MS = 60000;
+/**
+ * A component's declared `health:` never passed, or could not be checked at all.
+ * The invocation fails (SPEC.md § Failure semantics); `launchUp` tags it with
+ * the `health` phase so the CLI records the deployment the processes belong to.
+ */
+export declare class HealthGateError extends Error {
+    constructor(message: string);
+}
+/** One component the health gate gave up on: the probe asked and the window it got. */
+export interface StuckComponent {
+    name: string;
+    check: string;
+    budgetMs: number;
+}
+/**
+ * What a health-gate failure says. Every stuck component is named with the
+ * probe that was asked of it and the budget it actually got — budgets differ
+ * per component once a file declares `retries` — so "did not become healthy"
+ * is actionable.
+ */
+export declare function healthFailureMessage(stuck: ReadonlyArray<StuckComponent>): string;
 /** A spawned component process recorded for cross-session shutdown. */
 export interface RecordedProcessInfo {
     pid: number;
@@ -15,7 +43,10 @@ export interface RecordedProcessInfo {
 export declare class ProcessManager {
     private processes;
     private logDir;
-    constructor(projectDir: string);
+    private healthTimeoutMs;
+    constructor(projectDir: string, opts?: {
+        healthTimeoutMs?: number;
+    });
     register(name: string, config: {
         command: string;
         env: Record<string, string>;
@@ -25,9 +56,26 @@ export declare class ProcessManager {
         port?: number;
     }): void;
     /**
-     * Start all registered processes respecting dependency order.
+     * Start all registered processes respecting dependency order, then verify
+     * every component that declares `health:` actually became healthy.
+     *
+     * SPEC.md § Failure semantics: a component that never becomes healthy
+     * FAILS THE INVOCATION. The rejection names each stuck component and the
+     * probe it was asked. Processes that did start are left running and stay
+     * registered, so the caller can record their pids for `status`/`logs`/`down`.
      */
     startAll(): Promise<void>;
+    /** The failure-message entry for a component whose check never passed. */
+    private stuck;
+    /** Report a health-gate failure on stderr and build the error `up` rejects with. */
+    private healthFailure;
+    /**
+     * Poll one component's declared check until it passes or the budget runs
+     * out. Throws when the check cannot run at all: a `path` check with no
+     * allocated port has nothing to poll, and treating that as healthy would be
+     * a silent pass of a check the file declared.
+     */
+    private pollHealthy;
     private startOne;
     /**
      * Graceful shutdown in reverse dependency order.

package/dist/process-manager.js

@@ -5,10 +5,38 @@
  * health check waits, and graceful shutdown.
  */
 import { spawn } from "node:child_process";
-import { createWriteStream, mkdirSync } from "node:fs";
+import { closeSync, fchmodSync, mkdirSync, openSync, readSync, statSync } from "node:fs";
 import { join } from "node:path";
-import { waitForHealthy } from "./health.js";
+import { describeHealthCheck, healthBudgetMs, healthCheckNeedsPort, waitForHealthy } from "./health.js";
 import { redactSecrets } from "./redact.js";
+/**
+ * How long a component gets to report healthy before `up` fails. A
+ * provider-side budget: SPEC.md § Failure semantics binds the disposition of
+ * the failure, not the number of seconds (P-11). Documented in CLAUDE.md as
+ * PROVIDERS.md §10 rule 10 requires.
+ */
+export const HEALTH_TIMEOUT_MS = 60_000;
+/**
+ * A component's declared `health:` never passed, or could not be checked at all.
+ * The invocation fails (SPEC.md § Failure semantics); `launchUp` tags it with
+ * the `health` phase so the CLI records the deployment the processes belong to.
+ */
+export class HealthGateError extends Error {
+    constructor(message) {
+        super(message);
+        this.name = "HealthGateError";
+    }
+}
+/**
+ * What a health-gate failure says. Every stuck component is named with the
+ * probe that was asked of it and the budget it actually got — budgets differ
+ * per component once a file declares `retries` — so "did not become healthy"
+ * is actionable.
+ */
+export function healthFailureMessage(stuck) {
+    const named = stuck.map((s) => `${s.name} (${s.check}) within ${s.budgetMs / 1000}s`).join(", ");
+    return `component(s) did not become healthy: ${named}`;
+}
 // ANSI colors for log prefixing
 const COLORS = [
     "\x1b[36m", // cyan
@@ -41,11 +69,76 @@ function killGroupOrSelf(proc, pid, signal) {
         // Already exited.
     }
 }
+const TAIL_INTERVAL_MS = 200;
+/**
+ * Prints a component's log file as it grows. The component writes the file
+ * itself; this only reads what it appends, so the console view holds nothing
+ * the writer depends on. Polled, from the size the file had at `start`.
+ */
+class LogTail {
+    path;
+    onLine;
+    offset = 0;
+    partial = "";
+    timer;
+    constructor(path, onLine) {
+        this.path = path;
+        this.onLine = onLine;
+    }
+    start() {
+        this.offset = this.size();
+        this.timer = setInterval(() => this.drain(), TAIL_INTERVAL_MS);
+        // The child handle keeps the session alive; the tail never should.
+        this.timer.unref();
+    }
+    /** Print the rest of the file and stop polling. */
+    stop() {
+        if (this.timer)
+            clearInterval(this.timer);
+        this.timer = undefined;
+        this.drain();
+        if (this.partial) {
+            this.onLine(this.partial);
+            this.partial = "";
+        }
+    }
+    size() {
+        try {
+            return statSync(this.path).size;
+        }
+        catch {
+            return 0;
+        }
+    }
+    drain() {
+        const size = this.size();
+        if (size <= this.offset)
+            return;
+        const buf = Buffer.alloc(size - this.offset);
+        const fd = openSync(this.path, "r");
+        try {
+            const read = readSync(fd, buf, 0, buf.length, this.offset);
+            this.offset += read;
+            this.partial += buf.subarray(0, read).toString();
+        }
+        finally {
+            closeSync(fd);
+        }
+        const lines = this.partial.split("\n");
+        this.partial = lines.pop() ?? "";
+        for (const line of lines) {
+            if (line)
+                this.onLine(line);
+        }
+    }
+}
 export class ProcessManager {
     processes = new Map();
     logDir;
-    constructor(projectDir) {
+    healthTimeoutMs;
+    constructor(projectDir, opts = {}) {
         this.logDir = join(projectDir, ".launchfile", "logs");
+        this.healthTimeoutMs = opts.healthTimeoutMs ?? HEALTH_TIMEOUT_MS;
         // Security: restrict permissions — logs may contain sensitive output
         mkdirSync(this.logDir, { recursive: true, mode: 0o700 });
     }
@@ -62,7 +155,13 @@ export class ProcessManager {
         });
     }
     /**
-     * Start all registered processes respecting dependency order.
+     * Start all registered processes respecting dependency order, then verify
+     * every component that declares `health:` actually became healthy.
+     *
+     * SPEC.md § Failure semantics: a component that never becomes healthy
+     * FAILS THE INVOCATION. The rejection names each stuck component and the
+     * probe it was asked. Processes that did start are left running and stay
+     * registered, so the caller can record their pids for `status`/`logs`/`down`.
      */
     async startAll() {
         const batches = this.topologicalSort();
@@ -70,70 +169,119 @@ export class ProcessManager {
             // Start all processes in this batch concurrently
             await Promise.all(batch.map((name) => this.startOne(name)));
         }
-        console.log("\n  All components started.");
+        // A dependency gate above already verified some components; the sweep
+        // covers the rest — including every component nothing depends on.
+        const stuck = [];
+        await Promise.all([...this.processes.values()].map(async (proc) => {
+            const health = proc.health;
+            if (!health || !proc.process || proc.status === "healthy")
+                return;
+            if (!(await this.pollHealthy(proc, health))) {
+                stuck.push(this.stuck(proc, health));
+            }
+        }));
+        if (stuck.length > 0) {
+            throw this.healthFailure(healthFailureMessage(stuck));
+        }
+    }
+    /** The failure-message entry for a component whose check never passed. */
+    stuck(proc, health) {
+        return {
+            name: proc.name,
+            check: describeHealthCheck(health, proc.port),
+            budgetMs: healthBudgetMs(health, this.healthTimeoutMs),
+        };
+    }
+    /** Report a health-gate failure on stderr and build the error `up` rejects with. */
+    healthFailure(message) {
+        console.error(`  ! ${message}`);
+        console.error("    Processes are left running: `launchfile status` lists them, .launchfile/logs/<component>.log has their output, `launchfile down` stops them.");
+        return new HealthGateError(message);
+    }
+    /**
+     * Poll one component's declared check until it passes or the budget runs
+     * out. Throws when the check cannot run at all: a `path` check with no
+     * allocated port has nothing to poll, and treating that as healthy would be
+     * a silent pass of a check the file declared.
+     */
+    async pollHealthy(proc, health) {
+        if (healthCheckNeedsPort(health) && proc.port === undefined) {
+            throw this.healthFailure(`component ${proc.name} declares a health check (${describeHealthCheck(health, undefined)}) but no port was allocated to poll`);
+        }
+        // A command check never reads the port; 0 only fills the parameter.
+        const budget = healthBudgetMs(health, this.healthTimeoutMs);
+        const ok = await waitForHealthy(proc.name, health, proc.port ?? 0, budget);
+        if (ok)
+            proc.status = "healthy";
+        return ok;
     }
     async startOne(name) {
         const proc = this.processes.get(name);
         if (!proc)
             throw new Error(`Unknown component: ${name}`);
-        // Wait for dependencies
+        // Wait for dependencies. A `condition: healthy` gate fails closed: the
+        // dependent never starts when the dependency cannot be verified, and the
+        // whole invocation fails — the same answer compose gives `service_healthy`.
         for (const dep of proc.dependsOn) {
             const depProc = this.processes.get(dep.component);
             if (!depProc)
                 continue;
             if (dep.condition === "healthy") {
                 console.log(`  [${name}] Waiting for ${dep.component} to be healthy...`);
-                if (depProc.health && depProc.port) {
-                    await waitForHealthy(dep.component, depProc.health, depProc.port);
+                if (!depProc.health) {
+                    throw this.healthFailure(`component ${name} depends on ${dep.component} with condition: healthy, but ${dep.component} declares no health check`);
+                }
+                if (depProc.status !== "healthy" && !(await this.pollHealthy(depProc, depProc.health))) {
+                    const message = healthFailureMessage([this.stuck(depProc, depProc.health)]);
+                    throw this.healthFailure(`${message}; ${name} was not started`);
                 }
             }
             // For "started" condition, the process is already spawned by the time we get here
         }
         proc.status = "starting";
         console.log(`  [${name}] Starting: ${redactSecrets(proc.command)}`);
-        const logFile = createWriteStream(join(this.logDir, `${name}.log`), { flags: "a" });
         const colorIdx = [...this.processes.keys()].indexOf(name) % COLORS.length;
         const color = COLORS[colorIdx];
         const maxNameLen = Math.max(...[...this.processes.keys()].map((n) => n.length));
         const paddedName = name.padEnd(maxNameLen);
-        // `detached: true` makes the child the leader of a new process group
-        // (pgid === pid). That lets `launch down` signal the whole group later via
-        // a negative pid, killing the app AND any children it spawned — matching
-        // the foreground SIGINT behavior across sessions. We still keep the handle
-        // so the foreground session can kill it directly on Ctrl+C.
-        proc.process = spawn("sh", ["-c", proc.command], {
-            env: { ...process.env, ...proc.env },
-            cwd: proc.cwd,
-            stdio: ["ignore", "pipe", "pipe"],
-            detached: true,
+        // The child writes its stdout and stderr straight to its log file. A pipe
+        // held by this process would die with it, and a component left running
+        // after `up` fails (SPEC.md § Failure semantics) must survive its next
+        // write. The console view is a tail of that file.
+        const logPath = join(this.logDir, `${name}.log`);
+        const tail = new LogTail(logPath, (line) => {
+            process.stdout.write(`${color}[${paddedName}]${RESET} ${line}\n`);
         });
+        tail.start();
+        // The log holds the component's raw output, which can include a secret an
+        // app prints on first boot. The open mode covers a new file only, so a log
+        // left by an earlier run is tightened too.
+        const logFd = openSync(logPath, "a", 0o600);
+        try {
+            fchmodSync(logFd, 0o600);
+            // `detached: true` makes the child the leader of a new process group
+            // (pgid === pid). That lets `launch down` signal the whole group later via
+            // a negative pid, killing the app AND any children it spawned — matching
+            // the foreground SIGINT behavior across sessions. We still keep the handle
+            // so the foreground session can kill it directly on Ctrl+C.
+            proc.process = spawn("sh", ["-c", proc.command], {
+                env: { ...process.env, ...proc.env },
+                cwd: proc.cwd,
+                stdio: ["ignore", logFd, logFd],
+                detached: true,
+            });
+        }
+        finally {
+            // The child holds its own copy of the descriptor.
+            closeSync(logFd);
+        }
         if (proc.process.pid !== undefined) {
             proc.startedAt = new Date().toISOString();
         }
-        // Pipe stdout with prefix
-        proc.process.stdout?.on("data", (data) => {
-            const lines = data.toString().split("\n");
-            for (const line of lines) {
-                if (line) {
-                    process.stdout.write(`${color}[${paddedName}]${RESET} ${line}\n`);
-                    logFile.write(`${new Date().toISOString()} ${line}\n`);
-                }
-            }
-        });
-        // Pipe stderr with prefix
-        proc.process.stderr?.on("data", (data) => {
-            const lines = data.toString().split("\n");
-            for (const line of lines) {
-                if (line) {
-                    process.stderr.write(`${color}[${paddedName}]${RESET} \x1b[2m${line}${RESET}\n`);
-                    logFile.write(`${new Date().toISOString()} ERR ${line}\n`);
-                }
-            }
-        });
         proc.process.on("exit", (code) => {
             proc.status = code === 0 ? "stopped" : "failed";
+            tail.stop();
             console.log(`${color}[${paddedName}]${RESET} Process exited with code ${code}`);
-            logFile.end();
         });
         proc.status = "running";
     }