@episoda/cli 0.2.150 → 0.2.152

package/dist/daemon/daemon-process.js

@@ -2604,7 +2604,7 @@ var require_auth = __commonJS({
       };
     })();
     Object.defineProperty(exports2, "__esModule", { value: true });
-    exports2.getConfigDir = getConfigDir8;
+    exports2.getConfigDir = getConfigDir9;
     exports2.getConfigPath = getConfigPath;
     exports2.loadConfig = loadConfig9;
     exports2.saveConfig = saveConfig2;
@@ -2616,14 +2616,14 @@ var require_auth = __commonJS({
     var DEFAULT_CONFIG_FILE = "config.json";
     var hasWarnedMissingProjectId = false;
     var hasWarnedMissingRequiredFields = false;
-    function getConfigDir8() {
+    function getConfigDir9() {
       return process.env.EPISODA_CONFIG_DIR || path25.join(os10.homedir(), ".episoda");
     }
     function getConfigPath(configPath) {
       if (configPath) {
         return configPath;
       }
-      return path25.join(getConfigDir8(), DEFAULT_CONFIG_FILE);
+      return path25.join(getConfigDir9(), DEFAULT_CONFIG_FILE);
     }
     function ensureConfigDir(configPath) {
       const dir = path25.dirname(configPath);
@@ -2913,7 +2913,7 @@ var require_package = __commonJS({
   "package.json"(exports2, module2) {
     module2.exports = {
       name: "@episoda/cli",
-      version: "0.2.150",
+      version: "0.2.152",
       description: "CLI tool for Episoda local development workflow orchestration",
       main: "dist/index.js",
       types: "dist/index.d.ts",
@@ -3178,6 +3178,7 @@ var import_core3 = __toESM(require_dist());
 function getPidFilePath() {
   return path3.join((0, import_core3.getConfigDir)(), "daemon.pid");
 }
+var MAX_LOG_SIZE_BYTES = 10 * 1024 * 1024;
 
 // src/ipc/ipc-server.ts
 var net = __toESM(require("net"));
@@ -9161,12 +9162,21 @@ var AgentManager = class {
    * EP1173: Added autonomousMode parameter for permission-free execution
    */
   async startSession(options) {
-    const { sessionId, moduleId, moduleUid, projectId, projectPath, provider = "claude", autonomousMode = true, canWrite = true, readOnlyReason, mcpMode = "planning", message, credentials, systemPrompt, onChunk, onToolUse, onToolResult, onComplete, onError } = options;
+    const { sessionId, moduleId, moduleUid, projectId, workspaceId, projectPath, provider = "claude", autonomousMode = true, canWrite = true, readOnlyReason, mcpMode = "planning", message, credentials, systemPrompt, onChunk, onToolUse, onToolResult, onComplete, onError } = options;
     const normalizedMcpMode = this.normalizeMcpMode(mcpMode);
+    const normalizeWorkspaceId = (id) => {
+      const trimmed = id?.trim();
+      return trimmed ? trimmed : void 0;
+    };
+    const requestedWorkspaceId = normalizeWorkspaceId(workspaceId);
     const existingSession = this.sessions.get(sessionId);
     if (existingSession) {
       if (existingSession.provider === provider && existingSession.moduleId === moduleId) {
         console.log(`[AgentManager] EP1232: Session ${sessionId} already exists, treating start as message (idempotent)`);
+        if (requestedWorkspaceId && !normalizeWorkspaceId(existingSession.workspaceId)) {
+          existingSession.workspaceId = requestedWorkspaceId;
+          console.log(`[AgentManager] EP1357: Updated session ${sessionId} workspaceId from start options`);
+        }
         return this.sendMessage({
           sessionId,
           message,
@@ -9212,11 +9222,22 @@ var AgentManager = class {
         error: error instanceof Error ? error.message : `${cliName} not available`
       };
     }
+    let effectiveWorkspaceId = requestedWorkspaceId;
+    if (!effectiveWorkspaceId) {
+      try {
+        const config = await (0, import_core11.loadConfig)();
+        effectiveWorkspaceId = normalizeWorkspaceId(config?.workspace_id);
+      } catch (error) {
+        console.warn("[AgentManager] EP1357: Unable to resolve workspaceId from local config:", error instanceof Error ? error.message : error);
+      }
+    }
     const session = {
       sessionId,
       moduleId,
       moduleUid,
       projectId,
+      workspaceId: effectiveWorkspaceId,
+      // EP1357: Store workspace ID for MCP server env
       projectPath,
       provider,
       // EP1133: Store provider in session
@@ -9426,6 +9447,9 @@ If changes are needed, explain what needs to be done.`;
             EPISODA_PROJECT_ID: session.projectId,
             DEV_ENVIRONMENT_ID: devEnvId
           };
+          if (session.workspaceId) {
+            episodaMcpEnv.EPISODA_WORKSPACE_ID = session.workspaceId;
+          }
           if (sessionToken) {
             episodaMcpEnv.EPISODA_SESSION_TOKEN = sessionToken;
           }
@@ -9576,6 +9600,9 @@ If changes are needed, explain what needs to be done.`;
                   EPISODA_PROJECT_ID: session.projectId || "",
                   DEV_ENVIRONMENT_ID: devEnvId
                 };
+                if (session.workspaceId) {
+                  env.EPISODA_WORKSPACE_ID = session.workspaceId;
+                }
                 if (sessionToken) {
                   env.EPISODA_SESSION_TOKEN = sessionToken;
                 }
@@ -9659,6 +9686,9 @@ If changes are needed, explain what needs to be done.`;
         MODULE_UID: session.moduleUid,
         EPISODA_PROJECT_ID: session.projectId
       };
+      if (session.workspaceId) {
+        envVars.EPISODA_WORKSPACE_ID = session.workspaceId;
+      }
       if (provider === "codex") {
         envVars.CODEX_HOME = sessionCodexDir;
         console.log(`[AgentManager] EP1260: Set CODEX_HOME=${sessionCodexDir}`);
@@ -10377,7 +10407,7 @@ var path21 = __toESM(require("path"));
 var MAX_RESTART_ATTEMPTS = 5;
 var INITIAL_RESTART_DELAY_MS = 2e3;
 var MAX_RESTART_DELAY_MS = 3e4;
-var MAX_LOG_SIZE_BYTES = 5 * 1024 * 1024;
+var MAX_LOG_SIZE_BYTES2 = 5 * 1024 * 1024;
 var NODE_MEMORY_LIMIT_MB = 2048;
 var activeServers = /* @__PURE__ */ new Map();
 function getLogsDir() {
@@ -10394,7 +10424,7 @@ function rotateLogIfNeeded(logPath) {
   try {
     if (fs20.existsSync(logPath)) {
       const stats = fs20.statSync(logPath);
-      if (stats.size > MAX_LOG_SIZE_BYTES) {
+      if (stats.size > MAX_LOG_SIZE_BYTES2) {
         const backupPath = `${logPath}.1`;
         if (fs20.existsSync(backupPath)) {
           fs20.unlinkSync(backupPath);
@@ -11174,8 +11204,8 @@ var Daemon = class _Daemon {
       }
       console.log(`[Daemon] EP1324: Update to ${targetVersion} installed, restarting daemon...`);
       await this.shutdown();
-      const { getConfigDir: getConfigDir8 } = require_dist();
-      const configDir = getConfigDir8();
+      const { getConfigDir: getConfigDir9 } = require_dist();
+      const configDir = getConfigDir9();
       const logPath = path24.join(configDir, "daemon.log");
       const logFd = fs23.openSync(logPath, "a");
       const child = (0, import_child_process14.spawn)("node", [__filename], {
@@ -11470,16 +11500,29 @@ var Daemon = class _Daemon {
           "Content-Type": "application/json",
           "X-Project-Id": projectId
         };
-        const response = await fetch(`${config.api_url}/api/cli/status`, { headers });
-        if (response.ok) {
-          const data = await response.json();
-          serverConnected = data.connected === true;
-          serverMachineId = data.machine_id || null;
-        } else {
-          serverError = `Server returned ${response.status}`;
+        const controller = new AbortController();
+        const timeoutId = setTimeout(() => controller.abort(), 8e3);
+        try {
+          const response = await fetch(`${config.api_url}/api/cli/status`, {
+            headers,
+            signal: controller.signal
+          });
+          if (response.ok) {
+            const data = await response.json();
+            serverConnected = data.connected === true;
+            serverMachineId = data.machine_id || null;
+          } else {
+            serverError = `Server returned ${response.status}`;
+          }
+        } finally {
+          clearTimeout(timeoutId);
         }
       } catch (err) {
-        serverError = err instanceof Error ? err.message : "Network error";
+        if (err instanceof Error && err.name === "AbortError") {
+          serverError = "Server verification timed out (8s)";
+        } else {
+          serverError = err instanceof Error ? err.message : "Network error";
+        }
       }
       const machineMatch = serverMachineId === this.machineId;
       return {
@@ -12068,6 +12111,8 @@ var Daemon = class _Daemon {
               moduleId: cmd.moduleId,
               moduleUid: cmd.moduleUid,
               projectId: cmd.projectId,
+              workspaceId: cmd.workspaceId,
+              // EP1357: Pass workspace ID for MCP server auth
               projectPath: agentWorkingDir,
               provider: cmd.provider || "claude",
               // EP1133: Multi-provider support
@@ -12381,23 +12426,6 @@ var Daemon = class _Daemon {
       } catch (pidError) {
         console.warn(`[Daemon] Could not read daemon PID:`, pidError instanceof Error ? pidError.message : pidError);
       }
-      const authSuccessPromise = new Promise((resolve4, reject) => {
-        const AUTH_TIMEOUT = 3e4;
-        const timeout = setTimeout(() => {
-          reject(new Error("Authentication timeout after 30s - server may be under heavy load. Try again in a few seconds."));
-        }, AUTH_TIMEOUT);
-        const authHandler = () => {
-          clearTimeout(timeout);
-          resolve4();
-        };
-        client.once("auth_success", authHandler);
-        const errorHandler = (message) => {
-          clearTimeout(timeout);
-          const errorMsg = message;
-          reject(new Error(errorMsg.message || "Authentication failed"));
-        };
-        client.once("auth_error", errorHandler);
-      });
       const modeConfig = getDaemonModeConfig();
       const environment = modeConfig.mode;
       const containerId = process.env.EPISODA_CONTAINER_ID;
@@ -12410,7 +12438,36 @@ var Daemon = class _Daemon {
         containerId
       });
       console.log(`[Daemon] Successfully connected to project ${projectId}`);
-      await authSuccessPromise;
+      const AUTH_TIMEOUT = 3e4;
+      await new Promise((resolve4, reject) => {
+        let settled = false;
+        const cleanup = () => {
+          clearTimeout(timeout);
+          client.off("auth_success", authHandler);
+          client.off("auth_error", errorHandler);
+        };
+        const timeout = setTimeout(() => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          reject(new Error("Authentication timeout after 30s - server may be under heavy load. Try again in a few seconds."));
+        }, AUTH_TIMEOUT);
+        const authHandler = () => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          resolve4();
+        };
+        const errorHandler = (message) => {
+          if (settled) return;
+          settled = true;
+          cleanup();
+          const errorMsg = message;
+          reject(new Error(errorMsg.message || "Authentication failed"));
+        };
+        client.on("auth_success", authHandler);
+        client.on("auth_error", errorHandler);
+      });
       console.log(`[Daemon] Authentication complete for project ${projectId}`);
     } catch (error) {
       console.error(`[Daemon] Failed to connect to ${projectId}:`, error);
@@ -13203,6 +13260,7 @@ var Daemon = class _Daemon {
           this.healthCheckCounter = 0;
           await this.auditWorktreesOnStartup();
         }
+        this.checkAndRotateLog();
       } catch (error) {
         console.error("[Daemon] EP929: Health check error:", error instanceof Error ? error.message : error);
       } finally {
@@ -13220,6 +13278,50 @@ var Daemon = class _Daemon {
       console.log("[Daemon] EP929: Health check polling stopped");
     }
   }
+  static {
+    /**
+     * EP1351: Check daemon.log size and rotate if it exceeds the limit.
+     *
+     * Since the daemon's stdout/stderr are piped to daemon.log via an open FD,
+     * we cannot simply rename the file (the FD follows the inode). Instead:
+     * 1. Copy the current log to daemon.log.1 (shift existing rotated files)
+     * 2. Truncate daemon.log in-place (the open FD continues writing to offset 0)
+     *
+     * This means a small window of duplicate data between .1 and the truncated file,
+     * but that's acceptable for diagnostics logs.
+     */
+    this.MAX_LOG_SIZE_BYTES = 10 * 1024 * 1024;
+  }
+  static {
+    // 10 MB
+    this.MAX_LOG_FILES = 3;
+  }
+  checkAndRotateLog() {
+    try {
+      const configDir = (0, import_core14.getConfigDir)();
+      const logPath = path24.join(configDir, "daemon.log");
+      if (!fs23.existsSync(logPath)) return;
+      const stats = fs23.statSync(logPath);
+      if (stats.size < _Daemon.MAX_LOG_SIZE_BYTES) return;
+      console.log(`[Daemon] EP1351: Log rotation triggered (size: ${Math.round(stats.size / 1024 / 1024)}MB)`);
+      const oldestPath = `${logPath}.${_Daemon.MAX_LOG_FILES}`;
+      if (fs23.existsSync(oldestPath)) {
+        fs23.unlinkSync(oldestPath);
+      }
+      for (let i = _Daemon.MAX_LOG_FILES - 1; i >= 1; i--) {
+        const src = `${logPath}.${i}`;
+        const dst = `${logPath}.${i + 1}`;
+        if (fs23.existsSync(src)) {
+          fs23.renameSync(src, dst);
+        }
+      }
+      fs23.copyFileSync(logPath, `${logPath}.1`);
+      fs23.truncateSync(logPath, 0);
+      console.log("[Daemon] EP1351: Log rotated successfully");
+    } catch (error) {
+      console.warn("[Daemon] EP1351: Log rotation failed:", error instanceof Error ? error.message : error);
+    }
+  }
   /**
    * EP822: Clean up orphaned tunnels from previous daemon runs
    * EP904: Enhanced to aggressively clean ALL cloudflared processes then restart
@@ -13742,6 +13844,21 @@ var Daemon = class _Daemon {
     process.exit(0);
   }
 };
+var daemonStartedAt = Date.now();
+function logCrashDiagnostics(label, error) {
+  const uptimeMs = Date.now() - daemonStartedAt;
+  const mem = process.memoryUsage();
+  console.error(`[Daemon] ${label}:`, error);
+  console.error(`[Daemon] Crash diagnostics: uptime=${Math.round(uptimeMs / 1e3)}s, rss=${Math.round(mem.rss / 1024 / 1024)}MB, heap=${Math.round(mem.heapUsed / 1024 / 1024)}/${Math.round(mem.heapTotal / 1024 / 1024)}MB`);
+}
+process.on("unhandledRejection", (reason) => {
+  logCrashDiagnostics("Unhandled rejection", reason);
+  process.exit(1);
+});
+process.on("uncaughtException", (error) => {
+  logCrashDiagnostics("Uncaught exception", error);
+  process.exit(1);
+});
 async function main() {
   if (!process.env.EPISODA_DAEMON_MODE) {
     console.error("This script should only be run by daemon-manager");