@paleo/worktree-env 0.5.0 → 0.5.2

package/dist/cli.js

@@ -80,6 +80,7 @@ export function printDevServerHelp() {
     console.log(formatHelp("dev-server [options]", "Start, stop, or list background dev-server processes.", DEV_SERVER_OPTIONS));
 }
 export function validateSetupFlags(args) {
+    // --wait may chain after --use/--create/--here; --info is standalone.
     const modeFlags = [
         args.use,
         args.create,
@@ -87,17 +88,19 @@ export function validateSetupFlags(args) {
         isRemoveMode(args),
         isSetOwnerMode(args),
         isFinalizeMode(args),
-        isWaitMode(args),
         isInfoMode(args),
     ].filter(Boolean);
     if (modeFlags.length > 1) {
-        throw new ConfigError("Error: --use, --create, --here, --remove, --remove-here, --set-owner, --wait, and --info are mutually exclusive.");
+        throw new ConfigError("Error: --use, --create, --here, --remove, --remove-here, --set-owner, and --info are mutually exclusive.");
+    }
+    if (isWaitMode(args) && (isRemoveMode(args) || isSetOwnerMode(args) || isInfoMode(args))) {
+        throw new ConfigError("Error: --wait can only be combined with --use, --create, or --here (or used standalone).");
     }
     if (args.remove !== undefined && args["remove-here"]) {
         throw new ConfigError("Error: --remove and --remove-here are mutually exclusive.");
     }
-    if (args.slot !== undefined && !isSetupMode(args) && !isWaitMode(args)) {
-        throw new ConfigError("Error: --slot can only be used with --use, --create, --here, or --wait.");
+    if (args.slot !== undefined && !isSetupMode(args) && !isWaitMode(args) && !isInfoMode(args)) {
+        throw new ConfigError("Error: --slot can only be used with --use, --create, --here, --wait, or --info.");
     }
     if (args.force && !isSetupMode(args) && !isFinalizeMode(args)) {
         throw new ConfigError("Error: --force can only be used with --use, --create, or --here.");

package/dist/setup-worktree.js

@@ -42,12 +42,12 @@ export async function runSetupWorktree(config) {
         await runFinalize(args, config);
         return;
     }
-    if (isWaitMode(args)) {
+    if (isWaitMode(args) && !isSetupMode(args)) {
         await runWait(args, config);
         return;
     }
     if (isInfoMode(args)) {
-        runInfo(config);
+        runInfo(args, config);
         return;
     }
     if (!isSetupMode(args) && !isRemoveMode(args) && !isSetOwnerMode(args)) {
@@ -65,7 +65,10 @@ export async function runSetupWorktree(config) {
         handleSetOwnerMode(args, ctx, config);
         return;
     }
-    await runSetup(args, ctx, run, config);
+    const { slot } = await runSetup(args, ctx, run, config);
+    if (isWaitMode(args)) {
+        await waitForSlot(slot, config);
+    }
 }
 async function runSetup(args, ctx, run, config) {
     const scheme = resolvePortScheme(config);
@@ -91,6 +94,9 @@ async function runSetup(args, ctx, run, config) {
     const runtimeDir = join(setupCtx.currentWorktree, config.runtimeDir);
     mkdirSync(runtimeDir, { recursive: true });
     const logPath = join(runtimeDir, "wt-setup.log");
+    // Truncate any prior log so `--here` retries start with a clean record (the previous run's
+    // FAILED: banner would otherwise linger and produce false positives for grep-based tooling).
+    writeFileSync(logPath, "");
     // Opened "a" so the same fd can be inherited by the detached finalize child below.
     const logFd = openSync(logPath, "a");
     const teeLog = (message) => {
@@ -117,7 +123,7 @@ async function runSetup(args, ctx, run, config) {
         mainWorktree: setupCtx.mainWorktree,
     }));
     teeLog(`WORKTREE_CREATED path=${setupCtx.currentWorktree} branch=${branch} slot=${slot}`);
-    teeLog(`Setup continuing in background. Tail: ${config.runtimeDir}/wt-setup.log`);
+    teeLog(`Setup continuing in background. Tail: ${logPath}`);
     const child = spawn(process.execPath, [config.scriptPath, "--__finalize", String(slot)], {
         detached: true,
         stdio: ["ignore", logFd, logFd],
@@ -125,6 +131,7 @@ async function runSetup(args, ctx, run, config) {
     });
     child.unref();
     closeSync(logFd);
+    return { slot };
 }
 async function runFinalize(args, config) {
     const slot = Number(args.__finalize);
@@ -173,7 +180,7 @@ async function runFinalize(args, config) {
         process.exit(1);
     }
 }
-function resolveWaitSlot(args, config) {
+function resolveTargetSlot(args, config) {
     if (args.slot !== undefined) {
         const slot = Number(args.slot);
         const scheme = resolvePortScheme(config);
@@ -210,13 +217,27 @@ function printWorktreeInfo(config, slot, worktreeForLog, fallback) {
         mainWorktree: ctx.mainWorktree,
     }));
 }
-function runInfo(config) {
+function runInfo(args, config) {
+    if (args.slot !== undefined) {
+        const slot = resolveTargetSlot(args, config);
+        const ctx = detectWorktree();
+        const entry = readSlots(ctx.mainWorktree, config.registryDir).slots[String(slot)];
+        if (!entry) {
+            console.error(`Error: No slot ${slot} in registry.`);
+            process.exit(1);
+        }
+        printWorktreeInfo(config, slot, entry.worktree, { branch: entry.branch, owner: entry.owner });
+        return;
+    }
     const resolved = resolveCurrentSlot(config.basePort, config.registryDir);
     printWorktreeInfo(config, resolved.slot, ".", { branch: resolved.branch, owner: resolved.owner });
 }
 async function runWait(args, config) {
+    const slot = resolveTargetSlot(args, config);
+    await waitForSlot(slot, config);
+}
+async function waitForSlot(slot, config) {
     const ctx = detectWorktree();
-    const slot = resolveWaitSlot(args, config);
     const initial = readSlots(ctx.mainWorktree, config.registryDir).slots[String(slot)];
     if (!initial) {
         console.error(`Error: No slot ${slot} in registry.`);
@@ -249,6 +270,13 @@ async function handleRemove(args, ctx, run, config) {
     const removeHere = Boolean(args["remove-here"]);
     const registry = readSlots(ctx.mainWorktree, config.registryDir);
     const target = resolveRemoveTarget(args, ctx, registry, removeHere);
+    // Refuse to remove while the detached finalize is still writing to slots.json / wt-setup.log:
+    // racing the two corrupts the registry and leaves the worktree directory orphaned.
+    if (registry.slots[target.slotPort]?.status === "pending") {
+        console.error(`Error: Setup is still in progress for slot ${target.slotPort}. ` +
+            `Run 'setup-worktree --wait --slot ${target.slotPort}' to wait for it to finish (or fail), then retry --remove.`);
+        process.exit(1);
+    }
     if (!args["no-remote-check"]) {
         verifyBranchAbsentFromRemote(target.branch, run);
     }
@@ -275,7 +303,8 @@ async function handleRemove(args, ctx, run, config) {
         process.chdir(ctx.mainWorktree);
     }
     removeWorktree(target.worktreePath, run);
-    console.log(`Removed worktree for branch "${target.branch}" (slot ${target.slotPort}${ownerSuffix}).`);
+    console.log(`Removed worktree for branch "${target.branch}" (slot ${target.slotPort}${ownerSuffix}). ` +
+        `Branch "${target.branch}" kept.`);
     if (removeHere) {
         console.log(`Now run: cd ${ctx.mainWorktree}`);
     }

package/dist/worktree.js

@@ -40,6 +40,7 @@ export function createBranch(requestedBranch, ctx, run) {
             ++suffix;
         }
         finalBranch = `${requestedBranch}-${suffix}`;
+        console.warn(`Warning: Branch "${requestedBranch}" already exists; using "${finalBranch}" instead.`);
     }
     const worktreePath = computeWorktreePath(ctx.mainWorktree, finalBranch);
     execFileSync("git", ["worktree", "add", "-b", finalBranch, worktreePath], {

package/package.json

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