@paleo/worktree-env 0.4.1 → 0.5.0

package/README.md

@@ -28,6 +28,7 @@ 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 -- --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)
 npm run setup-worktree -- --remove feat/42   # full teardown
@@ -41,7 +42,9 @@ import { runSetupWorktree, helpers } from "@paleo/worktree-env";
 await runSetupWorktree({
   basePort: 8100,
   portNames: ["server", "frontend", "db"],
-  devServerPidFiles: [".local-data/dev-server.pid"],
+  sharedDirs: [".local", ".plans"],
+  runtimeDir: ".local-wt",
+  registryDir: ".local/wt-registry",
   configFiles: [
     {
       path: ".env",
@@ -52,28 +55,31 @@ await runSetupWorktree({
         }),
     },
   ],
-  setupWorktreeData: async ({ currentWorktree }) => {
-    // Create per-worktree directories, copy seed data, start containers, etc.
+  finalizeWorktree: async ({ currentWorktree }) => {
+    // MUST be idempotent. Install deps, start containers, seed a database, etc.
   },
-  installAndBuild: async () => {},
   printSummary: ({ slot, branch, owner, ports }) =>
     `Slot ${slot} (${branch}${owner ? `, ${owner}` : ""}) — server :${ports.server}`,
 });
 ```
 
+Setup runs in two phases: a fast foreground Part 1 creates the worktree and config, then a detached Part 2 runs `finalizeWorktree` and writes progress to `<runtimeDir>/wt-setup.log`. If Part 2 fails, `cd` into the worktree and run `setup-worktree --here` — it is idempotent and retries the finalize step. To block until Part 2 finishes (CI, agent orchestration), run `setup-worktree --wait` from inside the worktree (or `setup-worktree --wait --slot 8110` from anywhere) — exits 0 on `READY`, 1 on `FAILED`.
+
+`--evict` is best-effort: the cap check and the subsequent register are not atomic, so two concurrent `dev:up --evict` from different worktrees can both pass the check and end up at `devLimit + 1` live servers. The window is narrow; if it matters, `dev:list` + `dev:down` deterministically.
+
 ```ts
 import { runDevServer, helpers } from "@paleo/worktree-env";
 
 await runDevServer({
   basePort: 8100,
+  runtimeDir: ".local-wt",
+  registryDir: ".local/wt-registry",
   devLimit: 5,
   servers: [
     {
       name: "dev",
       exec: { command: "npm", args: ["run", "dev"] },
       port: helpers.readPortFromEnvFile(".env", "PORT"),
-      pidFile: ".local-data/dev-server.pid",
-      logFile: ".local-data/logs/dev-server.log",
       detectSuccess: (log) => log.includes("Server is ready on port"),
     },
   ],

package/dist/cli.d.ts

@@ -11,19 +11,27 @@ export interface SetupArgs {
     slot?: string;
     force?: boolean;
     verbose?: boolean;
+    wait?: boolean;
+    info?: boolean;
+    /** @internal Set by `runSetupWorktree` when it re-spawns itself to run the finalize phase. */
+    __finalize?: string;
 }
 export interface DevServerArgs {
     help?: boolean;
     stop?: boolean;
     list?: boolean;
     all?: boolean;
+    evict?: boolean;
 }
 export declare function parseSetupArgs(argv?: string[]): SetupArgs;
 export declare function parseDevServerArgs(argv?: string[]): DevServerArgs;
 export declare function printSetupHelp(): void;
 export declare function printDevServerHelp(): void;
+export declare function validateSetupFlags(args: SetupArgs): void;
+export declare function validateDevServerFlags(args: DevServerArgs): void;
 export declare function isSetupMode(args: SetupArgs): boolean;
 export declare function isRemoveMode(args: SetupArgs): boolean;
 export declare function isSetOwnerMode(args: SetupArgs): boolean;
-export declare function validateSetupFlags(args: SetupArgs): void;
-export declare function validateDevServerFlags(args: DevServerArgs): void;
+export declare function isFinalizeMode(args: SetupArgs): boolean;
+export declare function isWaitMode(args: SetupArgs): boolean;
+export declare function isInfoMode(args: SetupArgs): boolean;

package/dist/cli.js

@@ -50,51 +50,35 @@ const SETUP_OPTIONS = {
         description: "Overwrite existing config files and re-provision the database",
     },
     verbose: { type: "boolean", short: "v", description: "Show intermediate output" },
+    wait: {
+        type: "boolean",
+        description: "Wait for the background finalize to reach READY (exit 0, prints the worktree summary) or FAILED (exit 1). Uses the current worktree's slot, or --slot PORT to target another.",
+    },
+    info: {
+        type: "boolean",
+        description: "Print the worktree summary (ports, branch, readiness) for the current worktree.",
+    },
+    __finalize: { type: "string", arg: "slot", description: "" },
 };
 const DEV_SERVER_OPTIONS = {
     help: { type: "boolean", short: "h", description: "Show this help message" },
     stop: { type: "boolean", description: "Stop dev servers in the current worktree" },
     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" },
 };
-function parseOptions(argv, options) {
-    const cfg = { options: options, strict: true };
-    if (argv)
-        cfg.args = argv;
-    const { values } = parseArgs(cfg);
-    return values;
-}
 export function parseSetupArgs(argv) {
     return parseOptions(argv, SETUP_OPTIONS);
 }
 export function parseDevServerArgs(argv) {
     return parseOptions(argv, DEV_SERVER_OPTIONS);
 }
-function formatHelp(usage, intro, options) {
-    const lines = [`Usage: ${usage}`, "", intro, ""];
-    for (const [name, opt] of Object.entries(options)) {
-        const shortFlag = opt.short ? `-${opt.short}, ` : "";
-        const argSuffix = opt.arg ? ` <${opt.arg}>` : "";
-        const flag = `${shortFlag}--${name}${argSuffix}`;
-        lines.push(`  ${flag.padEnd(28)} ${opt.description}`);
-    }
-    return lines.join("\n");
-}
 export function printSetupHelp() {
     console.log(formatHelp("setup-worktree [options]", "Manage worktree lifecycle: creation, local environment setup, and removal.", SETUP_OPTIONS));
 }
 export function printDevServerHelp() {
     console.log(formatHelp("dev-server [options]", "Start, stop, or list background dev-server processes.", DEV_SERVER_OPTIONS));
 }
-export function isSetupMode(args) {
-    return args.use !== undefined || args.create !== undefined || Boolean(args.here);
-}
-export function isRemoveMode(args) {
-    return args.remove !== undefined || Boolean(args["remove-here"]);
-}
-export function isSetOwnerMode(args) {
-    return args["set-owner"] !== undefined;
-}
 export function validateSetupFlags(args) {
     const modeFlags = [
         args.use,
@@ -102,15 +86,21 @@ export function validateSetupFlags(args) {
         args.here,
         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, and --set-owner are mutually exclusive.");
+        throw new ConfigError("Error: --use, --create, --here, --remove, --remove-here, --set-owner, --wait, and --info are mutually exclusive.");
     }
     if (args.remove !== undefined && args["remove-here"]) {
         throw new ConfigError("Error: --remove and --remove-here are mutually exclusive.");
     }
-    if ((args.slot !== undefined || args.force) && !isSetupMode(args)) {
-        throw new ConfigError("Error: --slot and --force can only be used with --use, --create, or --here.");
+    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.force && !isSetupMode(args) && !isFinalizeMode(args)) {
+        throw new ConfigError("Error: --force can only be used with --use, --create, or --here.");
     }
     if (args.owner !== undefined && !isSetupMode(args)) {
         throw new ConfigError("Error: --owner is only valid with --use, --create, or --here.");
@@ -126,4 +116,45 @@ export function validateDevServerFlags(args) {
     if (args.list && (args.stop || args.all)) {
         throw new ConfigError("Error: --list is mutually exclusive with --stop and --all.");
     }
+    if (args.evict && (args.stop || args.list || args.all)) {
+        const conflict = args.stop ? "--stop" : args.list ? "--list" : "--all";
+        throw new ConfigError(`Error: --evict cannot be combined with ${conflict}.`);
+    }
+}
+export function isSetupMode(args) {
+    return args.use !== undefined || args.create !== undefined || Boolean(args.here);
+}
+export function isRemoveMode(args) {
+    return args.remove !== undefined || Boolean(args["remove-here"]);
+}
+export function isSetOwnerMode(args) {
+    return args["set-owner"] !== undefined;
+}
+export function isFinalizeMode(args) {
+    return args.__finalize !== undefined;
+}
+export function isWaitMode(args) {
+    return Boolean(args.wait);
+}
+export function isInfoMode(args) {
+    return Boolean(args.info);
+}
+function parseOptions(argv, options) {
+    const cfg = { options: options, strict: true };
+    if (argv)
+        cfg.args = argv;
+    const { values } = parseArgs(cfg);
+    return values;
+}
+function formatHelp(usage, intro, options) {
+    const lines = [`Usage: ${usage}`, "", intro, ""];
+    for (const [name, opt] of Object.entries(options)) {
+        if (opt.description === "")
+            continue;
+        const shortFlag = opt.short ? `-${opt.short}, ` : "";
+        const argSuffix = opt.arg ? ` <${opt.arg}>` : "";
+        const flag = `${shortFlag}--${name}${argSuffix}`;
+        lines.push(`  ${flag.padEnd(28)} ${opt.description}`);
+    }
+    return lines.join("\n");
 }

package/dist/dev-server.d.ts

@@ -3,6 +3,14 @@ import { type ResolvedSlot } from "./slots.js";
 export interface DevServerConfig {
     /** Anchor port for the slot range. Used to synthesize the main worktree's slot. */
     basePort: number;
+    /** Per-worktree runtime directory, relative to the worktree root (e.g. `.local-wt`). */
+    runtimeDir: string;
+    /**
+     * Shared registry directory, relative to a worktree root (e.g. `.local/wt-registry`).
+     * Holds `slots.json` and `dev-servers.json`. Must resolve to the same physical directory
+     * across linked worktrees — typically via a symlink (e.g. `.local`).
+     */
+    registryDir: string;
     /** Maximum concurrent dev-servers across all worktrees. Omit for no limit. */
     devLimit?: number;
     /** One entry per process to spawn. Started in array order. */
@@ -14,7 +22,7 @@ export interface DevServerConfig {
 }
 /** Describes one process to spawn. */
 export interface ServerDescriptor {
-    /** Short label used in logs and the registry. */
+    /** Short label used in logs and the registry. Derives `<runtimeDir>/<name>.pid` and `<runtimeDir>/logs/<name>.log`. */
     name: string;
     /** Command and arguments passed to `child_process.spawn`. */
     exec: {
@@ -23,10 +31,6 @@ export interface ServerDescriptor {
     };
     /** Port the process will listen on. Use `helpers.readPortFromEnvFile` / `readPortFromJsonFile` to read it from a config file. */
     port: number;
-    /** Path (relative to cwd) where the spawned PID is written. */
-    pidFile: string;
-    /** Path (relative to cwd) where stdout+stderr are tee'd. */
-    logFile: string;
     /** Returns `true` once the log content indicates the server is ready. */
     detectSuccess: (logContent: string) => boolean;
     /** Returns a non-empty marker string when the log content indicates a fatal error, or `false` otherwise. */

package/dist/dev-server.js

@@ -3,46 +3,17 @@ import { closeSync, mkdirSync, openSync, writeFileSync } from "node:fs";
 import { createConnection } from "node:net";
 import { dirname, join } from "node:path";
 import { parseDevServerArgs, printDevServerHelp, validateDevServerFlags, } from "./cli.js";
-import { listDevServers, printActiveServers, pruneAndPersist, registerDevServer, stopAllRegistered, unregisterDevServer, } from "./dev-servers-registry.js";
+import { evictOldest, listDevServers, printActiveServers, pruneAndPersist, registerDevServer, stopAllRegistered, unregisterDevServer, } from "./dev-servers-registry.js";
 import { ConfigError, StartupError } from "./errors.js";
 import { awaitAllReady, handleStartupFailure } from "./log-polling.js";
 import { cleanupPidFile, isProcessAlive, readPid, stopByPidFile } from "./process-control.js";
 import { resolveCurrentSlot } from "./slots.js";
 import { detectWorktree } from "./worktree.js";
-function isPortBusy(port) {
-    return new Promise((resolve) => {
-        const socket = createConnection({ port, host: "127.0.0.1" });
-        socket.setTimeout(500);
-        socket.once("connect", () => {
-            socket.destroy();
-            resolve(true);
-        });
-        socket.once("timeout", () => {
-            socket.destroy();
-            resolve(false);
-        });
-        socket.once("error", () => {
-            resolve(false);
-        });
-    });
+function pidFileFor(runtimeDir, name) {
+    return join(runtimeDir, `${name}.pid`);
 }
-function spawnServer(server) {
-    mkdirSync(dirname(server.logFile), { recursive: true });
-    mkdirSync(dirname(server.pidFile), { recursive: true });
-    const logFd = openSync(server.logFile, "w");
-    const child = spawn(server.exec.command, server.exec.args, {
-        detached: true,
-        stdio: ["ignore", logFd, logFd],
-    });
-    if (child.pid === undefined) {
-        closeSync(logFd);
-        console.error(`Error: failed to spawn ${server.name}.`);
-        process.exit(1);
-    }
-    writeFileSync(server.pidFile, String(child.pid));
-    child.unref();
-    closeSync(logFd);
-    return child.pid;
+function logFileFor(runtimeDir, name) {
+    return join(runtimeDir, "logs", `${name}.log`);
 }
 export async function runDevServer(config) {
     let args;
@@ -69,13 +40,14 @@ export async function runDevServer(config) {
     }
     const { mainWorktree } = detectWorktree();
     if (args.list) {
-        listDevServers(mainWorktree);
+        listDevServers(mainWorktree, config.registryDir);
         return;
     }
     if (args.stop && args.all) {
         await stopAllRegistered({
             mainWorktree,
-            pidFiles: config.servers.map((s) => s.pidFile),
+            registryDir: config.registryDir,
+            runtimeDir: config.runtimeDir,
         });
         return;
     }
@@ -83,51 +55,23 @@ export async function runDevServer(config) {
         await stopLocal(config, mainWorktree);
         return;
     }
-    await start(config, mainWorktree);
+    await start(config, mainWorktree, { evict: Boolean(args.evict) });
 }
-async function start(config, mainWorktree) {
-    const limit = config.devLimit;
-    const active = pruneAndPersist(mainWorktree).servers;
-    if (limit !== undefined && active.length >= limit) {
-        console.error(`Error: dev-server cap reached (${active.length}/${limit}). Active dev-servers:`);
-        printActiveServers(active);
-        console.error("Run `dev:down` in another worktree, or `dev:down --all`.");
-        process.exit(1);
-    }
-    const serverPorts = config.servers.map((server) => [
-        server,
-        server.port,
-    ]);
-    const busyResults = await Promise.all(serverPorts.map(([, port]) => isPortBusy(port)));
-    let anyBusy = false;
-    busyResults.forEach((busy, i) => {
-        if (busy) {
-            const [server, port] = serverPorts[i];
-            console.error(`Error: Port ${port} (${server.name}) is already in use.`);
-            anyBusy = true;
-        }
-    });
-    if (anyBusy)
-        process.exit(1);
-    for (const server of config.servers) {
-        const existingPid = readPid(server.pidFile);
-        if (existingPid !== undefined && isProcessAlive(existingPid)) {
-            console.error(`Error: ${server.name} is already running (PID ${existingPid}).`);
-            process.exit(1);
-        }
-        cleanupPidFile(server.pidFile);
-    }
+async function start(config, mainWorktree, { evict }) {
+    await enforceCap(config, mainWorktree, evict);
+    await checkPortsFree(config.servers);
+    checkNoLocalPidConflict(config);
     if (config.ensureInfrastructure)
         await config.ensureInfrastructure();
     const pids = [];
     for (const server of config.servers) {
         console.log(`Starting ${server.name} dev server...`);
-        pids.push(spawnServer(server));
+        pids.push(spawnServer(server, config.runtimeDir));
     }
     try {
         const pollables = config.servers.map((s) => ({
             name: s.name,
-            logFile: s.logFile,
+            logFile: logFileFor(config.runtimeDir, s.name),
             detectSuccess: s.detectSuccess,
             detectError: s.detectError,
         }));
@@ -142,12 +86,12 @@ async function start(config, mainWorktree) {
         }
         throw err;
     }
-    const slot = resolveCurrentSlot(config.basePort);
+    const slot = resolveCurrentSlot(config.basePort, config.registryDir);
     const pidMap = {};
     config.servers.forEach((server, i) => {
         pidMap[server.name] = pids[i];
     });
-    registerDevServer(mainWorktree, {
+    registerDevServer(mainWorktree, config.registryDir, {
         slot: slot.slot,
         worktree: slot.worktree,
         branch: slot.branch,
@@ -160,30 +104,118 @@ async function start(config, mainWorktree) {
             slot,
             servers: config.servers.map((server, i) => ({
                 server,
-                port: serverPorts[i][1],
+                port: server.port,
                 pid: pids[i],
             })),
         }));
     }
     else {
-        defaultPrintSummary(slot, config.servers, serverPorts.map(([, p]) => p), pids);
+        defaultPrintSummary(slot, config.servers, config.servers.map((s) => s.port), pids, config.runtimeDir);
     }
 }
-function defaultPrintSummary(slot, servers, ports, pids) {
+// 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).
+async function enforceCap(config, mainWorktree, evict) {
+    const limit = config.devLimit;
+    if (limit === undefined)
+        return;
+    const active = pruneAndPersist(mainWorktree, config.registryDir).servers;
+    if (active.length < limit)
+        return;
+    if (!evict) {
+        console.error(`Error: dev-server cap reached (${active.length}/${limit}). Active dev-servers:`);
+        printActiveServers(active);
+        console.error("Run `dev:down` in another worktree, or `dev:down --all`.");
+        console.error("Re-run with --evict to evict the oldest.");
+        process.exit(1);
+    }
+    const toEvict = active.length - limit + 1;
+    console.log(`Evicting ${toEvict} dev-server(s) to make room (cap ${limit}).`);
+    const evicted = await evictOldest(mainWorktree, config.registryDir, toEvict);
+    for (const entry of evicted) {
+        const ownerPart = entry.owner ? `, owner=${entry.owner}` : "";
+        console.log(`Evicted slot ${entry.slot} (branch=${entry.branch}${ownerPart}, startedAt=${entry.startedAt}).`);
+        for (const name of Object.keys(entry.pids)) {
+            cleanupPidFile(join(entry.worktree, config.runtimeDir, `${name}.pid`));
+        }
+    }
+}
+async function checkPortsFree(servers) {
+    const busy = await Promise.all(servers.map((s) => isPortBusy(s.port)));
+    let anyBusy = false;
+    busy.forEach((b, i) => {
+        if (b) {
+            console.error(`Error: Port ${servers[i].port} (${servers[i].name}) is already in use.`);
+            anyBusy = true;
+        }
+    });
+    if (anyBusy)
+        process.exit(1);
+}
+function checkNoLocalPidConflict(config) {
+    for (const server of config.servers) {
+        const pidFile = pidFileFor(config.runtimeDir, server.name);
+        const existingPid = readPid(pidFile);
+        if (existingPid !== undefined && isProcessAlive(existingPid)) {
+            console.error(`Error: ${server.name} is already running (PID ${existingPid}).`);
+            process.exit(1);
+        }
+        cleanupPidFile(pidFile);
+    }
+}
+async function stopLocal(config, mainWorktree) {
+    for (const server of config.servers) {
+        await stopByPidFile(pidFileFor(config.runtimeDir, server.name), server.name, (msg) => console.log(msg));
+    }
+    unregisterDevServer(mainWorktree, config.registryDir, process.cwd());
+}
+function defaultPrintSummary(slot, servers, ports, pids, runtimeDir) {
     console.log("\nDev servers started!");
     const ownerSuffix = slot.owner ? `, owner ${slot.owner}` : "";
     console.log(`  Worktree: slot ${slot.slot}${ownerSuffix}`);
     servers.forEach((server, i) => {
         const url = `http://localhost:${ports[i]}/`;
-        const logPath = join(process.cwd(), server.logFile);
+        const logPath = join(process.cwd(), logFileFor(runtimeDir, server.name));
         console.log(`  ${server.name}: ${url}  (PID ${pids[i]})`);
         console.log(`    log: ${logPath}`);
     });
     console.log("");
 }
-async function stopLocal(config, mainWorktree) {
-    for (const server of config.servers) {
-        await stopByPidFile(server.pidFile, server.name, (msg) => console.log(msg));
+function spawnServer(server, runtimeDir) {
+    const logFile = logFileFor(runtimeDir, server.name);
+    const pidFile = pidFileFor(runtimeDir, server.name);
+    mkdirSync(dirname(logFile), { recursive: true });
+    mkdirSync(dirname(pidFile), { recursive: true });
+    const logFd = openSync(logFile, "w");
+    const child = spawn(server.exec.command, server.exec.args, {
+        detached: true,
+        stdio: ["ignore", logFd, logFd],
+    });
+    if (child.pid === undefined) {
+        closeSync(logFd);
+        console.error(`Error: failed to spawn ${server.name}.`);
+        process.exit(1);
     }
-    unregisterDevServer(mainWorktree, process.cwd());
+    writeFileSync(pidFile, String(child.pid));
+    child.unref();
+    closeSync(logFd);
+    return child.pid;
+}
+function isPortBusy(port) {
+    return new Promise((resolve) => {
+        const socket = createConnection({ port, host: "127.0.0.1" });
+        socket.setTimeout(500);
+        socket.once("connect", () => {
+            socket.destroy();
+            resolve(true);
+        });
+        socket.once("timeout", () => {
+            socket.destroy();
+            resolve(false);
+        });
+        socket.once("error", () => {
+            resolve(false);
+        });
+    });
 }

package/dist/dev-servers-registry.d.ts

@@ -1,5 +1,3 @@
-export declare const DEV_SERVERS_FILE = ".local/worktrees/dev-servers.json";
-export declare const WORKTREES_DIR = ".local/worktrees";
 export interface DevServerEntry {
     slot: number;
     worktree: string;
@@ -11,18 +9,24 @@ export interface DevServerEntry {
 export interface DevServersData {
     servers: DevServerEntry[];
 }
-export declare function readDevServers(mainWorktree: string): DevServersData;
-export declare function writeDevServers(mainWorktree: string, data: DevServersData): void;
 export type IsAliveFn = (pid: number) => boolean;
-export declare function pruneDeadServers(data: DevServersData, isAlive?: IsAliveFn): DevServersData;
-export declare function pruneAndPersist(mainWorktree: string, isAlive?: IsAliveFn): DevServersData;
-export declare function registerDevServer(mainWorktree: string, entry: DevServerEntry): void;
-export declare function unregisterDevServer(mainWorktree: string, worktreePath: string): void;
-export declare function removeDevServerEntryByWorktree(mainWorktree: string, worktreePath: string): void;
+export declare function listDevServers(mainWorktree: string, registryDir: string): void;
 export declare function printActiveServers(active: DevServerEntry[]): void;
-export declare function listDevServers(mainWorktree: string): void;
 export interface StopAllInput {
     mainWorktree: string;
-    pidFiles: string[];
+    registryDir: string;
+    runtimeDir: string;
 }
 export declare function stopAllRegistered(input: StopAllInput): Promise<void>;
+export interface EvictDeps {
+    isAlive?: IsAliveFn;
+    stop?: (pid: number) => Promise<void>;
+}
+export declare function evictOldest(mainWorktree: string, registryDir: string, count: number, deps?: EvictDeps): Promise<DevServerEntry[]>;
+export declare function registerDevServer(mainWorktree: string, registryDir: string, entry: DevServerEntry): void;
+export declare function unregisterDevServer(mainWorktree: string, registryDir: string, worktreePath: string): void;
+export declare function removeDevServerEntryByWorktree(mainWorktree: string, registryDir: string, worktreePath: string): void;
+export declare function pruneAndPersist(mainWorktree: string, registryDir: string, isAlive?: IsAliveFn): DevServersData;
+export declare function pruneDeadServers(data: DevServersData, isAlive?: IsAliveFn): DevServersData;
+export declare function readDevServers(mainWorktree: string, registryDir: string): DevServersData;
+export declare function writeDevServers(mainWorktree: string, registryDir: string, data: DevServersData): void;