@epiphytic/claudecodeui 1.2.0 → 1.2.2

package/server/external-session-detector.js

@@ -27,10 +27,16 @@ const currentPid = process.pid;
 
 /**
  * Detect external Claude processes
- * @returns {Array<{ pid: number, command: string, cwd: string | null }>}
+ * @returns {{ processes: Array<{ pid: number, command: string, cwd: string | null }>, detectionAvailable: boolean, error: string | null }}
  */
 function detectClaudeProcesses() {
   const processes = [];
+  let detectionAvailable = true;
+  let error = null;
+
+  console.log("[ExternalSessionDetector] detectClaudeProcesses() called");
+  console.log("[ExternalSessionDetector] Platform:", os.platform());
+  console.log("[ExternalSessionDetector] Current PID:", currentPid);
 
   if (os.platform() === "win32") {
     // Windows: use wmic or tasklist
@@ -58,72 +64,165 @@ function detectClaudeProcesses() {
             }
           }
         }
+      } else if (result.error) {
+        detectionAvailable = false;
+        error = `wmic not available: ${result.error.message}`;
       }
-    } catch {
-      // Ignore errors on Windows
+    } catch (e) {
+      detectionAvailable = false;
+      error = `Windows process detection failed: ${e.message}`;
     }
   } else {
     // Unix: use pgrep and ps
     try {
-      // First, get PIDs of claude processes
-      const pgrepResult = spawnSync("pgrep", ["-f", "claude"], {
+      // First, check if pgrep is available
+      const pgrepCheck = spawnSync("which", ["pgrep"], {
         encoding: "utf8",
         stdio: "pipe",
       });
+      console.log(
+        "[ExternalSessionDetector] pgrep available:",
+        pgrepCheck.status === 0,
+      );
 
-      if (pgrepResult.status === 0) {
-        const pids = pgrepResult.stdout.trim().split("\n").filter(Boolean);
-
-        for (const pidStr of pids) {
-          const pid = parseInt(pidStr, 10);
-
-          // Skip our own process and child processes
-          if (pid === currentPid) continue;
-
-          // Get command details
-          const psResult = spawnSync("ps", ["-p", String(pid), "-o", "args="], {
+      if (pgrepCheck.status !== 0) {
+        // pgrep not available, try ps aux as fallback
+        console.log("[ExternalSessionDetector] Using ps aux fallback");
+        try {
+          const psResult = spawnSync("ps", ["aux"], {
             encoding: "utf8",
             stdio: "pipe",
           });
 
           if (psResult.status === 0) {
-            const command = psResult.stdout.trim();
-
-            // Filter out our own subprocesses (claude-sdk spawned by this app)
-            // and only include standalone claude CLI invocations
-            if (isExternalClaudeProcess(command)) {
-              // Try to get working directory via lsof
-              let cwd = null;
-              try {
-                const lsofResult = spawnSync(
-                  "lsof",
-                  ["-p", String(pid), "-Fn"],
-                  {
-                    encoding: "utf8",
-                    stdio: "pipe",
-                  },
-                );
-                if (lsofResult.status === 0) {
-                  const cwdMatch = lsofResult.stdout.match(/n(\/[^\n]+)/);
-                  if (cwdMatch) {
-                    cwd = cwdMatch[1];
+            const lines = psResult.stdout.split("\n");
+            const claudeLines = lines.filter(
+              (line) =>
+                line.toLowerCase().includes("claude") &&
+                !line.includes(String(currentPid)),
+            );
+            console.log(
+              "[ExternalSessionDetector] ps aux found",
+              claudeLines.length,
+              'lines containing "claude"',
+            );
+
+            for (const line of claudeLines) {
+              const parts = line.trim().split(/\s+/);
+              if (parts.length >= 2) {
+                const pid = parseInt(parts[1], 10);
+                if (!isNaN(pid) && pid !== currentPid) {
+                  const command = parts.slice(10).join(" ");
+                  const isExternal = isExternalClaudeProcess(command);
+                  console.log(
+                    `[ExternalSessionDetector] PID ${pid}: "${command.slice(0, 60)}..." isExternal=${isExternal}`,
+                  );
+                  if (isExternal) {
+                    processes.push({ pid, command, cwd: null });
                   }
                 }
-              } catch {
-                // lsof may not be available
               }
+            }
+          } else {
+            detectionAvailable = false;
+            error = "Neither pgrep nor ps aux available";
+            console.log("[ExternalSessionDetector] ps aux failed");
+          }
+        } catch (e) {
+          detectionAvailable = false;
+          error = `Process detection failed: ${e.message}`;
+          console.log("[ExternalSessionDetector] ps aux exception:", e.message);
+        }
+      } else {
+        // pgrep is available, use it
+        const pgrepResult = spawnSync("pgrep", ["-f", "claude"], {
+          encoding: "utf8",
+          stdio: "pipe",
+        });
+        console.log(
+          "[ExternalSessionDetector] pgrep status:",
+          pgrepResult.status,
+        );
+
+        if (pgrepResult.status === 0) {
+          const pids = pgrepResult.stdout.trim().split("\n").filter(Boolean);
+          console.log("[ExternalSessionDetector] pgrep found PIDs:", pids);
+
+          for (const pidStr of pids) {
+            const pid = parseInt(pidStr, 10);
+
+            // Skip our own process and child processes
+            if (pid === currentPid) {
+              console.log(
+                `[ExternalSessionDetector] Skipping our own PID ${pid}`,
+              );
+              continue;
+            }
+
+            // Get command details
+            const psResult = spawnSync(
+              "ps",
+              ["-p", String(pid), "-o", "args="],
+              {
+                encoding: "utf8",
+                stdio: "pipe",
+              },
+            );
+
+            if (psResult.status === 0) {
+              const command = psResult.stdout.trim();
+              const isExternal = isExternalClaudeProcess(command);
+              console.log(
+                `[ExternalSessionDetector] PID ${pid}: "${command.slice(0, 80)}..." isExternal=${isExternal}`,
+              );
+
+              // Filter out our own subprocesses (claude-sdk spawned by this app)
+              // and only include standalone claude CLI invocations
+              if (isExternal) {
+                // Try to get working directory via lsof
+                let cwd = null;
+                try {
+                  const lsofResult = spawnSync(
+                    "lsof",
+                    ["-p", String(pid), "-Fn"],
+                    {
+                      encoding: "utf8",
+                      stdio: "pipe",
+                    },
+                  );
+                  if (lsofResult.status === 0) {
+                    const cwdMatch = lsofResult.stdout.match(/n(\/[^\n]+)/);
+                    if (cwdMatch) {
+                      cwd = cwdMatch[1];
+                    }
+                  }
+                } catch {
+                  // lsof may not be available - not critical
+                }
 
-              processes.push({ pid, command, cwd });
+                processes.push({ pid, command, cwd });
+              }
             }
           }
+        } else {
+          console.log(
+            "[ExternalSessionDetector] pgrep found no claude processes (status:",
+            pgrepResult.status,
+            ")",
+          );
         }
       }
-    } catch {
-      // Ignore errors
+    } catch (e) {
+      detectionAvailable = false;
+      error = `Unix process detection failed: ${e.message}`;
+      console.log(
+        "[ExternalSessionDetector] Unix detection exception:",
+        e.message,
+      );
     }
   }
 
-  return processes;
+  return { processes, detectionAvailable, error };
 }
 
 /**
@@ -133,18 +232,30 @@ function detectClaudeProcesses() {
  */
 function isExternalClaudeProcess(command) {
   // Skip node processes (SDK internals)
-  if (command.startsWith("node ")) return false;
+  if (command.startsWith("node ")) {
+    console.log("[isExternalClaudeProcess] Rejected: starts with 'node '");
+    return false;
+  }
 
   // Skip our own server
-  if (command.includes("claudecodeui/server")) return false;
+  if (command.includes("claudecodeui/server")) {
+    console.log(
+      "[isExternalClaudeProcess] Rejected: contains 'claudecodeui/server'",
+    );
+    return false;
+  }
 
   // Look for actual claude CLI invocations
-  return (
+  const isExternal =
     command.includes("claude ") ||
     command.includes("claude-code") ||
     command.match(/\/claude\s/) ||
-    command.endsWith("/claude")
+    command.endsWith("/claude");
+
+  console.log(
+    `[isExternalClaudeProcess] "${command.slice(0, 60)}..." => ${isExternal}`,
   );
+  return isExternal;
 }
 
 /**
@@ -284,34 +395,63 @@ function processExists(pid) {
 /**
  * Main detection function - detect all external Claude sessions
  * @param {string} projectPath - The project directory to check
- * @returns {{ hasExternalSession: boolean, processes: Array, tmuxSessions: Array, lockFile: object }}
+ * @returns {{ hasExternalSession: boolean, processes: Array, tmuxSessions: Array, lockFile: object, detectionAvailable: boolean, detectionError: string | null }}
  */
 function detectExternalClaude(projectPath) {
+  console.log("[detectExternalClaude] Called with projectPath:", projectPath);
+
   // Check cache
   const cacheKey = projectPath || "__global__";
   const cached = detectionCache.get(cacheKey);
   if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    console.log("[detectExternalClaude] Returning cached result");
     return cached.result;
   }
+  console.log("[detectExternalClaude] Cache miss, performing fresh detection");
 
   const result = {
     hasExternalSession: false,
     processes: [],
     tmuxSessions: [],
     lockFile: { exists: false, lockFile: null, content: null },
+    detectionAvailable: true,
+    detectionError: null,
   };
 
   // Detect processes
-  result.processes = detectClaudeProcesses();
+  const processDetection = detectClaudeProcesses();
+  result.processes = processDetection.processes;
+  result.detectionAvailable = processDetection.detectionAvailable;
+  result.detectionError = processDetection.error;
+  console.log(
+    "[detectExternalClaude] Process detection result:",
+    processDetection.processes.length,
+    "processes, available:",
+    processDetection.detectionAvailable,
+    "error:",
+    processDetection.error,
+  );
+
   if (projectPath) {
     // Filter to processes in this project
+    const beforeFilter = result.processes.length;
     result.processes = result.processes.filter(
       (p) => !p.cwd || p.cwd.startsWith(projectPath),
     );
+    console.log(
+      "[detectExternalClaude] Filtered processes for project:",
+      beforeFilter,
+      "->",
+      result.processes.length,
+    );
   }
 
   // Detect tmux sessions
   result.tmuxSessions = detectClaudeTmuxSessions();
+  console.log(
+    "[detectExternalClaude] tmux sessions found:",
+    result.tmuxSessions.length,
+  );
 
   // Check lock file
   if (projectPath) {

package/server/index.js

@@ -379,6 +379,70 @@ const wss = new WebSocketServer({
 app.locals.wss = wss;
 
 app.use(cors());
+
+// Request/Response logging middleware for debugging
+app.use((req, res, next) => {
+  const startTime = Date.now();
+  const originalSend = res.send;
+  const originalJson = res.json;
+
+  // Capture response for logging
+  res.send = function (body) {
+    const duration = Date.now() - startTime;
+    const statusCode = res.statusCode;
+
+    // Log 4xx errors with headers
+    if (statusCode >= 400 && statusCode < 500) {
+      console.log(
+        `[HTTP ${statusCode}] ${req.method} ${req.originalUrl} (${duration}ms)`,
+      );
+      console.log(`  Request Headers:`, JSON.stringify(req.headers, null, 2));
+      console.log(
+        `  Response:`,
+        typeof body === "string" ? body.slice(0, 500) : body,
+      );
+    }
+    // Log 5xx errors with full details
+    else if (statusCode >= 500) {
+      console.error(
+        `[HTTP ${statusCode}] ${req.method} ${req.originalUrl} (${duration}ms)`,
+      );
+      console.error(`  Request Headers:`, JSON.stringify(req.headers, null, 2));
+      console.error(`  Request Body:`, req.body);
+      console.error(`  Response:`, body);
+    }
+
+    return originalSend.call(this, body);
+  };
+
+  res.json = function (body) {
+    const duration = Date.now() - startTime;
+    const statusCode = res.statusCode;
+
+    // Log 4xx errors with headers
+    if (statusCode >= 400 && statusCode < 500) {
+      console.log(
+        `[HTTP ${statusCode}] ${req.method} ${req.originalUrl} (${duration}ms)`,
+      );
+      console.log(`  Request Headers:`, JSON.stringify(req.headers, null, 2));
+      console.log(`  Response:`, JSON.stringify(body, null, 2).slice(0, 500));
+    }
+    // Log 5xx errors with full details
+    else if (statusCode >= 500) {
+      console.error(
+        `[HTTP ${statusCode}] ${req.method} ${req.originalUrl} (${duration}ms)`,
+      );
+      console.error(`  Request Headers:`, JSON.stringify(req.headers, null, 2));
+      console.error(`  Request Body:`, req.body);
+      console.error(`  Response:`, JSON.stringify(body, null, 2));
+    }
+
+    return originalJson.call(this, body);
+  };
+
+  next();
+});
+
 app.use(
   express.json({
     limit: "50mb",
@@ -402,6 +466,56 @@ app.get("/health", (req, res) => {
   });
 });
 
+// Explicit route for manifest.json (PWA manifest)
+app.get("/manifest.json", (req, res) => {
+  const manifestPath = path.join(__dirname, "../public/manifest.json");
+  const distManifestPath = path.join(__dirname, "../dist/manifest.json");
+
+  console.log("[manifest.json] Request received");
+  console.log("[manifest.json] __dirname:", __dirname);
+  console.log("[manifest.json] Checking paths:");
+  console.log(
+    "  - public:",
+    manifestPath,
+    "exists:",
+    fs.existsSync(manifestPath),
+  );
+  console.log(
+    "  - dist:",
+    distManifestPath,
+    "exists:",
+    fs.existsSync(distManifestPath),
+  );
+
+  // Try public first, then dist
+  if (fs.existsSync(manifestPath)) {
+    console.log("[manifest.json] Serving from public");
+    res.setHeader("Content-Type", "application/manifest+json");
+    res.setHeader("Cache-Control", "public, max-age=3600, must-revalidate");
+    res.sendFile(manifestPath, (err) => {
+      if (err) {
+        console.error("[manifest.json] sendFile error:", err);
+        res.status(500).json({ error: "Failed to send manifest.json" });
+      }
+    });
+  } else if (fs.existsSync(distManifestPath)) {
+    console.log("[manifest.json] Serving from dist");
+    res.setHeader("Content-Type", "application/manifest+json");
+    res.setHeader("Cache-Control", "public, max-age=3600, must-revalidate");
+    res.sendFile(distManifestPath, (err) => {
+      if (err) {
+        console.error("[manifest.json] sendFile error:", err);
+        res.status(500).json({ error: "Failed to send manifest.json" });
+      }
+    });
+  } else {
+    console.error("[ERROR] manifest.json not found in public or dist");
+    console.error("  Checked:", manifestPath);
+    console.error("  Checked:", distManifestPath);
+    res.status(404).json({ error: "manifest.json not found" });
+  }
+});
+
 // Optional API key validation (if configured)
 app.use("/api", validateApiKey);
 
@@ -447,7 +561,7 @@ app.use("/api/sessions", authenticateToken, sessionsRoutes);
 // Agent API Routes (uses API key authentication)
 app.use("/api/agent", agentRoutes);
 
-// Serve public files (like api-docs.html, icons)
+// Serve public files (like api-docs.html, icons, manifest.json)
 // Enable ETag generation for conditional requests (304 support)
 app.use(
   express.static(path.join(__dirname, "../public"), {
@@ -461,6 +575,9 @@ app.use(
           "Cache-Control",
           "public, max-age=604800, must-revalidate",
         );
+      } else if (filePath.endsWith(".json")) {
+        // JSON files (like manifest.json) - short cache with revalidation
+        res.setHeader("Cache-Control", "public, max-age=3600, must-revalidate");
       } else if (filePath.endsWith(".html")) {
         // HTML files should not be cached
         res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
@@ -483,6 +600,9 @@ app.use(
         res.setHeader("Cache-Control", "no-cache, no-store, must-revalidate");
         res.setHeader("Pragma", "no-cache");
         res.setHeader("Expires", "0");
+      } else if (filePath.endsWith(".json")) {
+        // JSON files (like manifest.json) - short cache with revalidation
+        res.setHeader("Cache-Control", "public, max-age=3600, must-revalidate");
       } else if (
         filePath.match(/\.(js|css|woff2?|ttf|eot|svg|png|jpg|jpeg|gif|ico)$/)
       ) {
@@ -1150,12 +1270,26 @@ async function handleChatMessage(ws, writer, messageData) {
     // Handle proactive external session check (before user submits a prompt)
     if (data.type === "check-external-session") {
       const projectPath = data.projectPath;
+      console.log(
+        "[ExternalSessionCheck] Checking for external sessions:",
+        projectPath,
+      );
       if (projectPath) {
         const externalCheck = detectExternalClaude(projectPath);
+        console.log("[ExternalSessionCheck] Result:", {
+          hasExternalSession: externalCheck.hasExternalSession,
+          detectionAvailable: externalCheck.detectionAvailable,
+          detectionError: externalCheck.detectionError,
+          processCount: externalCheck.processes.length,
+          tmuxCount: externalCheck.tmuxSessions.length,
+          hasLockFile: externalCheck.lockFile.exists,
+        });
         writer.send({
           type: "external-session-check-result",
           projectPath,
           hasExternalSession: externalCheck.hasExternalSession,
+          detectionAvailable: externalCheck.detectionAvailable,
+          detectionError: externalCheck.detectionError,
           details: externalCheck.hasExternalSession
             ? {
                 processIds: externalCheck.processes.map((p) => p.pid),
@@ -1169,6 +1303,8 @@ async function handleChatMessage(ws, writer, messageData) {
               }
             : null,
         });
+      } else {
+        console.log("[ExternalSessionCheck] No projectPath provided");
       }
       return;
     }
@@ -1208,6 +1344,7 @@ async function handleChatMessage(ws, writer, messageData) {
           writer.send({
             type: "external-session-detected",
             projectPath,
+            detectionAvailable: externalCheck.detectionAvailable,
             details: {
               processIds: externalCheck.processes.map((p) => p.pid),
               tmuxSessions: externalCheck.tmuxSessions.map(
@@ -2652,6 +2789,9 @@ app.get(
 app.get("*", (req, res) => {
   // Skip requests for static assets (files with extensions)
   if (path.extname(req.path)) {
+    console.log(
+      `[404] Static file not found: ${req.path} (not served by express.static)`,
+    );
     return res.status(404).send("Not found");
   }
 

package/server/projects-cache.js

@@ -14,6 +14,10 @@ let cachedProjects = [];
 let cacheVersion = 0;
 let cacheTimestamp = null;
 
+// Promise-based initialization waiting
+let initResolvers = [];
+const MAX_WAIT_MS = 30000; // 30 second timeout
+
 /**
  * Timeframe definitions in milliseconds
  * (Same as sessions-cache.js for consistency)
@@ -109,6 +113,14 @@ function updateProjectsCache(projects) {
 
   cacheVersion++;
   cacheTimestamp = new Date().toISOString();
+
+  // Resolve any waiting promises
+  if (initResolvers.length > 0) {
+    for (const resolve of initResolvers) {
+      resolve();
+    }
+    initResolvers = [];
+  }
 }
 
 /**
@@ -170,6 +182,35 @@ function isCacheInitialized() {
   return cacheTimestamp !== null;
 }
 
+/**
+ * Wait for cache to be initialized
+ * Returns immediately if already initialized, otherwise waits up to MAX_WAIT_MS
+ */
+function waitForInitialization() {
+  if (cacheTimestamp !== null) {
+    return Promise.resolve();
+  }
+
+  return new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      // Remove this resolver from the list
+      const idx = initResolvers.indexOf(resolve);
+      if (idx !== -1) {
+        initResolvers.splice(idx, 1);
+      }
+      reject(new Error("Cache initialization timeout"));
+    }, MAX_WAIT_MS);
+
+    // Wrap resolver to clear timeout
+    const wrappedResolve = () => {
+      clearTimeout(timeout);
+      resolve();
+    };
+
+    initResolvers.push(wrappedResolve);
+  });
+}
+
 /**
  * Get the raw cached projects (for initial load)
  */
@@ -190,6 +231,7 @@ export {
   generateETag,
   getCacheMeta,
   isCacheInitialized,
+  waitForInitialization,
   getCachedProjects,
   getProjectFromCache,
   TIMEFRAME_MS,

package/server/routes/projects.js

@@ -9,6 +9,7 @@ import {
   generateETag,
   getCacheMeta,
   isCacheInitialized,
+  waitForInitialization,
   TIMEFRAME_MS,
 } from "../projects-cache.js";
 
@@ -26,14 +27,18 @@ const router = express.Router();
  * Headers:
  * - If-None-Match: ETag from previous response (for 304 support)
  */
-router.get("/list", (req, res) => {
+router.get("/list", async (req, res) => {
   try {
-    // Check if cache is initialized
+    // Wait for cache to be initialized (blocks until ready or timeout)
     if (!isCacheInitialized()) {
-      return res.status(503).json({
-        error: "Projects cache not yet initialized",
-        message: "Please wait for initial project scan to complete",
-      });
+      try {
+        await waitForInitialization();
+      } catch (err) {
+        return res.status(503).json({
+          error: "Projects cache initialization timeout",
+          message: err.message,
+        });
+      }
     }
 
     // Get timeframe from query (validate against known values)

package/server/routes/sessions.js

@@ -13,6 +13,7 @@ import {
   generateETag,
   getCacheMeta,
   isCacheInitialized,
+  waitForInitialization,
   TIMEFRAME_MS,
 } from "../sessions-cache.js";
 
@@ -31,14 +32,18 @@ const router = express.Router();
  * - 304 Not Modified (if ETag matches)
  * - 200 OK with sessions data
  */
-router.get("/list", (req, res) => {
+router.get("/list", async (req, res) => {
   try {
-    // Check if cache is initialized
+    // Wait for cache to be initialized (blocks until ready or timeout)
     if (!isCacheInitialized()) {
-      return res.status(503).json({
-        error: "Sessions cache not yet initialized",
-        message: "Please wait for initial project scan to complete",
-      });
+      try {
+        await waitForInitialization();
+      } catch (err) {
+        return res.status(503).json({
+          error: "Sessions cache initialization timeout",
+          message: err.message,
+        });
+      }
     }
 
     // Get timeframe from query (validate against known values)