@paleo/workspace 0.14.0 → 0.14.2

package/dist/dev-server.d.ts

@@ -33,6 +33,12 @@ export interface DevServerSummaryContext {
     }[];
 }
 export declare function runDevServer(config: DevServerConfig): Promise<void>;
+/**
+ * Poll the foreground's own spawn PIDs; when none remain alive, the servers were stopped from
+ * outside this process (`dev down`, `down --all`, eviction, or a manual kill). Fires `onStopped`
+ * once so the foreground can exit instead of hanging on dead servers.
+ */
+export declare function watchForExternalStop(pids: number[], onStopped: () => void, isAlive?: (pid: number) => boolean, intervalMs?: number): NodeJS.Timeout | undefined;
 export type WorktreeReadyCheck = {
     ok: true;
 } | {

package/dist/dev-server.js

@@ -82,17 +82,7 @@ async function start(config, mainWorktree, options) {
     if (await runStartChecks(config, mainWorktree, ctx, options))
         return;
     const state = { spawnPids: {}, startedCallbacks: [] };
-    try {
-        await spawnAndAwait(config, ctx, state);
-    }
-    catch (err) {
-        await rollbackStart(state.spawnPids, state.startedCallbacks, ctx);
-        if (err instanceof StartupError) {
-            handleStartupFailure(err);
-            process.exit(1);
-        }
-        throw err;
-    }
+    await spawnWithRollback(config, ctx, state);
     const slot = registerStartedServer(config, mainWorktree, state.spawnPids);
     printStartSummary(config, slot, state.spawnPids);
 }
@@ -121,21 +111,22 @@ async function runForeground(config, mainWorktree, options) {
     process.on("SIGTERM", onSignal);
     if (await runStartChecks(config, mainWorktree, ctx, options))
         process.exit(0);
-    try {
-        await spawnAndAwait(config, ctx, state);
-    }
-    catch (err) {
-        await rollbackStart(state.spawnPids, state.startedCallbacks, ctx);
-        if (err instanceof StartupError) {
-            handleStartupFailure(err);
-            process.exit(1);
-        }
-        throw err;
+    // A signal during startup hands teardown to onSignal (rollback + exit 130); block so we
+    // neither roll back twice nor register a server that is being torn down.
+    if (!(await spawnWithRollback(config, ctx, state, () => shuttingDown))) {
+        await new Promise(() => { });
     }
     const slot = registerStartedServer(config, mainWorktree, state.spawnPids);
     started = true;
     printStartSummary(config, slot, state.spawnPids);
     tailLogs(config, state.spawnPids);
+    watchForExternalStop(Object.values(state.spawnPids), () => {
+        if (shuttingDown)
+            return;
+        shuttingDown = true;
+        console.log("\nDev-server stopped externally (e.g. `dev down`). Exiting.");
+        process.exit(0);
+    });
     await new Promise(() => { });
 }
 async function shutdownForeground(config, mainWorktree) {
@@ -153,6 +144,26 @@ async function runStartChecks(config, mainWorktree, ctx, { evict, restart }) {
     await checkPortsFree(config.servers, ctx.cwd);
     return false;
 }
+/**
+ * Spawn and await readiness, rolling back on failure. Returns `false` when `isAborted` reports a
+ * concurrent shutdown — the caller must then yield teardown to whoever set it, not proceed.
+ */
+async function spawnWithRollback(config, ctx, state, isAborted = () => false) {
+    try {
+        await spawnAndAwait(config, ctx, state);
+    }
+    catch (err) {
+        if (isAborted())
+            return false;
+        await rollbackStart(state.spawnPids, state.startedCallbacks, ctx);
+        if (err instanceof StartupError) {
+            handleStartupFailure(err);
+            process.exit(1);
+        }
+        throw err;
+    }
+    return !isAborted();
+}
 async function spawnAndAwait(config, ctx, state) {
     for (const server of config.servers) {
         console.log(`Starting ${server.name} dev server...`);
@@ -203,6 +214,7 @@ function printStartSummary(config, slot, spawnPids) {
     }
 }
 const TAIL_INTERVAL_MS = 300;
+const LIVENESS_POLL_MS = 1000;
 function tailLogs(config, spawnPids) {
     const names = Object.keys(spawnPids);
     const prefixed = names.length > 1;
@@ -231,6 +243,22 @@ function followLogFile(path, prefix) {
         process.stdout.write(prefix === "" ? text : text.replace(/^(?=.)/gm, prefix));
     }, TAIL_INTERVAL_MS);
 }
+/**
+ * Poll the foreground's own spawn PIDs; when none remain alive, the servers were stopped from
+ * outside this process (`dev down`, `down --all`, eviction, or a manual kill). Fires `onStopped`
+ * once so the foreground can exit instead of hanging on dead servers.
+ */
+export function watchForExternalStop(pids, onStopped, isAlive = isProcessAlive, intervalMs = LIVENESS_POLL_MS) {
+    if (pids.length === 0)
+        return;
+    const timer = setInterval(() => {
+        if (pids.some(isAlive))
+            return;
+        clearInterval(timer);
+        onStopped();
+    }, intervalMs);
+    return timer;
+}
 async function rollbackStart(spawnPids, startedCallbacks, ctx) {
     console.error("\nStopping dev servers...");
     for (const pid of Object.values(spawnPids)) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paleo/workspace",
-  "version": "0.14.0",
+  "version": "0.14.2",
   "description": "Run multiple git-worktree dev environments side by side.",
   "keywords": [
     "workspace",