@paleo/worktree-env 0.7.3 → 0.7.5

package/README.md

@@ -27,7 +27,8 @@ The agent reads the skill, adapts the reference scripts to your stack, installs
 
 ```sh
 npm run setup-worktree -- --create feat/42   # new branch + worktree + isolated env
-npm run dev:up                               # start dev server in the background
+npm run dev:up                               # start dev server in the background (no-op if already running here)
+npm run dev:up -- --restart                  # stop the dev-server in this worktree if running, then start fresh
 npm run dev:up -- --evict                    # if devLimit is reached, evict the oldest dev-server and start
 npm run dev:list                             # active dev-servers across all worktrees
 npm run dev:down                             # stop dev server (infrastructure stays up)

package/dist/cli.d.ts

@@ -22,6 +22,7 @@ export interface DevServerArgs {
     list?: boolean;
     all?: boolean;
     evict?: boolean;
+    restart?: boolean;
 }
 export declare function parseSetupArgs(argv?: string[]): SetupArgs;
 export declare function parseDevServerArgs(argv?: string[]): DevServerArgs;

package/dist/cli.js

@@ -66,6 +66,10 @@ const DEV_SERVER_OPTIONS = {
     list: { type: "boolean", description: "List active dev-servers across all worktrees" },
     all: { type: "boolean", description: "Apply --stop to every active dev-server" },
     evict: { type: "boolean", description: "Evict the oldest dev-server when the cap is reached" },
+    restart: {
+        type: "boolean",
+        description: "If a dev-server is already running in this worktree, stop it first, then start",
+    },
 };
 export function parseSetupArgs(argv) {
     return parseOptions(argv, SETUP_OPTIONS);
@@ -123,6 +127,10 @@ export function validateDevServerFlags(args) {
         const conflict = args.stop ? "--stop" : args.list ? "--list" : "--all";
         throw new ConfigError(`Error: --evict cannot be combined with ${conflict}.`);
     }
+    if (args.restart && (args.stop || args.list || args.all)) {
+        const conflict = args.stop ? "--stop" : args.list ? "--list" : "--all";
+        throw new ConfigError(`Error: --restart cannot be combined with ${conflict}.`);
+    }
 }
 export function isSetupMode(args) {
     return args.use !== undefined || args.create !== undefined || Boolean(args.here);

package/dist/dev-server.js

@@ -53,13 +53,18 @@ export async function runDevServer(config) {
         await stopLocal(config, mainWorktree);
         return;
     }
-    await start(config, mainWorktree, { evict: Boolean(args.evict) });
+    await start(config, mainWorktree, {
+        evict: Boolean(args.evict),
+        restart: Boolean(args.restart),
+    });
 }
 function callbackServersOf(config) {
     return config.servers.filter((s) => s.kind === "callback");
 }
-async function start(config, mainWorktree, { evict }) {
+async function start(config, mainWorktree, { evict, restart }) {
     const ctx = { cwd: process.cwd() };
+    if (await handleAlreadyRunning(config, mainWorktree, ctx, restart))
+        return;
     await enforceCap(config, mainWorktree, evict);
     checkNoLocalRegistryConflict(config, mainWorktree, ctx.cwd);
     await checkPortsFree(config.servers);
@@ -136,6 +141,28 @@ async function rollbackStart(spawnPids, startedCallbacks, ctx) {
         }
     }
 }
+/**
+ * If a dev-server is already running in this worktree, either stop it (when `restart`) so the
+ * normal start path can proceed, or print a friendly notice and return `true` to short-circuit.
+ * Returns `true` when the caller should exit cleanly without starting.
+ */
+async function handleAlreadyRunning(config, mainWorktree, ctx, restart) {
+    const entry = findOwnEntry(mainWorktree, config.registryDir, ctx.cwd);
+    if (!entry)
+        return false;
+    const livePids = Object.entries(entry.pids).filter(([, pid]) => isProcessAlive(pid));
+    if (livePids.length === 0)
+        return false;
+    if (restart) {
+        console.log("Restarting dev-server in this worktree...");
+        await stopLocal(config, mainWorktree);
+        return false;
+    }
+    const pidList = livePids.map(([name, pid]) => `${name}=${pid}`).join(", ");
+    console.log(`dev-server already running for this worktree (slot ${entry.slot}, pids: ${pidList}).`);
+    console.log("Run `dev:down` to stop it, or re-run with --restart to restart.");
+    return true;
+}
 // TOCTOU: the cap check and the subsequent register are not atomic. Two concurrent `dev:up --evict`
 // from different worktrees can both pass the cap check and both register, exceeding the limit by
 // one. Accepted: the race window is narrow and the consequence is bounded (one extra dev-server).

package/dist/setup-worktree.d.ts

@@ -86,6 +86,8 @@ export interface PreSetupContext {
 export interface SetupContext {
     currentWorktree: string;
     mainWorktree: string;
+    /** `true` when finalizing the main worktree. Gate "copy from main" steps with `!isMainWorktree`. */
+    isMainWorktree: boolean;
     slot: number;
     branch: string;
     owner?: string;

package/dist/setup-worktree.js

@@ -181,6 +181,7 @@ async function runFinalize(args, config) {
     const setupContext = {
         currentWorktree: ctx.currentWorktree,
         mainWorktree: ctx.mainWorktree,
+        isMainWorktree: ctx.isMainWorktree,
         slot,
         branch: entry.branch,
         owner: entry.owner,
@@ -279,15 +280,13 @@ async function waitForSlot(slot, config, options = {}) {
             process.exit(1);
         }
         if (entry.status === "ready") {
+            console.log("\n… ready");
             if (printSummary) {
                 printWorktreeInfo(config, slot, entry.worktree, {
                     branch: entry.branch,
                     owner: entry.owner,
                 });
             }
-            else {
-                console.log("Status: ready");
-            }
             return;
         }
         if (entry.status === "failed") {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@paleo/worktree-env",
-  "version": "0.7.3",
+  "version": "0.7.5",
   "description": "Worktree-based concurrent local environment kernel.",
   "keywords": [
     "worktree",