webmux 0.40.0 → 0.41.0

package/bin/webmux.js

@@ -5997,7 +5997,7 @@ var init_zod = __esm(() => {
   init_external();
 });
 
-// node_modules/.bun/@ts-rest+core@3.52.1+aea371d0c1c4fd29/node_modules/@ts-rest/core/index.esm.mjs
+// node_modules/.bun/@ts-rest+core@3.52.1+38b2c5aebf202339/node_modules/@ts-rest/core/index.esm.mjs
 var isZodType = (obj) => {
   return typeof (obj === null || obj === undefined ? undefined : obj.safeParse) === "function";
 }, isZodObjectStrict = (obj) => {
@@ -8339,21 +8339,110 @@ ${result.stderr.trim()}` : ""
   console.log();
 });
 
+// backend/src/domain/projects.ts
+function isProjectEntry(value) {
+  if (typeof value !== "object" || value === null)
+    return false;
+  const v = value;
+  return typeof v.path === "string" && v.path.length > 0 && typeof v.name === "string" && typeof v.addedAt === "number";
+}
+
+// backend/src/lib/log.ts
+function ts() {
+  return new Date().toISOString().slice(11, 23);
+}
+var DEBUG, log2;
+var init_log = __esm(() => {
+  DEBUG = Bun.env.WEBMUX_DEBUG === "1";
+  log2 = {
+    info(msg) {
+      console.log(`[${ts()}] ${msg}`);
+    },
+    debug(msg) {
+      if (DEBUG)
+        console.log(`[${ts()}] ${msg}`);
+    },
+    warn(msg) {
+      console.warn(`[${ts()}] ${msg}`);
+    },
+    error(msg, err) {
+      err !== undefined ? console.error(`[${ts()}] ${msg}`, err) : console.error(`[${ts()}] ${msg}`);
+    }
+  };
+});
+
+// backend/src/adapters/projects-registry.ts
+import { mkdirSync, readFileSync as readFileSync3, renameSync, writeFileSync } from "fs";
+import { homedir } from "os";
+import { dirname as dirname3, join as join5 } from "path";
+function defaultRegistryFile() {
+  return join5(homedir(), ".webmux", "projects.json");
+}
+function createProjectsRegistry(file = defaultRegistryFile()) {
+  function read() {
+    let raw;
+    try {
+      raw = readFileSync3(file, "utf8");
+    } catch {
+      return [];
+    }
+    let parsed;
+    try {
+      parsed = JSON.parse(raw);
+    } catch {
+      log2.debug(`[projects-registry] ignoring malformed ${file}`);
+      return [];
+    }
+    if (!Array.isArray(parsed))
+      return [];
+    return parsed.filter(isProjectEntry);
+  }
+  function write(entries) {
+    mkdirSync(dirname3(file), { recursive: true });
+    const tmpPath = `${file}.${process.pid}.${Date.now()}.tmp`;
+    writeFileSync(tmpPath, `${JSON.stringify(entries, null, 2)}
+`);
+    renameSync(tmpPath, file);
+  }
+  return {
+    list() {
+      return read();
+    },
+    add(entry) {
+      const entries = read().filter((existing) => existing.path !== entry.path);
+      entries.push(entry);
+      write(entries);
+    },
+    remove(path) {
+      const entries = read();
+      const next = entries.filter((entry) => entry.path !== path);
+      if (next.length !== entries.length)
+        write(next);
+    }
+  };
+}
+var init_projects_registry = __esm(() => {
+  init_log();
+});
+
 // bin/src/service.ts
 var exports_service = {};
 __export(exports_service, {
+  shouldPersistProject: () => shouldPersistProject,
   resolveEnvVars: () => resolveEnvVars,
+  resolveConfirmDecision: () => resolveConfirmDecision,
   readPortFromUnit: () => readPortFromUnit,
   readEnvVarsFromUnit: () => readEnvVarsFromUnit,
   parseInstalledServiceConfig: () => parseInstalledServiceConfig,
   parseEnvCliArgs: () => parseEnvCliArgs,
+  migrateServedRepoFromUnit: () => migrateServedRepoFromUnit,
   generateServiceFile: () => generateServiceFile,
   default: () => service,
   AUTO_PICKUP_ENV_VARS: () => AUTO_PICKUP_ENV_VARS
 });
-import { chmodSync, existsSync as existsSync4, mkdirSync, readFileSync as readFileSync3, unlinkSync } from "fs";
-import { basename as basename3, join as join5 } from "path";
-import { homedir } from "os";
+import { chmodSync, existsSync as existsSync4, mkdirSync as mkdirSync2, readFileSync as readFileSync4, unlinkSync } from "fs";
+import { basename as basename3, join as join6 } from "path";
+import { homedir as homedir2 } from "os";
 function getPlatform() {
   const plat = process.platform;
   if (plat === "linux" || plat === "darwin")
@@ -8366,6 +8455,33 @@ function resolveWebmuxPath() {
     return null;
   return result.stdout.toString().trim();
 }
+function shouldPersistProject(root, hasWebmuxConfig, existingPaths) {
+  if (!root || !hasWebmuxConfig)
+    return false;
+  return !existingPaths.includes(root);
+}
+function hasWebmuxConfig(root) {
+  return existsSync4(join6(root, ".webmux.yaml")) || existsSync4(join6(root, ".webmux.local.yaml"));
+}
+function persistProject(root, registry) {
+  if (!root)
+    return null;
+  const existingPaths = registry.list().map((entry) => entry.path);
+  if (!shouldPersistProject(root, hasWebmuxConfig(root), existingPaths))
+    return null;
+  registry.add({ path: root, name: detectProjectName(root), addedAt: Date.now() });
+  return root;
+}
+function cwdProjectToPersist() {
+  const gitRoot2 = getGitRoot();
+  if (!gitRoot2)
+    return null;
+  const existingPaths = createProjectsRegistry().list().map((entry) => entry.path);
+  return shouldPersistProject(gitRoot2, hasWebmuxConfig(gitRoot2), existingPaths) ? gitRoot2 : null;
+}
+function migrateServedRepoFromUnit(filePath, platform, registry = createProjectsRegistry()) {
+  return persistProject(readWorkingDirFromUnit(filePath, platform), registry);
+}
 function formatCommand([bin, args]) {
   return [bin, ...args].join(" ");
 }
@@ -8379,10 +8495,10 @@ function printRunResult(result) {
     console.error(err);
 }
 function systemdUnitPath(serviceName) {
-  return join5(homedir(), ".config", "systemd", "user", `${serviceName}.service`);
+  return join6(homedir2(), ".config", "systemd", "user", `${serviceName}.service`);
 }
 function launchdPlistPath(serviceName) {
-  return join5(homedir(), "Library", "LaunchAgents", `com.webmux.${serviceName}.plist`);
+  return join6(homedir2(), "Library", "LaunchAgents", `com.webmux.${serviceName}.plist`);
 }
 function serviceFilePath(config) {
   if (config.platform === "linux")
@@ -8393,16 +8509,15 @@ function generateSystemdUnit(config) {
   const extra = Object.keys(config.envVars).sort().map((key) => `Environment=${key}=${config.envVars[key]}`).join(`
 `);
   return `[Unit]
-Description=webmux dashboard \u2014 ${config.projectName}
+Description=webmux dashboard
 
 [Service]
 Type=simple
 ExecStart=${config.webmuxPath} serve --port ${config.port}
-WorkingDirectory=${config.projectDir}
+WorkingDirectory=${homedir2()}
 Restart=on-failure
 RestartSec=5
 Environment=PORT=${config.port}
-Environment=WEBMUX_PROJECT_DIR=${config.projectDir}
 Environment=PATH=${process.env.PATH}${extra ? `
 ` + extra : ""}
 
@@ -8414,7 +8529,7 @@ function escapePlistText(value) {
   return value.replace(/&/g, "&amp;").replace(/</g, "&lt;").replace(/>/g, "&gt;");
 }
 function generateLaunchdPlist(config) {
-  const logPath = join5(homedir(), "Library", "Logs", `webmux-${config.serviceName}.log`);
+  const logPath = join6(homedir2(), "Library", "Logs", `webmux-${config.serviceName}.log`);
   const extra = Object.keys(config.envVars).sort().map((key) => `    <key>${escapePlistText(key)}</key>
     <string>${escapePlistText(config.envVars[key])}</string>`).join(`
 `);
@@ -8432,7 +8547,7 @@ function generateLaunchdPlist(config) {
     <string>${config.port}</string>
   </array>
   <key>WorkingDirectory</key>
-  <string>${config.projectDir}</string>
+  <string>${homedir2()}</string>
   <key>RunAtLoad</key>
   <true/>
   <key>KeepAlive</key>
@@ -8448,8 +8563,6 @@ function generateLaunchdPlist(config) {
   <dict>
     <key>PORT</key>
     <string>${config.port}</string>
-    <key>WEBMUX_PROJECT_DIR</key>
-    <string>${config.projectDir}</string>
     <key>PATH</key>
     <string>${process.env.PATH}</string>${extra ? `
 ` + extra : ""}
@@ -8466,7 +8579,7 @@ function generateServiceFile(config) {
 function readWorkingDirFromUnit(filePath, platform) {
   let text;
   try {
-    text = readFileSync3(filePath, "utf8");
+    text = readFileSync4(filePath, "utf8");
   } catch {
     return null;
   }
@@ -8477,7 +8590,7 @@ function readWorkingDirFromUnit(filePath, platform) {
 function readPortFromUnit(filePath) {
   let text;
   try {
-    text = readFileSync3(filePath, "utf8");
+    text = readFileSync4(filePath, "utf8");
   } catch {
     return null;
   }
@@ -8491,7 +8604,7 @@ function unescapePlistText(value) {
 function readEnvVarsFromUnit(filePath, platform) {
   let text;
   try {
-    text = readFileSync3(filePath, "utf8");
+    text = readFileSync4(filePath, "utf8");
   } catch {
     return {};
   }
@@ -8520,19 +8633,13 @@ function parseInstalledServiceConfig(filePath, platform, webmuxPath) {
   const port = readPortFromUnit(filePath);
   if (port === null)
     return null;
-  const projectDir = readWorkingDirFromUnit(filePath, platform);
-  if (projectDir === null)
-    return null;
   const fileBase = basename3(filePath);
   const serviceName = platform === "linux" ? fileBase.replace(/\.service$/, "") : fileBase.replace(/^com\.webmux\./, "").replace(/\.plist$/, "");
-  const projectName = detectProjectName(projectDir);
   const envVars = readEnvVarsFromUnit(filePath, platform);
   return {
     platform,
-    projectName,
     serviceName,
     webmuxPath,
-    projectDir,
     port,
     envVars
   };
@@ -8627,19 +8734,19 @@ function redactSecretsInUnit(content, envVars) {
   }
   return out;
 }
-async function install(config, portExplicit, envVarNotes) {
+function isInteractive() {
+  return Boolean(process.stdin.isTTY);
+}
+function resolveConfirmDecision(autoConfirm, interactive) {
+  if (autoConfirm)
+    return "proceed";
+  if (!interactive)
+    return "abort-noninteractive";
+  return "prompt";
+}
+async function install(config, portExplicit, envVarNotes, autoConfirm) {
   const filePath = serviceFilePath(config);
   const alreadyInstalled = isInstalled(config);
-  if (alreadyInstalled) {
-    const reinstall = await confirm({ message: "Service is already installed. Reinstall?" });
-    if (isCancel(reinstall) || !reinstall) {
-      log.info("Aborted.");
-      return;
-    }
-    for (const cmd of uninstallCommands(config)) {
-      runCommand(cmd);
-    }
-  }
   const requestedPort = config.port;
   let chosenPort = requestedPort;
   let portNote = null;
@@ -8653,14 +8760,17 @@ async function install(config, portExplicit, envVarNotes) {
   config = { ...config, port: chosenPort };
   const content = generateServiceFile(config);
   const commands = installCommands(config);
+  const persistPath = cwdProjectToPersist();
   const displayContent = redactSecretsInUnit(content, config.envVars);
   note([
+    ...alreadyInstalled ? ["Service is already installed \u2014 this will reinstall it.", ""] : [],
     `File: ${filePath}`,
     "",
     "Contents:",
     displayContent,
     "Commands to run:",
-    ...commands.map((c4) => `  $ ${formatCommand(c4)}`)
+    ...commands.map((c4) => `  $ ${formatCommand(c4)}`),
+    ...persistPath ? ["", `Will also register this project: ${persistPath}`] : []
   ].join(`
 `), "Install service");
   if (Object.keys(config.envVars).length > 0) {
@@ -8670,12 +8780,28 @@ ${envVarNotes.join(`
   }
   if (portNote)
     log.info(portNote);
-  const ok = await confirm({ message: "Proceed?" });
-  if (isCancel(ok) || !ok) {
-    log.info("Aborted.");
+  const decision = resolveConfirmDecision(autoConfirm, isInteractive());
+  if (decision === "abort-noninteractive") {
+    log.info(`Non-interactive environment \u2014 not ${alreadyInstalled ? "reinstalling" : "installing"}. ` + "Re-run with --yes to confirm and apply the plan above.");
     return;
   }
-  mkdirSync(filePath.substring(0, filePath.lastIndexOf("/")), { recursive: true });
+  if (decision === "prompt") {
+    const ok = await confirm({ message: alreadyInstalled ? "Reinstall?" : "Proceed?" });
+    if (isCancel(ok) || !ok) {
+      log.info("Aborted.");
+      return;
+    }
+  }
+  if (alreadyInstalled) {
+    const migrated = migrateServedRepoFromUnit(filePath, config.platform);
+    if (migrated) {
+      log.success(`Migrated previously-served project ${detectProjectName(migrated)} (${migrated})`);
+    }
+    for (const cmd of uninstallCommands(config)) {
+      runCommand(cmd);
+    }
+  }
+  mkdirSync2(filePath.substring(0, filePath.lastIndexOf("/")), { recursive: true });
   await Bun.write(filePath, content);
   if (Object.keys(config.envVars).length > 0) {
     try {
@@ -8685,6 +8811,14 @@ ${envVarNotes.join(`
     }
   }
   log.success(`Wrote ${filePath}`);
+  if (persistPath) {
+    createProjectsRegistry().add({
+      path: persistPath,
+      name: detectProjectName(persistPath),
+      addedAt: Date.now()
+    });
+    log.success(`Registered project ${detectProjectName(persistPath)} (${persistPath})`);
+  }
   for (const cmd of commands) {
     const result = runCommand(cmd);
     if (!result.success) {
@@ -8756,7 +8890,7 @@ function logs(config) {
   if (config.platform === "linux") {
     proc = Bun.spawn(["journalctl", "--user", "-u", config.serviceName, "-f", "--no-pager"], { stdout: "inherit", stderr: "inherit" });
   } else {
-    const logPath = join5(homedir(), "Library", "Logs", `webmux-${config.serviceName}.log`);
+    const logPath = join6(homedir2(), "Library", "Logs", `webmux-${config.serviceName}.log`);
     if (!existsSync4(logPath)) {
       log.error(`Log file not found: ${logPath}`);
       return;
@@ -8785,6 +8919,9 @@ Usage:
 Options:
   --port N                   Pin the service to a port (default: 5111). On
                              reinstall without --port the existing port is kept.
+  --yes, -y                  Skip the confirmation prompt and install. In a
+                             non-interactive shell (CI, pipe) install prints the
+                             plan and stops unless --yes is passed.
   --env KEY=VALUE            Bake an environment variable into the service
                              unit (repeatable). Reserved keys PORT,
                              WEBMUX_PROJECT_DIR, and PATH are rejected.
@@ -8813,11 +8950,6 @@ async function service(args) {
     log.error(`Unsupported platform: ${process.platform}. Only linux and macOS are supported.`);
     return;
   }
-  const gitRoot2 = getGitRoot();
-  if (!gitRoot2) {
-    log.error("Not inside a git repository.");
-    return;
-  }
   const serviceManager = platform === "linux" ? "systemctl" : "launchctl";
   const smResult = run("which", [serviceManager]);
   if (!smResult.success) {
@@ -8832,6 +8964,7 @@ async function service(args) {
   let port = parseInt(process.env.PORT || "5111");
   let portExplicit = false;
   let autoPickup = true;
+  let autoConfirm = false;
   for (let i2 = 1;i2 < args.length; i2++) {
     if (args[i2] === "--port" && args[i2 + 1]) {
       const parsed = parseInt(args[++i2]);
@@ -8843,6 +8976,8 @@ async function service(args) {
       portExplicit = true;
     } else if (args[i2] === "--no-auto-env") {
       autoPickup = false;
+    } else if (args[i2] === "--yes" || args[i2] === "-y") {
+      autoConfirm = true;
     }
   }
   const cliEnv = parseEnvCliArgs(args.slice(1));
@@ -8851,7 +8986,6 @@ async function service(args) {
       log.error(err);
     return;
   }
-  const projectName = detectProjectName(gitRoot2);
   const serviceName = "webmux";
   let envVars = {};
   let envVarNotes = [];
@@ -8868,16 +9002,14 @@ async function service(args) {
   }
   const config = {
     platform,
-    projectName,
     serviceName,
     webmuxPath,
-    projectDir: gitRoot2,
     port,
     envVars
   };
   switch (action) {
     case "install":
-      await install(config, portExplicit, envVarNotes);
+      await install(config, portExplicit, envVarNotes, autoConfirm);
       break;
     case "uninstall":
       await uninstall(config);
@@ -8898,6 +9030,7 @@ var AUTO_PICKUP_ENV_VARS, RESERVED_ENV_KEYS, SYSTEMD_WORKDIR_RE, LAUNCHD_WORKDIR
 var init_service = __esm(() => {
   init_dist4();
   init_shared();
+  init_projects_registry();
   AUTO_PICKUP_ENV_VARS = ["LINEAR_API_KEY"];
   RESERVED_ENV_KEYS = new Set(["PORT", "WEBMUX_PROJECT_DIR", "PATH"]);
   SYSTEMD_WORKDIR_RE = /^WorkingDirectory=(.+)$/m;
@@ -8917,9 +9050,9 @@ __export(exports_service_restart, {
   restartCommand: () => restartCommand,
   listInstalledServices: () => listInstalledServices
 });
-import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync4 } from "fs";
-import { homedir as homedir2 } from "os";
-import { join as join6 } from "path";
+import { existsSync as existsSync5, readdirSync as readdirSync2, readFileSync as readFileSync5 } from "fs";
+import { homedir as homedir3 } from "os";
+import { join as join7 } from "path";
 function listInstalledServices(opts = {}) {
   const out = [];
   const systemdDir = opts.systemdDir ?? DEFAULT_SYSTEMD_DIR;
@@ -8931,7 +9064,7 @@ function listInstalledServices(opts = {}) {
           continue;
         out.push({
           name: name.slice(0, -".service".length),
-          filePath: join6(systemdDir, name),
+          filePath: join7(systemdDir, name),
           platform: "linux"
         });
       }
@@ -8944,7 +9077,7 @@ function listInstalledServices(opts = {}) {
           continue;
         out.push({
           name: name.slice(0, -".plist".length),
-          filePath: join6(launchdDir, name),
+          filePath: join7(launchdDir, name),
           platform: "darwin"
         });
       }
@@ -8987,17 +9120,19 @@ function reloadAfterRegenerate(service2, runner) {
   service is now unloaded \u2014 recover with: launchctl load -w "${service2.filePath}"`
   };
 }
-async function updateInstalledService(service2, webmuxPath, runner = defaultRunner) {
+async function updateInstalledService(service2, webmuxPath, runner = defaultRunner, migrate = migrateServedRepoFromUnit) {
   const canRegenerate = webmuxPath.length > 0;
   const config = canRegenerate ? parseInstalledServiceConfig(service2.filePath, service2.platform, webmuxPath) : null;
   let regenerated = false;
+  let migratedProject;
   if (config !== null) {
     let currentContent = "";
     try {
-      currentContent = readFileSync4(service2.filePath, "utf8");
+      currentContent = readFileSync5(service2.filePath, "utf8");
     } catch {}
     const expected = generateServiceFile(config);
     if (currentContent !== expected) {
+      migratedProject = migrate(service2.filePath, service2.platform) ?? undefined;
       try {
         await Bun.write(service2.filePath, expected);
         regenerated = true;
@@ -9006,6 +9141,7 @@ async function updateInstalledService(service2, webmuxPath, runner = defaultRunn
           service: service2,
           regenerated: false,
           restarted: false,
+          migratedProject,
           error: `could not rewrite ${service2.filePath}: ${String(err)}`
         };
       }
@@ -9014,16 +9150,17 @@ async function updateInstalledService(service2, webmuxPath, runner = defaultRunn
   if (regenerated) {
     const reload = reloadAfterRegenerate(service2, runner);
     if (!reload.ok) {
-      return { service: service2, regenerated, restarted: false, error: reload.error };
+      return { service: service2, regenerated, restarted: false, migratedProject, error: reload.error };
     }
     if (service2.platform === "darwin") {
-      return { service: service2, regenerated, restarted: true };
+      return { service: service2, regenerated, restarted: true, migratedProject };
     }
   }
   const outcome = restartInstalledService(service2, runner);
   return {
     service: service2,
     regenerated,
+    migratedProject,
     restarted: outcome.ok,
     error: outcome.error
   };
@@ -9033,40 +9170,16 @@ var init_service_restart = __esm(() => {
   init_shared();
   init_service();
   defaultRunner = { run };
-  DEFAULT_SYSTEMD_DIR = join6(homedir2(), ".config", "systemd", "user");
-  DEFAULT_LAUNCHD_DIR = join6(homedir2(), "Library", "LaunchAgents");
-});
-
-// backend/src/lib/log.ts
-function ts() {
-  return new Date().toISOString().slice(11, 23);
-}
-var DEBUG, log2;
-var init_log = __esm(() => {
-  DEBUG = Bun.env.WEBMUX_DEBUG === "1";
-  log2 = {
-    info(msg) {
-      console.log(`[${ts()}] ${msg}`);
-    },
-    debug(msg) {
-      if (DEBUG)
-        console.log(`[${ts()}] ${msg}`);
-    },
-    warn(msg) {
-      console.warn(`[${ts()}] ${msg}`);
-    },
-    error(msg, err) {
-      err !== undefined ? console.error(`[${ts()}] ${msg}`, err) : console.error(`[${ts()}] ${msg}`);
-    }
-  };
+  DEFAULT_SYSTEMD_DIR = join7(homedir3(), ".config", "systemd", "user");
+  DEFAULT_LAUNCHD_DIR = join7(homedir3(), "Library", "LaunchAgents");
 });
 
 // backend/src/adapters/instance-registry.ts
-import { mkdirSync as mkdirSync2, readdirSync as readdirSync3, readFileSync as readFileSync5, renameSync, unlinkSync as unlinkSync2, writeFileSync } from "fs";
-import { homedir as homedir3 } from "os";
-import { join as join7 } from "path";
+import { mkdirSync as mkdirSync3, readdirSync as readdirSync3, readFileSync as readFileSync6, renameSync as renameSync2, unlinkSync as unlinkSync2, writeFileSync as writeFileSync2 } from "fs";
+import { homedir as homedir4 } from "os";
+import { join as join8 } from "path";
 function defaultRegistryDir() {
-  return join7(homedir3(), ".webmux", "instances");
+  return join8(homedir4(), ".webmux", "instances");
 }
 function isAlive(pid) {
   try {
@@ -9084,14 +9197,14 @@ function isInstanceEntry(value) {
 }
 function createInstanceRegistry(dir = defaultRegistryDir()) {
   function ensureDir() {
-    mkdirSync2(dir, { recursive: true });
+    mkdirSync3(dir, { recursive: true });
   }
   function entryPath(port) {
-    return join7(dir, `${port}.json`);
+    return join8(dir, `${port}.json`);
   }
   function readEntry(filename) {
     try {
-      const raw = readFileSync5(join7(dir, filename), "utf8");
+      const raw = readFileSync6(join8(dir, filename), "utf8");
       const parsed = JSON.parse(raw);
       return isInstanceEntry(parsed) ? parsed : null;
     } catch {
@@ -9105,8 +9218,8 @@ function createInstanceRegistry(dir = defaultRegistryDir()) {
       const tmpPath = `${finalPath}.${process.pid}.${Date.now()}.tmp`;
       const text = `${JSON.stringify(entry, null, 2)}
 `;
-      writeFileSync(tmpPath, text);
-      renameSync(tmpPath, finalPath);
+      writeFileSync2(tmpPath, text);
+      renameSync2(tmpPath, finalPath);
     },
     deregister(port, expectedPid) {
       if (expectedPid !== undefined) {
@@ -9139,7 +9252,7 @@ function createInstanceRegistry(dir = defaultRegistryDir()) {
           continue;
         if (!isAlive(entry.pid)) {
           try {
-            unlinkSync2(join7(dir, filename));
+            unlinkSync2(join8(dir, filename));
           } catch {}
           continue;
         }
@@ -11322,7 +11435,7 @@ var WORKTREE_META_SCHEMA_VERSION = 1, WORKTREE_ARCHIVE_STATE_VERSION = 1, OPEN_S
 
 // backend/src/adapters/fs.ts
 import { mkdir } from "fs/promises";
-import { join as join8 } from "path";
+import { join as join9 } from "path";
 function stringifyAllocatedPorts(ports) {
   const entries = Object.entries(ports).map(([key, value]) => [key, String(value)]);
   return Object.fromEntries(entries);
@@ -11354,28 +11467,28 @@ function parseDotenv(content) {
 }
 async function loadDotenvLocal(worktreePath) {
   try {
-    const content = await Bun.file(join8(worktreePath, ".env.local")).text();
+    const content = await Bun.file(join9(worktreePath, ".env.local")).text();
     return parseDotenv(content);
   } catch {
     return {};
   }
 }
 function getWorktreeStoragePaths(gitDir) {
-  const webmuxDir = join8(gitDir, "webmux");
+  const webmuxDir = join9(gitDir, "webmux");
   return {
     gitDir,
     webmuxDir,
-    metaPath: join8(webmuxDir, "meta.json"),
-    runtimeEnvPath: join8(webmuxDir, "runtime.env"),
-    controlEnvPath: join8(webmuxDir, "control.env"),
-    prsPath: join8(webmuxDir, "prs.json")
+    metaPath: join9(webmuxDir, "meta.json"),
+    runtimeEnvPath: join9(webmuxDir, "runtime.env"),
+    controlEnvPath: join9(webmuxDir, "control.env"),
+    prsPath: join9(webmuxDir, "prs.json")
   };
 }
 function getProjectArchiveStatePath(gitDir) {
-  return join8(gitDir, "webmux", "archive.json");
+  return join9(gitDir, "webmux", "archive.json");
 }
 function getProjectOpenSessionsStatePath(gitDir) {
-  return join8(gitDir, "webmux", "open-sessions.json");
+  return join9(gitDir, "webmux", "open-sessions.json");
 }
 async function ensureWorktreeStorageDirs(gitDir) {
   const paths = getWorktreeStoragePaths(gitDir);
@@ -18783,8 +18896,8 @@ var init_dist5 = __esm(() => {
 });
 
 // backend/src/adapters/config.ts
-import { readFileSync as readFileSync6 } from "fs";
-import { dirname as dirname3, join as join9, resolve as resolve7 } from "path";
+import { readFileSync as readFileSync7 } from "fs";
+import { dirname as dirname4, join as join10, resolve as resolve7 } from "path";
 function DEFAULT_ONESHOT_SYSTEM_PROMPT() {
   return [
     "You are running in webmux ONESHOT mode. There is NO interactive user \u2014 nobody is watching the chat or will respond to questions, approvals, or status checks. Any message asking the user to review, approve, confirm, take a look, or 'let you know' is wasted output: it will not be answered.",
@@ -19013,10 +19126,10 @@ function getDefaultProfileName(config) {
   return Object.keys(config.profiles)[0] ?? "default";
 }
 function readConfigFile(root) {
-  return readFileSync6(join9(root, ".webmux.yaml"), "utf8");
+  return readFileSync7(join10(root, ".webmux.yaml"), "utf8");
 }
 function readLocalConfigFile(root) {
-  return readFileSync6(join9(root, ".webmux.local.yaml"), "utf8");
+  return readFileSync7(join10(root, ".webmux.local.yaml"), "utf8");
 }
 function parseConfigDocument(text) {
   const parsed = $parse(text);
@@ -19164,7 +19277,7 @@ function projectRoot(dir) {
   if (result.exitCode !== 0)
     return gitRoot2(dir);
   const commonDir = new TextDecoder().decode(result.stdout).trim();
-  return commonDir ? dirname3(resolve7(dir, commonDir)) : gitRoot2(dir);
+  return commonDir ? dirname4(resolve7(dir, commonDir)) : gitRoot2(dir);
 }
 function loadConfig(dir, options = {}) {
   const root = options.resolvedRoot ? dir : projectRoot(dir);
@@ -19243,7 +19356,7 @@ var init_config = __esm(() => {
 
 // backend/src/adapters/control-token.ts
 import { chmod, mkdir as mkdir2 } from "fs/promises";
-import { dirname as dirname4 } from "path";
+import { dirname as dirname5 } from "path";
 async function loadControlToken() {
   if (cachedToken)
     return cachedToken;
@@ -19253,7 +19366,7 @@ async function loadControlToken() {
     return cachedToken;
   }
   const controlToken = crypto.randomUUID();
-  await mkdir2(dirname4(CONTROL_TOKEN_PATH), { recursive: true });
+  await mkdir2(dirname5(CONTROL_TOKEN_PATH), { recursive: true });
   await Bun.write(CONTROL_TOKEN_PATH, controlToken);
   await chmod(CONTROL_TOKEN_PATH, 384);
   cachedToken = controlToken;
@@ -19521,7 +19634,7 @@ var init_docker = __esm(() => {
 });
 
 // backend/src/adapters/hooks.ts
-import { join as join10 } from "path";
+import { join as join11 } from "path";
 function buildErrorMessage(name, exitCode, stdout2, stderr) {
   const output = stderr.trim() || stdout2.trim();
   if (output) {
@@ -19546,7 +19659,7 @@ class BunLifecycleHookRunner {
     return this.direnvAvailable;
   }
   async buildCommand(cwd, command) {
-    if (this.checkDirenv() && await Bun.file(join10(cwd, ".envrc")).exists()) {
+    if (this.checkDirenv() && await Bun.file(join11(cwd, ".envrc")).exists()) {
       Bun.spawnSync(["direnv", "allow"], { cwd, stdout: "pipe", stderr: "pipe" });
       return ["direnv", "exec", cwd, "bash", "-c", command];
     }
@@ -19653,7 +19766,7 @@ var init_claude_cli = __esm(() => {
 
 // backend/src/adapters/session-discovery.ts
 import { readdir, stat as stat2 } from "fs/promises";
-import { basename as basename5, join as join11 } from "path";
+import { basename as basename5, join as join12 } from "path";
 function home() {
   const value = Bun.env.HOME;
   if (!value)
@@ -19664,10 +19777,10 @@ function newestFirst(sessions) {
   return sessions.sort((left, right) => right.mtimeMs - left.mtimeMs).map((entry) => entry.sessionId);
 }
 async function listClaudeSessionIds(cwd) {
-  const dir = join11(home(), ".claude", "projects", encodeClaudeProjectDir(cwd));
+  const dir = join12(home(), ".claude", "projects", encodeClaudeProjectDir(cwd));
   const names = await readdir(dir).catch(() => []);
   const stamped = await Promise.all(names.filter((name) => name.endsWith(".jsonl")).map(async (name) => {
-    const info = await stat2(join11(dir, name)).catch(() => null);
+    const info = await stat2(join12(dir, name)).catch(() => null);
     return info ? { sessionId: basename5(name, ".jsonl"), mtimeMs: info.mtimeMs } : null;
   }));
   return newestFirst(stamped.filter((entry) => entry !== null));
@@ -19689,14 +19802,14 @@ async function readCodexSessionCwdId(path) {
   }
 }
 async function listCodexSessionIds(cwd) {
-  const root = join11(home(), ".codex", "sessions");
+  const root = join12(home(), ".codex", "sessions");
   const relPaths = await readdir(root, { recursive: true }).catch(() => []);
   const rollouts = relPaths.filter((rel) => {
     const name = basename5(rel);
     return name.startsWith("rollout-") && name.endsWith(".jsonl");
   });
   const stamped = await Promise.all(rollouts.map(async (rel) => {
-    const path = join11(root, rel);
+    const path = join12(root, rel);
     const meta = await readCodexSessionCwdId(path);
     if (!meta || meta.cwd !== cwd)
       return null;
@@ -19886,7 +19999,7 @@ var init_archive_state_service = __esm(() => {
 
 // backend/src/adapters/agent-runtime.ts
 import { chmod as chmod2, mkdir as mkdir3 } from "fs/promises";
-import { dirname as dirname5, join as join12, resolve as resolve8 } from "path";
+import { dirname as dirname6, join as join13, resolve as resolve8 } from "path";
 function shellQuote(value) {
   return `'${value.replaceAll("'", "'\\''")}'`;
 }
@@ -20305,7 +20418,7 @@ async function mergeCodexHooksFile(hooksPath, hookSettings, agentCtlPath) {
 }
 async function resolveGitCommonDir(gitDir) {
   try {
-    const commonDir = (await Bun.file(join12(gitDir, "commondir")).text()).trim();
+    const commonDir = (await Bun.file(join13(gitDir, "commondir")).text()).trim();
     if (!commonDir)
       return gitDir;
     return commonDir.startsWith("/") ? commonDir : resolve8(gitDir, commonDir);
@@ -20315,7 +20428,7 @@ async function resolveGitCommonDir(gitDir) {
 }
 async function ensureGeneratedCodexHooksIgnored(gitDir) {
   const commonDir = await resolveGitCommonDir(gitDir);
-  const excludePath = join12(commonDir, "info", "exclude");
+  const excludePath = join13(commonDir, "info", "exclude");
   let existing = "";
   try {
     existing = await Bun.file(excludePath).text();
@@ -20325,7 +20438,7 @@ async function ensureGeneratedCodexHooksIgnored(gitDir) {
   const lines = existing.split(/\r?\n/).map((line) => line.trim());
   if (lines.includes(GENERATED_CODEX_HOOKS_EXCLUDE))
     return;
-  await mkdir3(dirname5(excludePath), { recursive: true });
+  await mkdir3(dirname6(excludePath), { recursive: true });
   const separator = existing.length > 0 && !existing.endsWith(`
 `) ? `
 ` : "";
@@ -20335,12 +20448,12 @@ async function ensureGeneratedCodexHooksIgnored(gitDir) {
 async function ensureAgentRuntimeArtifacts(input) {
   const storagePaths = getWorktreeStoragePaths(input.gitDir);
   const artifacts = {
-    agentCtlPath: join12(storagePaths.webmuxDir, "webmux-agentctl"),
-    claudeSettingsPath: join12(input.worktreePath, ".claude", "settings.local.json"),
-    codexHooksPath: join12(input.worktreePath, ".codex", "hooks.json")
+    agentCtlPath: join13(storagePaths.webmuxDir, "webmux-agentctl"),
+    claudeSettingsPath: join13(input.worktreePath, ".claude", "settings.local.json"),
+    codexHooksPath: join13(input.worktreePath, ".codex", "hooks.json")
   };
-  await mkdir3(dirname5(artifacts.claudeSettingsPath), { recursive: true });
-  await mkdir3(dirname5(artifacts.codexHooksPath), { recursive: true });
+  await mkdir3(dirname6(artifacts.claudeSettingsPath), { recursive: true });
+  await mkdir3(dirname6(artifacts.codexHooksPath), { recursive: true });
   await Bun.write(artifacts.agentCtlPath, buildAgentCtlScript());
   await chmod2(artifacts.agentCtlPath, 493);
   const hookSettings = buildClaudeHookSettings(artifacts);
@@ -20872,7 +20985,7 @@ var init_worktree_service = __esm(() => {
 // backend/src/services/lifecycle-service.ts
 import { randomUUID as randomUUID3 } from "crypto";
 import { mkdir as mkdir4 } from "fs/promises";
-import { dirname as dirname6, resolve as resolve10 } from "path";
+import { dirname as dirname7, resolve as resolve10 } from "path";
 function toErrorMessage2(error) {
   return error instanceof Error ? error.message : String(error);
 }
@@ -21792,7 +21905,7 @@ ${oneshotPrompt}` : oneshotPrompt ?? baseSystemPrompt;
         ...createProgressBase,
         phase: "creating_worktree"
       });
-      await mkdir4(dirname6(worktreePath), { recursive: true });
+      await mkdir4(dirname7(worktreePath), { recursive: true });
       initialized = await createManagedWorktree({
         repoRoot: this.deps.projectRoot,
         worktreePath,
@@ -23346,13 +23459,13 @@ var init_worktree_commands = __esm(() => {
 });
 
 // bin/src/webmux.ts
-import { resolve as resolve13, dirname as dirname7, join as join13 } from "path";
+import { resolve as resolve13, dirname as dirname8, join as join14 } from "path";
 import { existsSync as existsSync6 } from "fs";
 import { fileURLToPath } from "url";
 // package.json
 var package_default = {
   name: "webmux",
-  version: "0.40.0",
+  version: "0.41.0",
   description: "Web dashboard for workmux \u2014 browser UI with embedded terminals, PR monitoring, and CI integration",
   type: "module",
   repository: {
@@ -23409,7 +23522,7 @@ var package_default = {
 };
 
 // bin/src/webmux.ts
-var PKG_ROOT = resolve13(dirname7(fileURLToPath(import.meta.url)), "..");
+var PKG_ROOT = resolve13(dirname8(fileURLToPath(import.meta.url)), "..");
 function usage2() {
   console.log(`
 webmux \u2014 Dev dashboard for managing Git worktrees
@@ -23646,6 +23759,8 @@ Refreshing ${services.length} installed webmux service(s) to pick up the new ver
           const parts = [];
           if (outcome.regenerated)
             parts.push("regenerated unit");
+          if (outcome.migratedProject)
+            parts.push(`migrated served project ${outcome.migratedProject}`);
           if (outcome.restarted)
             parts.push("restarted");
           if (!outcome.regenerated && !outcome.restarted && !outcome.error)
@@ -23733,8 +23848,8 @@ Refreshing ${services.length} installed webmux service(s) to pick up the new ver
   }
   process.on("SIGINT", cleanup);
   process.on("SIGTERM", cleanup);
-  const backendEntry = join13(PKG_ROOT, "backend", "dist", "server.js");
-  const staticDir = join13(PKG_ROOT, "frontend", "dist");
+  const backendEntry = join14(PKG_ROOT, "backend", "dist", "server.js");
+  const staticDir = join14(PKG_ROOT, "frontend", "dist");
   if (!existsSync6(staticDir)) {
     console.error(`Error: frontend/dist/ not found. Run 'bun run build' first.`);
     process.exit(1);