episoda 0.2.50 → 0.2.52

package/dist/daemon/daemon-process.js

@@ -1563,15 +1563,15 @@ var require_git_executor = __commonJS({
           try {
             const { stdout: gitDir } = await execAsync2("git rev-parse --git-dir", { cwd, timeout: 5e3 });
             const gitDirPath = gitDir.trim();
-            const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+            const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
             const rebaseMergePath = `${gitDirPath}/rebase-merge`;
             const rebaseApplyPath = `${gitDirPath}/rebase-apply`;
             try {
-              await fs18.access(rebaseMergePath);
+              await fs17.access(rebaseMergePath);
               inRebase = true;
             } catch {
               try {
-                await fs18.access(rebaseApplyPath);
+                await fs17.access(rebaseApplyPath);
                 inRebase = true;
               } catch {
                 inRebase = false;
@@ -1625,9 +1625,9 @@ var require_git_executor = __commonJS({
               error: validation.error || "UNKNOWN_ERROR"
             };
           }
-          const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs18.access(command.path);
+            await fs17.access(command.path);
             return {
               success: false,
               error: "WORKTREE_EXISTS",
@@ -1681,9 +1681,9 @@ var require_git_executor = __commonJS({
        */
       async executeWorktreeRemove(command, cwd, options) {
         try {
-          const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
           try {
-            await fs18.access(command.path);
+            await fs17.access(command.path);
           } catch {
             return {
               success: false,
@@ -1718,7 +1718,7 @@ var require_git_executor = __commonJS({
           const result = await this.runGitCommand(args, cwd, options);
           if (result.success) {
             try {
-              await fs18.rm(command.path, { recursive: true, force: true });
+              await fs17.rm(command.path, { recursive: true, force: true });
             } catch {
             }
             return {
@@ -1852,10 +1852,10 @@ var require_git_executor = __commonJS({
        */
       async executeCloneBare(command, options) {
         try {
-          const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path19 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path18 = await Promise.resolve().then(() => __importStar(require("path")));
           try {
-            await fs18.access(command.path);
+            await fs17.access(command.path);
             return {
               success: false,
               error: "BRANCH_ALREADY_EXISTS",
@@ -1864,9 +1864,9 @@ var require_git_executor = __commonJS({
             };
           } catch {
           }
-          const parentDir = path19.dirname(command.path);
+          const parentDir = path18.dirname(command.path);
           try {
-            await fs18.mkdir(parentDir, { recursive: true });
+            await fs17.mkdir(parentDir, { recursive: true });
           } catch {
           }
           const { stdout, stderr } = await execAsync2(
@@ -1914,22 +1914,22 @@ var require_git_executor = __commonJS({
        */
       async executeProjectInfo(cwd, options) {
         try {
-          const fs18 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
-          const path19 = await Promise.resolve().then(() => __importStar(require("path")));
+          const fs17 = await Promise.resolve().then(() => __importStar(require("fs"))).then((m) => m.promises);
+          const path18 = await Promise.resolve().then(() => __importStar(require("path")));
           let currentPath = cwd;
           let projectPath = cwd;
           let bareRepoPath;
           for (let i = 0; i < 10; i++) {
-            const bareDir = path19.join(currentPath, ".bare");
-            const episodaDir = path19.join(currentPath, ".episoda");
+            const bareDir = path18.join(currentPath, ".bare");
+            const episodaDir = path18.join(currentPath, ".episoda");
             try {
-              await fs18.access(bareDir);
-              await fs18.access(episodaDir);
+              await fs17.access(bareDir);
+              await fs17.access(episodaDir);
               projectPath = currentPath;
               bareRepoPath = bareDir;
               break;
             } catch {
-              const parentPath = path19.dirname(currentPath);
+              const parentPath = path18.dirname(currentPath);
               if (parentPath === currentPath) {
                 break;
               }
@@ -2533,36 +2533,36 @@ var require_auth = __commonJS({
       };
     })();
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.getConfigDir = getConfigDir7;
+    exports2.getConfigDir = getConfigDir8;
     exports2.getConfigPath = getConfigPath;
     exports2.loadConfig = loadConfig7;
     exports2.saveConfig = saveConfig2;
     exports2.validateToken = validateToken;
-    var fs18 = __importStar(require("fs"));
-    var path19 = __importStar(require("path"));
+    var fs17 = __importStar(require("fs"));
+    var path18 = __importStar(require("path"));
     var os7 = __importStar(require("os"));
     var child_process_1 = require("child_process");
     var DEFAULT_CONFIG_FILE = "config.json";
-    function getConfigDir7() {
-      return process.env.EPISODA_CONFIG_DIR || path19.join(os7.homedir(), ".episoda");
+    function getConfigDir8() {
+      return process.env.EPISODA_CONFIG_DIR || path18.join(os7.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path19.join(getConfigDir7(), DEFAULT_CONFIG_FILE);
+      return path18.join(getConfigDir8(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
-      const dir = path19.dirname(configPath);
-      const isNew = !fs18.existsSync(dir);
+      const dir = path18.dirname(configPath);
+      const isNew = !fs17.existsSync(dir);
       if (isNew) {
-        fs18.mkdirSync(dir, { recursive: true, mode: 448 });
+        fs17.mkdirSync(dir, { recursive: true, mode: 448 });
       }
       if (process.platform === "darwin") {
-        const nosyncPath = path19.join(dir, ".nosync");
-        if (isNew || !fs18.existsSync(nosyncPath)) {
+        const nosyncPath = path18.join(dir, ".nosync");
+        if (isNew || !fs17.existsSync(nosyncPath)) {
           try {
-            fs18.writeFileSync(nosyncPath, "", { mode: 384 });
+            fs17.writeFileSync(nosyncPath, "", { mode: 384 });
             (0, child_process_1.execSync)(`xattr -w com.apple.fileprovider.ignore 1 "${dir}"`, {
               stdio: "ignore",
               timeout: 5e3
@@ -2574,9 +2574,9 @@ var require_auth = __commonJS({
     }
     async function loadConfig7(configPath) {
       const fullPath = getConfigPath(configPath);
-      if (fs18.existsSync(fullPath)) {
+      if (fs17.existsSync(fullPath)) {
         try {
-          const content = fs18.readFileSync(fullPath, "utf8");
+          const content = fs17.readFileSync(fullPath, "utf8");
           const config = JSON.parse(content);
           return config;
         } catch (error) {
@@ -2601,7 +2601,7 @@ var require_auth = __commonJS({
       ensureConfigDir(fullPath);
       try {
         const content = JSON.stringify(config, null, 2);
-        fs18.writeFileSync(fullPath, content, { mode: 384 });
+        fs17.writeFileSync(fullPath, content, { mode: 384 });
       } catch (error) {
         throw new Error(`Failed to save config: ${error instanceof Error ? error.message : String(error)}`);
       }
@@ -2718,7 +2718,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "episoda",
-      version: "0.2.50",
+      version: "0.2.52",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -3095,11 +3095,16 @@ var IPCServer = class {
 };
 
 // src/daemon/daemon-process.ts
-var import_core11 = __toESM(require_dist());
+var import_core12 = __toESM(require_dist());
 
 // src/utils/update-checker.ts
 var import_child_process2 = require("child_process");
 var semver = __toESM(require("semver"));
+
+// src/ipc/ipc-client.ts
+var import_core5 = __toESM(require_dist());
+
+// src/utils/update-checker.ts
 var PACKAGE_NAME = "episoda";
 var NPM_REGISTRY = "https://registry.npmjs.org";
 async function checkForUpdates(currentVersion) {
@@ -3758,12 +3763,12 @@ async function handleExec(command, projectPath) {
 // src/daemon/handlers/stale-commit-cleanup.ts
 var import_child_process4 = require("child_process");
 var import_util = require("util");
-var import_core5 = __toESM(require_dist());
+var import_core6 = __toESM(require_dist());
 var execAsync = (0, import_util.promisify)(import_child_process4.exec);
 async function cleanupStaleCommits(projectPath) {
   try {
     const machineId = await getMachineId();
-    const config = await (0, import_core5.loadConfig)();
+    const config = await (0, import_core6.loadConfig)();
     if (!config?.access_token) {
       return {
         success: false,
@@ -4013,14 +4018,16 @@ var path7 = __toESM(require("path"));
 var os2 = __toESM(require("os"));
 
 // src/tunnel/tunnel-api.ts
-var import_core6 = __toESM(require_dist());
+var import_core7 = __toESM(require_dist());
 async function provisionNamedTunnel(moduleId, port = 3e3) {
-  const config = await (0, import_core6.loadConfig)();
+  console.log(`[TunnelAPI] EP1038: provisionNamedTunnel called for moduleId ${moduleId} with port ${port}`);
+  const config = await (0, import_core7.loadConfig)();
   if (!config?.access_token) {
     return { success: false, error: "Not authenticated" };
   }
   try {
     const apiUrl = config.api_url || "https://episoda.dev";
+    console.log(`[TunnelAPI] EP1038: POSTing to ${apiUrl}/api/tunnels with port=${port}`);
     const response = await fetch(`${apiUrl}/api/tunnels`, {
       method: "POST",
       headers: {
@@ -4050,7 +4057,8 @@ async function provisionNamedTunnel(moduleId, port = 3e3) {
   }
 }
 async function provisionNamedTunnelByUid(moduleUid, port = 3e3) {
-  const config = await (0, import_core6.loadConfig)();
+  console.log(`[TunnelAPI] EP1038: provisionNamedTunnelByUid called for ${moduleUid} with port ${port}`);
+  const config = await (0, import_core7.loadConfig)();
   if (!config?.access_token) {
     return { success: false, error: "Not authenticated" };
   }
@@ -4087,7 +4095,7 @@ async function updateTunnelStatus(moduleUid, status, error) {
   if (!moduleUid || moduleUid === "LOCAL") {
     return;
   }
-  const config = await (0, import_core6.loadConfig)();
+  const config = await (0, import_core7.loadConfig)();
   if (!config?.access_token) {
     return;
   }
@@ -4112,7 +4120,7 @@ async function clearTunnelUrl(moduleUid) {
   if (!moduleUid || moduleUid === "LOCAL") {
     return;
   }
-  const config = await (0, import_core6.loadConfig)();
+  const config = await (0, import_core7.loadConfig)();
   if (!config?.access_token) {
     return;
   }
@@ -5269,7 +5277,7 @@ var http = __toESM(require("http"));
 var fs11 = __toESM(require("fs"));
 var path12 = __toESM(require("path"));
 var import_events2 = require("events");
-var import_core7 = __toESM(require_dist());
+var import_core8 = __toESM(require_dist());
 
 // src/utils/port-check.ts
 var net2 = __toESM(require("net"));
@@ -5636,7 +5644,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
   // ============ Private Methods ============
   async fetchEnvVars(projectPath) {
     try {
-      const config = await (0, import_core7.loadConfig)();
+      const config = await (0, import_core8.loadConfig)();
       if (!config?.access_token || !config?.project_id) {
         return {};
       }
@@ -5796,7 +5804,7 @@ var DevServerRunner = class extends import_events2.EventEmitter {
     return new Promise((resolve3) => setTimeout(resolve3, ms));
   }
   getLogsDir() {
-    const logsDir = path12.join((0, import_core7.getConfigDir)(), "logs");
+    const logsDir = path12.join((0, import_core8.getConfigDir)(), "logs");
     if (!fs11.existsSync(logsDir)) {
       fs11.mkdirSync(logsDir, { recursive: true });
     }
@@ -5852,6 +5860,48 @@ function getDevServerRunner() {
   return instance2;
 }
 
+// src/utils/port-allocator.ts
+var PORT_RANGE_START = 3100;
+var PORT_RANGE_END = 3199;
+var PORT_WARNING_THRESHOLD = 80;
+var portAssignments = /* @__PURE__ */ new Map();
+function allocatePort(moduleUid) {
+  const existing = portAssignments.get(moduleUid);
+  if (existing) {
+    return existing;
+  }
+  const usedPorts = new Set(portAssignments.values());
+  if (usedPorts.size >= PORT_WARNING_THRESHOLD) {
+    console.warn(
+      `[PortAllocator] Warning: ${usedPorts.size}/${PORT_RANGE_END - PORT_RANGE_START + 1} ports allocated`
+    );
+  }
+  for (let port = PORT_RANGE_START; port <= PORT_RANGE_END; port++) {
+    if (!usedPorts.has(port)) {
+      portAssignments.set(moduleUid, port);
+      console.log(`[PortAllocator] Assigned port ${port} to ${moduleUid}`);
+      return port;
+    }
+  }
+  throw new Error(
+    `No available ports in range ${PORT_RANGE_START}-${PORT_RANGE_END}. ${portAssignments.size} modules are using all available ports.`
+  );
+}
+function releasePort(moduleUid) {
+  const port = portAssignments.get(moduleUid);
+  if (port) {
+    portAssignments.delete(moduleUid);
+    console.log(`[PortAllocator] Released port ${port} from ${moduleUid}`);
+  }
+}
+function clearAllPorts() {
+  const count = portAssignments.size;
+  portAssignments.clear();
+  if (count > 0) {
+    console.log(`[PortAllocator] Cleared ${count} port assignments`);
+  }
+}
+
 // src/preview/preview-manager.ts
 var DEFAULT_PORT = 3e3;
 var PreviewManager = class extends import_events3.EventEmitter {
@@ -6064,6 +6114,7 @@ var PreviewManager = class extends import_events3.EventEmitter {
     } catch (error) {
       console.warn(`[PreviewManager] Error clearing tunnel URL for ${moduleUid}:`, error);
     }
+    releasePort(moduleUid);
     if (state) {
       state.state = "stopped";
       state.tunnelUrl = void 0;
@@ -6242,7 +6293,7 @@ function getPreviewManager() {
 
 // src/utils/dev-server.ts
 var import_child_process10 = require("child_process");
-var import_core8 = __toESM(require_dist());
+var import_core9 = __toESM(require_dist());
 var fs12 = __toESM(require("fs"));
 var path13 = __toESM(require("path"));
 var MAX_RESTART_ATTEMPTS = 5;
@@ -6252,7 +6303,7 @@ var MAX_LOG_SIZE_BYTES = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
-  const logsDir = path13.join((0, import_core8.getConfigDir)(), "logs");
+  const logsDir = path13.join((0, import_core9.getConfigDir)(), "logs");
   if (!fs12.existsSync(logsDir)) {
     fs12.mkdirSync(logsDir, { recursive: true });
   }
@@ -6453,7 +6504,7 @@ async function startDevServer(projectPath, port = 3e3, moduleUid = "default", op
   console.log(`[DevServer] EP932: Starting dev server for ${moduleUid} on port ${port} (auto-restart: ${autoRestart})...`);
   let injectedEnvVars = {};
   try {
-    const config = await (0, import_core8.loadConfig)();
+    const config = await (0, import_core9.loadConfig)();
     if (config?.access_token && config?.project_id) {
       const apiUrl = config.api_url || "https://episoda.dev";
       const result = await fetchEnvVarsWithCache(apiUrl, config.access_token, {
@@ -6569,81 +6620,10 @@ function getDevServerStatus() {
   }));
 }
 
-// src/utils/port-detect.ts
+// src/daemon/worktree-manager.ts
 var fs13 = __toESM(require("fs"));
 var path14 = __toESM(require("path"));
-var DEFAULT_PORT2 = 3e3;
-function detectDevPort(projectPath) {
-  const envPort = getPortFromEnv(projectPath);
-  if (envPort) {
-    console.log(`[PortDetect] Found PORT=${envPort} in .env`);
-    return envPort;
-  }
-  const scriptPort = getPortFromPackageJson(projectPath);
-  if (scriptPort) {
-    console.log(`[PortDetect] Found port ${scriptPort} in package.json dev script`);
-    return scriptPort;
-  }
-  console.log(`[PortDetect] Using default port ${DEFAULT_PORT2}`);
-  return DEFAULT_PORT2;
-}
-function getPortFromEnv(projectPath) {
-  const envPaths = [
-    path14.join(projectPath, ".env"),
-    path14.join(projectPath, ".env.local"),
-    path14.join(projectPath, ".env.development"),
-    path14.join(projectPath, ".env.development.local")
-  ];
-  for (const envPath of envPaths) {
-    try {
-      if (!fs13.existsSync(envPath)) continue;
-      const content = fs13.readFileSync(envPath, "utf-8");
-      const lines = content.split("\n");
-      for (const line of lines) {
-        const match = line.match(/^\s*PORT\s*=\s*["']?(\d+)["']?\s*(?:#.*)?$/);
-        if (match) {
-          const port = parseInt(match[1], 10);
-          if (port > 0 && port < 65536) {
-            return port;
-          }
-        }
-      }
-    } catch {
-    }
-  }
-  return null;
-}
-function getPortFromPackageJson(projectPath) {
-  const packageJsonPath = path14.join(projectPath, "package.json");
-  try {
-    if (!fs13.existsSync(packageJsonPath)) return null;
-    const content = fs13.readFileSync(packageJsonPath, "utf-8");
-    const pkg = JSON.parse(content);
-    const devScript = pkg.scripts?.dev;
-    if (!devScript) return null;
-    const portMatch = devScript.match(/(?:--port[=\s]|-p[=\s])(\d+)/);
-    if (portMatch) {
-      const port = parseInt(portMatch[1], 10);
-      if (port > 0 && port < 65536) {
-        return port;
-      }
-    }
-    const envMatch = devScript.match(/PORT[=\s](\d+)/);
-    if (envMatch) {
-      const port = parseInt(envMatch[1], 10);
-      if (port > 0 && port < 65536) {
-        return port;
-      }
-    }
-  } catch {
-  }
-  return null;
-}
-
-// src/daemon/worktree-manager.ts
-var fs14 = __toESM(require("fs"));
-var path15 = __toESM(require("path"));
-var import_core9 = __toESM(require_dist());
+var import_core10 = __toESM(require_dist());
 function validateModuleUid(moduleUid) {
   if (!moduleUid || typeof moduleUid !== "string" || !moduleUid.trim()) {
     return false;
@@ -6666,9 +6646,9 @@ var WorktreeManager = class _WorktreeManager {
     // ============================================================
     this.lockPath = "";
     this.projectRoot = projectRoot;
-    this.bareRepoPath = path15.join(projectRoot, ".bare");
-    this.configPath = path15.join(projectRoot, ".episoda", "config.json");
-    this.gitExecutor = new import_core9.GitExecutor();
+    this.bareRepoPath = path14.join(projectRoot, ".bare");
+    this.configPath = path14.join(projectRoot, ".episoda", "config.json");
+    this.gitExecutor = new import_core10.GitExecutor();
   }
   /**
    * Initialize worktree manager from existing project root
@@ -6676,10 +6656,10 @@ var WorktreeManager = class _WorktreeManager {
    * @returns true if valid project, false otherwise
    */
   async initialize() {
-    if (!fs14.existsSync(this.bareRepoPath)) {
+    if (!fs13.existsSync(this.bareRepoPath)) {
       return false;
     }
-    if (!fs14.existsSync(this.configPath)) {
+    if (!fs13.existsSync(this.configPath)) {
       return false;
     }
     try {
@@ -6726,8 +6706,8 @@ var WorktreeManager = class _WorktreeManager {
    */
   static async createProject(projectRoot, repoUrl, projectId, workspaceSlug, projectSlug) {
     const manager = new _WorktreeManager(projectRoot);
-    const episodaDir = path15.join(projectRoot, ".episoda");
-    fs14.mkdirSync(episodaDir, { recursive: true });
+    const episodaDir = path14.join(projectRoot, ".episoda");
+    fs13.mkdirSync(episodaDir, { recursive: true });
     const cloneResult = await manager.gitExecutor.execute({
       action: "clone_bare",
       url: repoUrl,
@@ -6758,7 +6738,7 @@ var WorktreeManager = class _WorktreeManager {
         error: `Invalid module UID: "${moduleUid}" - contains disallowed characters`
       };
     }
-    const worktreePath = path15.join(this.projectRoot, moduleUid);
+    const worktreePath = path14.join(this.projectRoot, moduleUid);
     const lockAcquired = await this.acquireLock();
     if (!lockAcquired) {
       return {
@@ -6940,7 +6920,7 @@ var WorktreeManager = class _WorktreeManager {
     let prunedCount = 0;
     await this.updateConfigSafe((config) => {
       const initialCount = config.worktrees.length;
-      config.worktrees = config.worktrees.filter((w) => fs14.existsSync(w.worktreePath));
+      config.worktrees = config.worktrees.filter((w) => fs13.existsSync(w.worktreePath));
       prunedCount = initialCount - config.worktrees.length;
       return config;
     });
@@ -7021,16 +7001,16 @@ var WorktreeManager = class _WorktreeManager {
     const retryInterval = 50;
     while (Date.now() - startTime < timeoutMs) {
       try {
-        fs14.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
+        fs13.writeFileSync(lockPath, String(process.pid), { flag: "wx" });
         return true;
       } catch (err) {
         if (err.code === "EEXIST") {
           try {
-            const stats = fs14.statSync(lockPath);
+            const stats = fs13.statSync(lockPath);
             const lockAge = Date.now() - stats.mtimeMs;
             if (lockAge > 3e4) {
               try {
-                const lockContent = fs14.readFileSync(lockPath, "utf-8").trim();
+                const lockContent = fs13.readFileSync(lockPath, "utf-8").trim();
                 const lockPid = parseInt(lockContent, 10);
                 if (!isNaN(lockPid) && this.isProcessRunning(lockPid)) {
                   await new Promise((resolve3) => setTimeout(resolve3, retryInterval));
@@ -7039,7 +7019,7 @@ var WorktreeManager = class _WorktreeManager {
               } catch {
               }
               try {
-                fs14.unlinkSync(lockPath);
+                fs13.unlinkSync(lockPath);
               } catch {
               }
               continue;
@@ -7060,16 +7040,16 @@ var WorktreeManager = class _WorktreeManager {
    */
   releaseLock() {
     try {
-      fs14.unlinkSync(this.getLockPath());
+      fs13.unlinkSync(this.getLockPath());
     } catch {
     }
   }
   readConfig() {
     try {
-      if (!fs14.existsSync(this.configPath)) {
+      if (!fs13.existsSync(this.configPath)) {
         return null;
       }
-      const content = fs14.readFileSync(this.configPath, "utf-8");
+      const content = fs13.readFileSync(this.configPath, "utf-8");
       return JSON.parse(content);
     } catch (error) {
       console.error("[WorktreeManager] Failed to read config:", error);
@@ -7078,11 +7058,11 @@ var WorktreeManager = class _WorktreeManager {
   }
   writeConfig(config) {
     try {
-      const dir = path15.dirname(this.configPath);
-      if (!fs14.existsSync(dir)) {
-        fs14.mkdirSync(dir, { recursive: true });
+      const dir = path14.dirname(this.configPath);
+      if (!fs13.existsSync(dir)) {
+        fs13.mkdirSync(dir, { recursive: true });
       }
-      fs14.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
+      fs13.writeFileSync(this.configPath, JSON.stringify(config, null, 2), "utf-8");
     } catch (error) {
       console.error("[WorktreeManager] Failed to write config:", error);
       throw error;
@@ -7163,14 +7143,14 @@ var WorktreeManager = class _WorktreeManager {
     }
     try {
       for (const file of files) {
-        const srcPath = path15.join(mainWorktree.worktreePath, file);
-        const destPath = path15.join(worktree.worktreePath, file);
-        if (fs14.existsSync(srcPath)) {
-          const destDir = path15.dirname(destPath);
-          if (!fs14.existsSync(destDir)) {
-            fs14.mkdirSync(destDir, { recursive: true });
-          }
-          fs14.copyFileSync(srcPath, destPath);
+        const srcPath = path14.join(mainWorktree.worktreePath, file);
+        const destPath = path14.join(worktree.worktreePath, file);
+        if (fs13.existsSync(srcPath)) {
+          const destDir = path14.dirname(destPath);
+          if (!fs13.existsSync(destDir)) {
+            fs13.mkdirSync(destDir, { recursive: true });
+          }
+          fs13.copyFileSync(srcPath, destPath);
           console.log(`[WorktreeManager] EP964: Copied ${file} to ${moduleUid} (deprecated)`);
         } else {
           console.log(`[WorktreeManager] EP964: Skipped ${file} (not found in main)`);
@@ -7253,27 +7233,27 @@ var WorktreeManager = class _WorktreeManager {
   }
 };
 function getEpisodaRoot() {
-  return process.env.EPISODA_ROOT || path15.join(require("os").homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path14.join(require("os").homedir(), "episoda");
 }
 async function isWorktreeProject(projectRoot) {
   const manager = new WorktreeManager(projectRoot);
   return manager.initialize();
 }
 async function findProjectRoot(startPath) {
-  let current = path15.resolve(startPath);
+  let current = path14.resolve(startPath);
   const episodaRoot = getEpisodaRoot();
   if (!current.startsWith(episodaRoot)) {
     return null;
   }
   for (let i = 0; i < 10; i++) {
-    const bareDir = path15.join(current, ".bare");
-    const episodaDir = path15.join(current, ".episoda");
-    if (fs14.existsSync(bareDir) && fs14.existsSync(episodaDir)) {
+    const bareDir = path14.join(current, ".bare");
+    const episodaDir = path14.join(current, ".episoda");
+    if (fs13.existsSync(bareDir) && fs13.existsSync(episodaDir)) {
       if (await isWorktreeProject(current)) {
         return current;
       }
     }
-    const parent = path15.dirname(current);
+    const parent = path14.dirname(current);
     if (parent === current) {
       break;
     }
@@ -7283,24 +7263,24 @@ async function findProjectRoot(startPath) {
 }
 
 // src/utils/worktree.ts
-var path16 = __toESM(require("path"));
-var fs15 = __toESM(require("fs"));
+var path15 = __toESM(require("path"));
+var fs14 = __toESM(require("fs"));
 var os5 = __toESM(require("os"));
-var import_core10 = __toESM(require_dist());
+var import_core11 = __toESM(require_dist());
 function getEpisodaRoot2() {
-  return process.env.EPISODA_ROOT || path16.join(os5.homedir(), "episoda");
+  return process.env.EPISODA_ROOT || path15.join(os5.homedir(), "episoda");
 }
 function getWorktreeInfo(moduleUid, workspaceSlug, projectSlug) {
   const root = getEpisodaRoot2();
-  const worktreePath = path16.join(root, workspaceSlug, projectSlug, moduleUid);
+  const worktreePath = path15.join(root, workspaceSlug, projectSlug, moduleUid);
   return {
     path: worktreePath,
-    exists: fs15.existsSync(worktreePath),
+    exists: fs14.existsSync(worktreePath),
     moduleUid
   };
 }
 async function getWorktreeInfoForModule(moduleUid) {
-  const config = await (0, import_core10.loadConfig)();
+  const config = await (0, import_core11.loadConfig)();
   if (!config?.workspace_slug || !config?.project_slug) {
     console.warn("[Worktree] Missing workspace_slug or project_slug in config");
     return null;
@@ -7308,72 +7288,62 @@ async function getWorktreeInfoForModule(moduleUid) {
   return getWorktreeInfo(moduleUid, config.workspace_slug, config.project_slug);
 }
 
-// src/utils/port-allocator.ts
-var portAssignments = /* @__PURE__ */ new Map();
-function clearAllPorts() {
-  const count = portAssignments.size;
-  portAssignments.clear();
-  if (count > 0) {
-    console.log(`[PortAllocator] Cleared ${count} port assignments`);
-  }
-}
-
 // src/framework-detector.ts
-var fs16 = __toESM(require("fs"));
-var path17 = __toESM(require("path"));
+var fs15 = __toESM(require("fs"));
+var path16 = __toESM(require("path"));
 function getInstallCommand(cwd) {
-  if (fs16.existsSync(path17.join(cwd, "bun.lockb"))) {
+  if (fs15.existsSync(path16.join(cwd, "bun.lockb"))) {
     return {
       command: ["bun", "install"],
       description: "Installing dependencies with bun",
       detectedFrom: "bun.lockb"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "pnpm-lock.yaml"))) {
+  if (fs15.existsSync(path16.join(cwd, "pnpm-lock.yaml"))) {
     return {
       command: ["pnpm", "install"],
       description: "Installing dependencies with pnpm",
       detectedFrom: "pnpm-lock.yaml"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "yarn.lock"))) {
+  if (fs15.existsSync(path16.join(cwd, "yarn.lock"))) {
     return {
       command: ["yarn", "install"],
       description: "Installing dependencies with yarn",
       detectedFrom: "yarn.lock"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "package-lock.json"))) {
+  if (fs15.existsSync(path16.join(cwd, "package-lock.json"))) {
     return {
       command: ["npm", "ci"],
       description: "Installing dependencies with npm ci",
       detectedFrom: "package-lock.json"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "package.json"))) {
+  if (fs15.existsSync(path16.join(cwd, "package.json"))) {
     return {
       command: ["npm", "install"],
       description: "Installing dependencies with npm",
       detectedFrom: "package.json"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "Pipfile.lock")) || fs16.existsSync(path17.join(cwd, "Pipfile"))) {
+  if (fs15.existsSync(path16.join(cwd, "Pipfile.lock")) || fs15.existsSync(path16.join(cwd, "Pipfile"))) {
     return {
       command: ["pipenv", "install"],
       description: "Installing dependencies with pipenv",
-      detectedFrom: fs16.existsSync(path17.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
+      detectedFrom: fs15.existsSync(path16.join(cwd, "Pipfile.lock")) ? "Pipfile.lock" : "Pipfile"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "poetry.lock"))) {
+  if (fs15.existsSync(path16.join(cwd, "poetry.lock"))) {
     return {
       command: ["poetry", "install"],
       description: "Installing dependencies with poetry",
       detectedFrom: "poetry.lock"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "pyproject.toml"))) {
-    const pyprojectPath = path17.join(cwd, "pyproject.toml");
-    const content = fs16.readFileSync(pyprojectPath, "utf-8");
+  if (fs15.existsSync(path16.join(cwd, "pyproject.toml"))) {
+    const pyprojectPath = path16.join(cwd, "pyproject.toml");
+    const content = fs15.readFileSync(pyprojectPath, "utf-8");
     if (content.includes("[tool.poetry]")) {
       return {
         command: ["poetry", "install"],
@@ -7382,41 +7352,41 @@ function getInstallCommand(cwd) {
       };
     }
   }
-  if (fs16.existsSync(path17.join(cwd, "requirements.txt"))) {
+  if (fs15.existsSync(path16.join(cwd, "requirements.txt"))) {
     return {
       command: ["pip", "install", "-r", "requirements.txt"],
       description: "Installing dependencies with pip",
       detectedFrom: "requirements.txt"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "Gemfile.lock")) || fs16.existsSync(path17.join(cwd, "Gemfile"))) {
+  if (fs15.existsSync(path16.join(cwd, "Gemfile.lock")) || fs15.existsSync(path16.join(cwd, "Gemfile"))) {
     return {
       command: ["bundle", "install"],
       description: "Installing dependencies with bundler",
-      detectedFrom: fs16.existsSync(path17.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
+      detectedFrom: fs15.existsSync(path16.join(cwd, "Gemfile.lock")) ? "Gemfile.lock" : "Gemfile"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "go.sum")) || fs16.existsSync(path17.join(cwd, "go.mod"))) {
+  if (fs15.existsSync(path16.join(cwd, "go.sum")) || fs15.existsSync(path16.join(cwd, "go.mod"))) {
     return {
       command: ["go", "mod", "download"],
       description: "Downloading Go modules",
-      detectedFrom: fs16.existsSync(path17.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
+      detectedFrom: fs15.existsSync(path16.join(cwd, "go.sum")) ? "go.sum" : "go.mod"
     };
   }
-  if (fs16.existsSync(path17.join(cwd, "Cargo.lock")) || fs16.existsSync(path17.join(cwd, "Cargo.toml"))) {
+  if (fs15.existsSync(path16.join(cwd, "Cargo.lock")) || fs15.existsSync(path16.join(cwd, "Cargo.toml"))) {
     return {
       command: ["cargo", "build"],
       description: "Building Rust project (downloads dependencies)",
-      detectedFrom: fs16.existsSync(path17.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
+      detectedFrom: fs15.existsSync(path16.join(cwd, "Cargo.lock")) ? "Cargo.lock" : "Cargo.toml"
     };
   }
   return null;
 }
 
 // src/daemon/daemon-process.ts
-var fs17 = __toESM(require("fs"));
+var fs16 = __toESM(require("fs"));
 var os6 = __toESM(require("os"));
-var path18 = __toESM(require("path"));
+var path17 = __toESM(require("path"));
 var packageJson = require_package();
 async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
   const now = Date.now();
@@ -7451,7 +7421,7 @@ async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
       refresh_token: tokenResponse.refresh_token || config.refresh_token,
       expires_at: now + tokenResponse.expires_in * 1e3
     };
-    await (0, import_core11.saveConfig)(updatedConfig);
+    await (0, import_core12.saveConfig)(updatedConfig);
     console.log("[Daemon] EP904: Access token refreshed successfully");
     return updatedConfig;
   } catch (error) {
@@ -7460,7 +7430,7 @@ async function ensureValidToken(config, bufferMs = 5 * 60 * 1e3) {
   }
 }
 async function fetchWithAuth(url, options = {}, retryOnUnauthorized = true) {
-  let config = await (0, import_core11.loadConfig)();
+  let config = await (0, import_core12.loadConfig)();
   if (!config?.access_token) {
     throw new Error("No access token configured");
   }
@@ -7487,7 +7457,7 @@ async function fetchWithAuth(url, options = {}, retryOnUnauthorized = true) {
 }
 async function fetchEnvVars2() {
   try {
-    const config = await (0, import_core11.loadConfig)();
+    const config = await (0, import_core12.loadConfig)();
     if (!config?.project_id) {
       console.warn("[Daemon] EP973: No project_id in config, cannot fetch env vars");
       return {};
@@ -7570,7 +7540,7 @@ var Daemon = class _Daemon {
     console.log("[Daemon] Starting Episoda daemon...");
     this.machineId = await getMachineId();
     console.log(`[Daemon] Machine ID: ${this.machineId}`);
-    const config = await (0, import_core11.loadConfig)();
+    const config = await (0, import_core12.loadConfig)();
     if (config?.device_id) {
       this.deviceId = config.device_id;
       console.log(`[Daemon] Loaded cached Device ID (UUID): ${this.deviceId}`);
@@ -7707,7 +7677,7 @@ var Daemon = class _Daemon {
       };
     });
     this.ipcServer.on("verify-server-connection", async () => {
-      const config = await (0, import_core11.loadConfig)();
+      const config = await (0, import_core12.loadConfig)();
       if (!config?.access_token || !config?.api_url) {
         return {
           verified: false,
@@ -7767,6 +7737,7 @@ var Daemon = class _Daemon {
       }
       await tunnelManager.stopTunnel(moduleUid);
       await stopDevServer(moduleUid);
+      releasePort(moduleUid);
       await clearTunnelUrl(moduleUid);
       this.tunnelHealthFailures.delete(moduleUid);
       console.log(`[Daemon] EP823: Tunnel stopped for ${moduleUid}`);
@@ -7880,7 +7851,7 @@ var Daemon = class _Daemon {
       console.warn(`[Daemon] Stale connection detected for ${projectPath}, forcing reconnection`);
       await this.disconnectProject(projectPath);
     }
-    const config = await (0, import_core11.loadConfig)();
+    const config = await (0, import_core12.loadConfig)();
     if (!config || !config.access_token) {
       throw new Error("No access token found. Please run: episoda auth");
     }
@@ -7901,8 +7872,8 @@ var Daemon = class _Daemon {
       wsUrl = `${wsProtocol}//${wsHostname}:${wsPort}`;
     }
     console.log(`[Daemon] Connecting to ${wsUrl} for project ${projectId}...`);
-    const client = new import_core11.EpisodaClient();
-    const gitExecutor = new import_core11.GitExecutor();
+    const client = new import_core12.EpisodaClient();
+    const gitExecutor = new import_core12.GitExecutor();
     const connection = {
       projectId,
       projectPath,
@@ -7917,7 +7888,7 @@ var Daemon = class _Daemon {
         client.updateActivity();
         try {
           const gitCmd = message.command;
-          const bareRepoPath = path18.join(projectPath, ".bare");
+          const bareRepoPath = path17.join(projectPath, ".bare");
           const cwd = gitCmd.worktreePath || bareRepoPath;
           if (gitCmd.worktreePath) {
             console.log(`[Daemon] Routing command to worktree: ${gitCmd.worktreePath}`);
@@ -8071,8 +8042,9 @@ var Daemon = class _Daemon {
               return;
             }
             console.log(`[Daemon] EP1024: Using worktree path ${worktree.path} for ${cmd.moduleUid}`);
-            const port = cmd.port || detectDevPort(worktree.path);
-            const devConfig = await (0, import_core11.loadConfig)();
+            const port = cmd.port || allocatePort(cmd.moduleUid);
+            console.log(`[Daemon] EP1038: Allocated port ${port} for ${cmd.moduleUid}`);
+            const devConfig = await (0, import_core12.loadConfig)();
             const customCommand = devConfig?.project_settings?.worktree_dev_server_script;
             const startResult = await previewManager.startPreview({
               moduleUid: cmd.moduleUid,
@@ -8332,8 +8304,8 @@ var Daemon = class _Daemon {
       let daemonPid;
       try {
         const pidPath = getPidFilePath();
-        if (fs17.existsSync(pidPath)) {
-          const pidStr = fs17.readFileSync(pidPath, "utf-8").trim();
+        if (fs16.existsSync(pidPath)) {
+          const pidStr = fs16.readFileSync(pidPath, "utf-8").trim();
           daemonPid = parseInt(pidStr, 10);
         }
       } catch (pidError) {
@@ -8454,27 +8426,27 @@ var Daemon = class _Daemon {
    */
   async installGitHooks(projectPath) {
     const hooks = ["post-checkout", "pre-commit", "post-commit"];
-    const hooksDir = path18.join(projectPath, ".git", "hooks");
-    if (!fs17.existsSync(hooksDir)) {
+    const hooksDir = path17.join(projectPath, ".git", "hooks");
+    if (!fs16.existsSync(hooksDir)) {
       console.warn(`[Daemon] Hooks directory not found: ${hooksDir}`);
       return;
     }
     for (const hookName of hooks) {
       try {
-        const hookPath = path18.join(hooksDir, hookName);
-        const bundledHookPath = path18.join(__dirname, "..", "hooks", hookName);
-        if (!fs17.existsSync(bundledHookPath)) {
+        const hookPath = path17.join(hooksDir, hookName);
+        const bundledHookPath = path17.join(__dirname, "..", "hooks", hookName);
+        if (!fs16.existsSync(bundledHookPath)) {
           console.warn(`[Daemon] Bundled hook not found: ${bundledHookPath}`);
           continue;
         }
-        const hookContent = fs17.readFileSync(bundledHookPath, "utf-8");
-        if (fs17.existsSync(hookPath)) {
-          const existingContent = fs17.readFileSync(hookPath, "utf-8");
+        const hookContent = fs16.readFileSync(bundledHookPath, "utf-8");
+        if (fs16.existsSync(hookPath)) {
+          const existingContent = fs16.readFileSync(hookPath, "utf-8");
           if (existingContent === hookContent) {
             continue;
           }
         }
-        fs17.writeFileSync(hookPath, hookContent, { mode: 493 });
+        fs16.writeFileSync(hookPath, hookContent, { mode: 493 });
         console.log(`[Daemon] Installed git hook: ${hookName}`);
       } catch (error) {
         console.warn(`[Daemon] Failed to install ${hookName} hook:`, error instanceof Error ? error.message : error);
@@ -8489,7 +8461,7 @@ var Daemon = class _Daemon {
    */
   async cacheDeviceId(deviceId) {
     try {
-      const config = await (0, import_core11.loadConfig)();
+      const config = await (0, import_core12.loadConfig)();
       if (!config) {
         console.warn("[Daemon] Cannot cache device ID - no config found");
         return;
@@ -8502,7 +8474,7 @@ var Daemon = class _Daemon {
         device_id: deviceId,
         machine_id: this.machineId
       };
-      await (0, import_core11.saveConfig)(updatedConfig);
+      await (0, import_core12.saveConfig)(updatedConfig);
       console.log(`[Daemon] Cached device ID to config: ${deviceId}`);
     } catch (error) {
       console.warn("[Daemon] Failed to cache device ID:", error instanceof Error ? error.message : error);
@@ -8516,7 +8488,7 @@ var Daemon = class _Daemon {
    */
   async syncProjectSettings(projectId) {
     try {
-      const config = await (0, import_core11.loadConfig)();
+      const config = await (0, import_core12.loadConfig)();
       if (!config) return;
       const apiUrl = config.api_url || "https://episoda.dev";
       const response = await fetchWithAuth(`${apiUrl}/api/projects/${projectId}/settings`);
@@ -8550,7 +8522,7 @@ var Daemon = class _Daemon {
             cached_at: Date.now()
           }
         };
-        await (0, import_core11.saveConfig)(updatedConfig);
+        await (0, import_core12.saveConfig)(updatedConfig);
         console.log(`[Daemon] EP973: Project settings synced (slugs: ${projectSlug}/${workspaceSlug})`);
       }
     } catch (error) {
@@ -8570,7 +8542,7 @@ var Daemon = class _Daemon {
         console.warn("[Daemon] EP995: Cannot sync project path - deviceId not available");
         return;
       }
-      const config = await (0, import_core11.loadConfig)();
+      const config = await (0, import_core12.loadConfig)();
       if (!config) return;
       const apiUrl = config.api_url || "https://episoda.dev";
       const response = await fetchWithAuth(`${apiUrl}/api/account/machines/${this.deviceId}`, {
@@ -8603,7 +8575,7 @@ var Daemon = class _Daemon {
    */
   async updateModuleWorktreeStatus(moduleUid, status, worktreePath, errorMessage) {
     try {
-      const config = await (0, import_core11.loadConfig)();
+      const config = await (0, import_core12.loadConfig)();
       if (!config) return;
       const apiUrl = config.api_url || "https://episoda.dev";
       const body = {
@@ -8658,7 +8630,7 @@ var Daemon = class _Daemon {
         console.log("[Daemon] EP1003: Cannot reconcile - deviceId not available yet");
         return;
       }
-      const config = await (0, import_core11.loadConfig)();
+      const config = await (0, import_core12.loadConfig)();
       if (!config) return;
       const apiUrl = config.api_url || "https://episoda.dev";
       const controller = new AbortController();
@@ -8744,7 +8716,7 @@ var Daemon = class _Daemon {
     try {
       const envVars = await fetchEnvVars2();
       console.log(`[Daemon] EP1002: Fetched ${Object.keys(envVars).length} env vars for ${moduleUid}`);
-      const config = await (0, import_core11.loadConfig)();
+      const config = await (0, import_core12.loadConfig)();
       const setupConfig = config?.project_settings;
       await this.runWorktreeSetupSync(
         moduleUid,
@@ -8922,7 +8894,7 @@ var Daemon = class _Daemon {
       }
       this.healthCheckInProgress = true;
       try {
-        const config = await (0, import_core11.loadConfig)();
+        const config = await (0, import_core12.loadConfig)();
         if (config?.access_token) {
           await this.performHealthChecks(config);
         }
@@ -9041,7 +9013,7 @@ var Daemon = class _Daemon {
    */
   async fetchActiveModuleUids(projectId) {
     try {
-      const config = await (0, import_core11.loadConfig)();
+      const config = await (0, import_core12.loadConfig)();
       if (!config?.access_token || !config?.api_url) {
         return null;
       }
@@ -9144,7 +9116,7 @@ var Daemon = class _Daemon {
   async restartTunnel(moduleUid, port) {
     const previewManager = getPreviewManager();
     try {
-      const config = await (0, import_core11.loadConfig)();
+      const config = await (0, import_core12.loadConfig)();
       if (!config?.access_token) {
         console.error(`[Daemon] EP833: No access token for tunnel restart`);
         return;
@@ -9337,8 +9309,8 @@ var Daemon = class _Daemon {
     await this.shutdown();
     try {
       const pidPath = getPidFilePath();
-      if (fs17.existsSync(pidPath)) {
-        fs17.unlinkSync(pidPath);
+      if (fs16.existsSync(pidPath)) {
+        fs16.unlinkSync(pidPath);
         console.log("[Daemon] PID file cleaned up");
       }
     } catch (error) {