@epiphytic/claudecodeui 1.1.0 → 1.2.1

package/server/database/db.js

@@ -120,6 +120,27 @@ const runMigrations = () => {
       `);
     }
 
+    // Check if orchestrator_tokens table exists
+    const orchestratorTokensTable = db
+      .prepare(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='orchestrator_tokens'",
+      )
+      .all();
+    if (orchestratorTokensTable.length === 0) {
+      console.log("Running migration: Creating orchestrator_tokens table");
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS orchestrator_tokens (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          host TEXT NOT NULL UNIQUE,
+          token TEXT NOT NULL,
+          client_id TEXT,
+          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+          updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+        );
+        CREATE INDEX IF NOT EXISTS idx_orchestrator_tokens_host ON orchestrator_tokens(host);
+      `);
+    }
+
     console.log("Database migrations completed successfully");
   } catch (error) {
     console.error("Error running migrations:", error.message);
@@ -642,6 +663,82 @@ const tmuxSessionsDb = {
   },
 };
 
+// Orchestrator tokens database operations (for storing tokens received during pending mode)
+const orchestratorTokensDb = {
+  /**
+   * Get stored orchestrator token for a specific host
+   * @param {string} host - The orchestrator host (e.g., "duratii.example.com")
+   * @returns {{token: string, client_id: string} | null}
+   */
+  getToken: (host) => {
+    try {
+      const row = db
+        .prepare(
+          "SELECT token, client_id FROM orchestrator_tokens WHERE host = ?",
+        )
+        .get(host);
+      return row || null;
+    } catch (err) {
+      throw err;
+    }
+  },
+
+  /**
+   * Save or update orchestrator token for a host
+   * @param {string} host - The orchestrator host
+   * @param {string} token - The full token string
+   * @param {string} clientId - The client ID from orchestrator
+   */
+  saveToken: (host, token, clientId) => {
+    try {
+      const stmt = db.prepare(`
+        INSERT INTO orchestrator_tokens (host, token, client_id, updated_at)
+        VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+        ON CONFLICT(host) DO UPDATE SET
+          token = excluded.token,
+          client_id = excluded.client_id,
+          updated_at = CURRENT_TIMESTAMP
+      `);
+      stmt.run(host, token, clientId);
+      return true;
+    } catch (err) {
+      throw err;
+    }
+  },
+
+  /**
+   * Delete orchestrator token for a host
+   * @param {string} host - The orchestrator host
+   * @returns {boolean} True if a token was deleted
+   */
+  deleteToken: (host) => {
+    try {
+      const stmt = db.prepare("DELETE FROM orchestrator_tokens WHERE host = ?");
+      const result = stmt.run(host);
+      return result.changes > 0;
+    } catch (err) {
+      throw err;
+    }
+  },
+
+  /**
+   * Get all stored orchestrator tokens
+   * @returns {Array<{id: number, host: string, client_id: string, created_at: string, updated_at: string}>}
+   */
+  getAllTokens: () => {
+    try {
+      const rows = db
+        .prepare(
+          "SELECT id, host, client_id, created_at, updated_at FROM orchestrator_tokens ORDER BY updated_at DESC",
+        )
+        .all();
+      return rows;
+    } catch (err) {
+      throw err;
+    }
+  },
+};
+
 // Backward compatibility - keep old names pointing to new system
 const githubTokensDb = {
   createGithubToken: (userId, tokenName, githubToken, description = null) => {
@@ -675,4 +772,5 @@ export {
   credentialsDb,
   githubTokensDb, // Backward compatibility
   tmuxSessionsDb,
+  orchestratorTokensDb,
 };

package/server/database/init.sql

@@ -65,4 +65,16 @@ CREATE TABLE IF NOT EXISTS tmux_sessions (
 );
 
 CREATE INDEX IF NOT EXISTS idx_tmux_sessions_project ON tmux_sessions(project_path);
-CREATE INDEX IF NOT EXISTS idx_tmux_sessions_name ON tmux_sessions(tmux_session_name);
+CREATE INDEX IF NOT EXISTS idx_tmux_sessions_name ON tmux_sessions(tmux_session_name);
+
+-- Orchestrator tokens table for storing tokens received from orchestrator during pending mode
+CREATE TABLE IF NOT EXISTS orchestrator_tokens (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    host TEXT NOT NULL UNIQUE,          -- e.g., "duratii.example.com"
+    token TEXT NOT NULL,                 -- Full token string (ao_xxx_yyy)
+    client_id TEXT,                      -- Client ID assigned by orchestrator
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    updated_at DATETIME DEFAULT CURRENT_TIMESTAMP
+);
+
+CREATE INDEX IF NOT EXISTS idx_orchestrator_tokens_host ON orchestrator_tokens(host);

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) {