@epiphytic/claudecodeui 1.0.0 → 1.1.0

package/server/routes/projects.js

@@ -1,33 +1,157 @@
-import express from 'express';
-import { promises as fs } from 'fs';
-import path from 'path';
-import { spawn } from 'child_process';
-import os from 'os';
-import { addProjectManually } from '../projects.js';
+import express from "express";
+import { promises as fs } from "fs";
+import path from "path";
+import { spawn } from "child_process";
+import os from "os";
+import { addProjectManually, getProjectDetailFull } from "../projects.js";
+import {
+  getProjectsByTimeframe,
+  generateETag,
+  getCacheMeta,
+  isCacheInitialized,
+  TIMEFRAME_MS,
+} from "../projects-cache.js";
 
 const router = express.Router();
 
+/**
+ * GET /api/projects/list
+ *
+ * Returns a slim list of projects for sidebar display with timeframe filtering.
+ * Supports ETag/304 caching for efficient polling.
+ *
+ * Query Parameters:
+ * - timeframe: '1h' | '8h' | '1d' | '1w' | '2w' | '1m' | 'all' (default: '1w')
+ *
+ * Headers:
+ * - If-None-Match: ETag from previous response (for 304 support)
+ */
+router.get("/list", (req, res) => {
+  try {
+    // Check if cache is initialized
+    if (!isCacheInitialized()) {
+      return res.status(503).json({
+        error: "Projects cache not yet initialized",
+        message: "Please wait for initial project scan to complete",
+      });
+    }
+
+    // Get timeframe from query (validate against known values)
+    const timeframe =
+      TIMEFRAME_MS[req.query.timeframe] !== undefined
+        ? req.query.timeframe
+        : "1w";
+
+    // Generate current ETag
+    const currentETag = generateETag(timeframe);
+
+    // Check If-None-Match header for conditional request
+    const clientETag = req.headers["if-none-match"];
+    if (clientETag && clientETag === currentETag) {
+      // Data hasn't changed - return 304
+      return res.status(304).end();
+    }
+
+    // Get projects filtered by timeframe
+    const { projects, totalCount, filteredCount } =
+      getProjectsByTimeframe(timeframe);
+    const cacheMeta = getCacheMeta();
+
+    // Set caching headers
+    res.set({
+      "Cache-Control": "private, max-age=10",
+      ETag: currentETag,
+    });
+
+    // Return projects data
+    res.json({
+      projects,
+      meta: {
+        totalCount,
+        filteredCount,
+        timeframe,
+        cacheTimestamp: cacheMeta.timestamp,
+      },
+    });
+  } catch (error) {
+    console.error("[ERROR] Projects list endpoint error:", error);
+    res.status(500).json({
+      error: "Failed to retrieve projects",
+      message: error.message,
+    });
+  }
+});
+
+/**
+ * GET /api/projects/cache-status
+ * Returns current cache status (for debugging/monitoring)
+ */
+router.get("/cache-status", (req, res) => {
+  try {
+    const meta = getCacheMeta();
+    res.json({
+      initialized: isCacheInitialized(),
+      ...meta,
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+/**
+ * GET /api/projects/:projectName/detail
+ *
+ * Returns full project data including all sessions.
+ * Called when a project is expanded in the sidebar.
+ */
+router.get("/:projectName/detail", async (req, res) => {
+  try {
+    const { projectName } = req.params;
+
+    // Decode the project name (URL encoded)
+    const decodedName = decodeURIComponent(projectName);
+
+    // Fetch full project details
+    const project = await getProjectDetailFull(decodedName);
+
+    if (!project) {
+      return res.status(404).json({
+        error: "Project not found",
+        projectName: decodedName,
+      });
+    }
+
+    res.json(project);
+  } catch (error) {
+    console.error("[ERROR] Project detail endpoint error:", error);
+    res.status(500).json({
+      error: "Failed to retrieve project details",
+      message: error.message,
+    });
+  }
+});
+
 // Configure allowed workspace root (defaults to user's home directory)
 const WORKSPACES_ROOT = process.env.WORKSPACES_ROOT || os.homedir();
 
 // System-critical paths that should never be used as workspace directories
 const FORBIDDEN_PATHS = [
-  '/',
-  '/etc',
-  '/bin',
-  '/sbin',
-  '/usr',
-  '/dev',
-  '/proc',
-  '/sys',
-  '/var',
-  '/boot',
-  '/root',
-  '/lib',
-  '/lib64',
-  '/opt',
-  '/tmp',
-  '/run'
+  "/",
+  "/etc",
+  "/bin",
+  "/sbin",
+  "/usr",
+  "/dev",
+  "/proc",
+  "/sys",
+  "/var",
+  "/boot",
+  "/root",
+  "/lib",
+  "/lib64",
+  "/opt",
+  "/tmp",
+  "/run",
 ];
 
 /**
@@ -42,28 +166,32 @@ async function validateWorkspacePath(requestedPath) {
 
     // Check if path is a forbidden system directory
     const normalizedPath = path.normalize(absolutePath);
-    if (FORBIDDEN_PATHS.includes(normalizedPath) || normalizedPath === '/') {
+    if (FORBIDDEN_PATHS.includes(normalizedPath) || normalizedPath === "/") {
       return {
         valid: false,
-        error: 'Cannot use system-critical directories as workspace locations'
+        error: "Cannot use system-critical directories as workspace locations",
       };
     }
 
     // Additional check for paths starting with forbidden directories
     for (const forbidden of FORBIDDEN_PATHS) {
-      if (normalizedPath === forbidden ||
-          normalizedPath.startsWith(forbidden + path.sep)) {
+      if (
+        normalizedPath === forbidden ||
+        normalizedPath.startsWith(forbidden + path.sep)
+      ) {
         // Exception: /var/tmp and similar user-accessible paths might be allowed
         // but /var itself and most /var subdirectories should be blocked
-        if (forbidden === '/var' &&
-            (normalizedPath.startsWith('/var/tmp') ||
-             normalizedPath.startsWith('/var/folders'))) {
+        if (
+          forbidden === "/var" &&
+          (normalizedPath.startsWith("/var/tmp") ||
+            normalizedPath.startsWith("/var/folders"))
+        ) {
           continue; // Allow these specific cases
         }
 
         return {
           valid: false,
-          error: `Cannot create workspace in system directory: ${forbidden}`
+          error: `Cannot create workspace in system directory: ${forbidden}`,
         };
       }
     }
@@ -75,7 +203,7 @@ async function validateWorkspacePath(requestedPath) {
       await fs.access(absolutePath);
       realPath = await fs.realpath(absolutePath);
     } catch (error) {
-      if (error.code === 'ENOENT') {
+      if (error.code === "ENOENT") {
         // Path doesn't exist yet - check parent directory
         let parentPath = path.dirname(absolutePath);
         try {
@@ -84,7 +212,7 @@ async function validateWorkspacePath(requestedPath) {
           // Reconstruct the full path with real parent
           realPath = path.join(parentRealPath, path.basename(absolutePath));
         } catch (parentError) {
-          if (parentError.code === 'ENOENT') {
+          if (parentError.code === "ENOENT") {
             // Parent doesn't exist either - use the absolute path as-is
             // We'll validate it's within allowed root
             realPath = absolutePath;
@@ -101,11 +229,13 @@ async function validateWorkspacePath(requestedPath) {
     const resolvedWorkspaceRoot = await fs.realpath(WORKSPACES_ROOT);
 
     // Ensure the resolved path is contained within the allowed workspace root
-    if (!realPath.startsWith(resolvedWorkspaceRoot + path.sep) &&
-        realPath !== resolvedWorkspaceRoot) {
+    if (
+      !realPath.startsWith(resolvedWorkspaceRoot + path.sep) &&
+      realPath !== resolvedWorkspaceRoot
+    ) {
       return {
         valid: false,
-        error: `Workspace path must be within the allowed workspace root: ${WORKSPACES_ROOT}`
+        error: `Workspace path must be within the allowed workspace root: ${WORKSPACES_ROOT}`,
       };
     }
 
@@ -117,19 +247,24 @@ async function validateWorkspacePath(requestedPath) {
       if (stats.isSymbolicLink()) {
         // Verify symlink target is also within allowed root
         const linkTarget = await fs.readlink(absolutePath);
-        const resolvedTarget = path.resolve(path.dirname(absolutePath), linkTarget);
+        const resolvedTarget = path.resolve(
+          path.dirname(absolutePath),
+          linkTarget,
+        );
         const realTarget = await fs.realpath(resolvedTarget);
 
-        if (!realTarget.startsWith(resolvedWorkspaceRoot + path.sep) &&
-            realTarget !== resolvedWorkspaceRoot) {
+        if (
+          !realTarget.startsWith(resolvedWorkspaceRoot + path.sep) &&
+          realTarget !== resolvedWorkspaceRoot
+        ) {
           return {
             valid: false,
-            error: 'Symlink target is outside the allowed workspace root'
+            error: "Symlink target is outside the allowed workspace root",
           };
         }
       }
     } catch (error) {
-      if (error.code !== 'ENOENT') {
+      if (error.code !== "ENOENT") {
         throw error;
       }
       // Path doesn't exist - that's fine for new workspace creation
@@ -137,13 +272,12 @@ async function validateWorkspacePath(requestedPath) {
 
     return {
       valid: true,
-      resolvedPath: realPath
+      resolvedPath: realPath,
     };
-
   } catch (error) {
     return {
       valid: false,
-      error: `Path validation failed: ${error.message}`
+      error: `Path validation failed: ${error.message}`,
     };
   }
 }
@@ -159,43 +293,57 @@ async function validateWorkspacePath(requestedPath) {
  * - githubTokenId?: number (optional, ID of stored token)
  * - newGithubToken?: string (optional, one-time token)
  */
-router.post('/create-workspace', async (req, res) => {
+router.post("/create-workspace", async (req, res) => {
   try {
-    const { workspaceType, path: workspacePath, githubUrl, githubTokenId, newGithubToken } = req.body;
+    const {
+      workspaceType,
+      path: workspacePath,
+      githubUrl,
+      githubTokenId,
+      newGithubToken,
+    } = req.body;
 
     // Validate required fields
     if (!workspaceType || !workspacePath) {
-      return res.status(400).json({ error: 'workspaceType and path are required' });
+      return res
+        .status(400)
+        .json({ error: "workspaceType and path are required" });
     }
 
-    if (!['existing', 'new'].includes(workspaceType)) {
-      return res.status(400).json({ error: 'workspaceType must be "existing" or "new"' });
+    if (!["existing", "new"].includes(workspaceType)) {
+      return res
+        .status(400)
+        .json({ error: 'workspaceType must be "existing" or "new"' });
     }
 
     // Validate path safety before any operations
     const validation = await validateWorkspacePath(workspacePath);
     if (!validation.valid) {
       return res.status(400).json({
-        error: 'Invalid workspace path',
-        details: validation.error
+        error: "Invalid workspace path",
+        details: validation.error,
       });
     }
 
     const absolutePath = validation.resolvedPath;
 
     // Handle existing workspace
-    if (workspaceType === 'existing') {
+    if (workspaceType === "existing") {
       // Check if the path exists
       try {
         await fs.access(absolutePath);
         const stats = await fs.stat(absolutePath);
 
         if (!stats.isDirectory()) {
-          return res.status(400).json({ error: 'Path exists but is not a directory' });
+          return res
+            .status(400)
+            .json({ error: "Path exists but is not a directory" });
         }
       } catch (error) {
-        if (error.code === 'ENOENT') {
-          return res.status(404).json({ error: 'Workspace path does not exist' });
+        if (error.code === "ENOENT") {
+          return res
+            .status(404)
+            .json({ error: "Workspace path does not exist" });
         }
         throw error;
       }
@@ -206,20 +354,21 @@ router.post('/create-workspace', async (req, res) => {
       return res.json({
         success: true,
         project,
-        message: 'Existing workspace added successfully'
+        message: "Existing workspace added successfully",
       });
     }
 
     // Handle new workspace creation
-    if (workspaceType === 'new') {
+    if (workspaceType === "new") {
       // Check if path already exists
       try {
         await fs.access(absolutePath);
         return res.status(400).json({
-          error: 'Path already exists. Please choose a different path or use "existing workspace" option.'
+          error:
+            'Path already exists. Please choose a different path or use "existing workspace" option.',
         });
       } catch (error) {
-        if (error.code !== 'ENOENT') {
+        if (error.code !== "ENOENT") {
           throw error;
         }
         // Path doesn't exist - good, we can create it
@@ -239,7 +388,7 @@ router.post('/create-workspace', async (req, res) => {
           if (!token) {
             // Clean up created directory
             await fs.rm(absolutePath, { recursive: true, force: true });
-            return res.status(404).json({ error: 'GitHub token not found' });
+            return res.status(404).json({ error: "GitHub token not found" });
           }
           githubToken = token.github_token;
         } else if (newGithubToken) {
@@ -254,7 +403,10 @@ router.post('/create-workspace', async (req, res) => {
           try {
             await fs.rm(absolutePath, { recursive: true, force: true });
           } catch (cleanupError) {
-            console.error('Failed to clean up directory after clone failure:', cleanupError);
+            console.error(
+              "Failed to clean up directory after clone failure:",
+              cleanupError,
+            );
             // Continue to throw original error
           }
           throw new Error(`Failed to clone repository: ${error.message}`);
@@ -268,16 +420,15 @@ router.post('/create-workspace', async (req, res) => {
         success: true,
         project,
         message: githubUrl
-          ? 'New workspace created and repository cloned successfully'
-          : 'New workspace created successfully'
+          ? "New workspace created and repository cloned successfully"
+          : "New workspace created successfully",
       });
     }
-
   } catch (error) {
-    console.error('Error creating workspace:', error);
+    console.error("Error creating workspace:", error);
     res.status(500).json({
-      error: error.message || 'Failed to create workspace',
-      details: process.env.NODE_ENV === 'development' ? error.stack : undefined
+      error: error.message || "Failed to create workspace",
+      details: process.env.NODE_ENV === "development" ? error.stack : undefined,
     });
   }
 });
@@ -286,19 +437,19 @@ router.post('/create-workspace', async (req, res) => {
  * Helper function to get GitHub token from database
  */
 async function getGithubTokenById(tokenId, userId) {
-  const { getDatabase } = await import('../database/db.js');
+  const { getDatabase } = await import("../database/db.js");
   const db = await getDatabase();
 
   const credential = await db.get(
-    'SELECT * FROM user_credentials WHERE id = ? AND user_id = ? AND credential_type = ? AND is_active = 1',
-    [tokenId, userId, 'github_token']
+    "SELECT * FROM user_credentials WHERE id = ? AND user_id = ? AND credential_type = ? AND is_active = 1",
+    [tokenId, userId, "github_token"],
   );
 
   // Return in the expected format (github_token field for compatibility)
   if (credential) {
     return {
       ...credential,
-      github_token: credential.credential_value
+      github_token: credential.credential_value,
     };
   }
 
@@ -318,45 +469,50 @@ function cloneGitHubRepository(githubUrl, destinationPath, githubToken = null) {
         const url = new URL(githubUrl);
         // Format: https://TOKEN@github.com/user/repo.git
         url.username = githubToken;
-        url.password = '';
+        url.password = "";
         cloneUrl = url.toString();
       } catch (error) {
-        return reject(new Error('Invalid GitHub URL format'));
+        return reject(new Error("Invalid GitHub URL format"));
       }
     }
 
-    const gitProcess = spawn('git', ['clone', cloneUrl, destinationPath], {
-      stdio: ['ignore', 'pipe', 'pipe'],
+    const gitProcess = spawn("git", ["clone", cloneUrl, destinationPath], {
+      stdio: ["ignore", "pipe", "pipe"],
       env: {
         ...process.env,
-        GIT_TERMINAL_PROMPT: '0' // Disable git password prompts
-      }
+        GIT_TERMINAL_PROMPT: "0", // Disable git password prompts
+      },
     });
 
-    let stdout = '';
-    let stderr = '';
+    let stdout = "";
+    let stderr = "";
 
-    gitProcess.stdout.on('data', (data) => {
+    gitProcess.stdout.on("data", (data) => {
       stdout += data.toString();
     });
 
-    gitProcess.stderr.on('data', (data) => {
+    gitProcess.stderr.on("data", (data) => {
       stderr += data.toString();
     });
 
-    gitProcess.on('close', (code) => {
+    gitProcess.on("close", (code) => {
       if (code === 0) {
         resolve({ stdout, stderr });
       } else {
         // Parse git error messages to provide helpful feedback
-        let errorMessage = 'Git clone failed';
-
-        if (stderr.includes('Authentication failed') || stderr.includes('could not read Username')) {
-          errorMessage = 'Authentication failed. Please check your GitHub token.';
-        } else if (stderr.includes('Repository not found')) {
-          errorMessage = 'Repository not found. Please check the URL and ensure you have access.';
-        } else if (stderr.includes('already exists')) {
-          errorMessage = 'Directory already exists';
+        let errorMessage = "Git clone failed";
+
+        if (
+          stderr.includes("Authentication failed") ||
+          stderr.includes("could not read Username")
+        ) {
+          errorMessage =
+            "Authentication failed. Please check your GitHub token.";
+        } else if (stderr.includes("Repository not found")) {
+          errorMessage =
+            "Repository not found. Please check the URL and ensure you have access.";
+        } else if (stderr.includes("already exists")) {
+          errorMessage = "Directory already exists";
         } else if (stderr) {
           errorMessage = stderr;
         }
@@ -365,9 +521,9 @@ function cloneGitHubRepository(githubUrl, destinationPath, githubToken = null) {
       }
     });
 
-    gitProcess.on('error', (error) => {
-      if (error.code === 'ENOENT') {
-        reject(new Error('Git is not installed or not in PATH'));
+    gitProcess.on("error", (error) => {
+      if (error.code === "ENOENT") {
+        reject(new Error("Git is not installed or not in PATH"));
       } else {
         reject(error);
       }

package/server/routes/sessions.js

@@ -0,0 +1,106 @@
+/**
+ * SESSIONS API ROUTES
+ * ===================
+ *
+ * GET /api/sessions/list
+ * Returns a flat list of all sessions with optional timeframe filtering.
+ * Supports ETag/304 caching for efficient polling.
+ */
+
+import express from "express";
+import {
+  getSessionsByTimeframe,
+  generateETag,
+  getCacheMeta,
+  isCacheInitialized,
+  TIMEFRAME_MS,
+} from "../sessions-cache.js";
+
+const router = express.Router();
+
+/**
+ * GET /api/sessions/list
+ *
+ * Query Parameters:
+ * - timeframe: '1h' | '8h' | '1d' | '1w' | '2w' | '1m' | 'all' (default: '1w')
+ *
+ * Headers:
+ * - If-None-Match: ETag from previous response (for 304 support)
+ *
+ * Response:
+ * - 304 Not Modified (if ETag matches)
+ * - 200 OK with sessions data
+ */
+router.get("/list", (req, res) => {
+  try {
+    // Check if cache is initialized
+    if (!isCacheInitialized()) {
+      return res.status(503).json({
+        error: "Sessions cache not yet initialized",
+        message: "Please wait for initial project scan to complete",
+      });
+    }
+
+    // Get timeframe from query (validate against known values)
+    const timeframe =
+      TIMEFRAME_MS[req.query.timeframe] !== undefined
+        ? req.query.timeframe
+        : "1w";
+
+    // Generate current ETag
+    const currentETag = generateETag(timeframe);
+
+    // Check If-None-Match header for conditional request
+    const clientETag = req.headers["if-none-match"];
+    if (clientETag && clientETag === currentETag) {
+      // Data hasn't changed - return 304
+      return res.status(304).end();
+    }
+
+    // Get sessions filtered by timeframe
+    const { sessions, totalCount, filteredCount } =
+      getSessionsByTimeframe(timeframe);
+    const cacheMeta = getCacheMeta();
+
+    // Set caching headers
+    res.set({
+      "Cache-Control": "private, max-age=10",
+      ETag: currentETag,
+    });
+
+    // Return sessions data
+    res.json({
+      sessions,
+      meta: {
+        totalCount,
+        filteredCount,
+        timeframe,
+        cacheTimestamp: cacheMeta.timestamp,
+      },
+    });
+  } catch (error) {
+    console.error("[ERROR] Sessions list endpoint error:", error);
+    res.status(500).json({
+      error: "Failed to retrieve sessions",
+      message: error.message,
+    });
+  }
+});
+
+/**
+ * GET /api/sessions/cache-status
+ * Returns current cache status (for debugging/monitoring)
+ */
+router.get("/cache-status", (req, res) => {
+  try {
+    const meta = getCacheMeta();
+    res.json({
+      initialized: isCacheInitialized(),
+      ...meta,
+    });
+  } catch (error) {
+    res.status(500).json({ error: error.message });
+  }
+});
+
+export default router;