@epiphytic/claudecodeui 1.0.1 → 1.2.0

package/server/database/db.js

@@ -97,6 +97,50 @@ const runMigrations = () => {
       );
     }
 
+    // Check if tmux_sessions table exists
+    const tables = db
+      .prepare(
+        "SELECT name FROM sqlite_master WHERE type='table' AND name='tmux_sessions'",
+      )
+      .all();
+    if (tables.length === 0) {
+      console.log("Running migration: Creating tmux_sessions table");
+      db.exec(`
+        CREATE TABLE IF NOT EXISTS tmux_sessions (
+          id INTEGER PRIMARY KEY AUTOINCREMENT,
+          project_path TEXT NOT NULL,
+          session_id TEXT,
+          tmux_session_name TEXT NOT NULL,
+          created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+          last_used DATETIME DEFAULT CURRENT_TIMESTAMP,
+          UNIQUE(project_path, session_id)
+        );
+        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);
+      `);
+    }
+
+    // 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);
@@ -519,6 +563,182 @@ const credentialsDb = {
   },
 };
 
+// tmux sessions database operations (for persisting shell session mappings)
+const tmuxSessionsDb = {
+  // Get tmux session name for a project+session combo
+  getTmuxSession: (projectPath, sessionId) => {
+    try {
+      const row = db
+        .prepare(
+          "SELECT tmux_session_name FROM tmux_sessions WHERE project_path = ? AND (session_id = ? OR (session_id IS NULL AND ? IS NULL))",
+        )
+        .get(projectPath, sessionId, sessionId);
+      return row?.tmux_session_name || null;
+    } catch (err) {
+      throw err;
+    }
+  },
+
+  // Save or update tmux session mapping
+  saveTmuxSession: (projectPath, sessionId, tmuxSessionName) => {
+    try {
+      const stmt = db.prepare(`
+        INSERT INTO tmux_sessions (project_path, session_id, tmux_session_name, last_used)
+        VALUES (?, ?, ?, CURRENT_TIMESTAMP)
+        ON CONFLICT(project_path, session_id) DO UPDATE SET
+          tmux_session_name = excluded.tmux_session_name,
+          last_used = CURRENT_TIMESTAMP
+      `);
+      stmt.run(projectPath, sessionId, tmuxSessionName);
+      return true;
+    } catch (err) {
+      throw err;
+    }
+  },
+
+  // Update last_used timestamp
+  touchTmuxSession: (projectPath, sessionId) => {
+    try {
+      db.prepare(
+        "UPDATE tmux_sessions SET last_used = CURRENT_TIMESTAMP WHERE project_path = ? AND (session_id = ? OR (session_id IS NULL AND ? IS NULL))",
+      ).run(projectPath, sessionId, sessionId);
+    } catch (err) {
+      throw err;
+    }
+  },
+
+  // Delete a tmux session mapping
+  deleteTmuxSession: (projectPath, sessionId) => {
+    try {
+      const stmt = db.prepare(
+        "DELETE FROM tmux_sessions WHERE project_path = ? AND (session_id = ? OR (session_id IS NULL AND ? IS NULL))",
+      );
+      const result = stmt.run(projectPath, sessionId, sessionId);
+      return result.changes > 0;
+    } catch (err) {
+      throw err;
+    }
+  },
+
+  // Delete by tmux session name
+  deleteByTmuxName: (tmuxSessionName) => {
+    try {
+      const stmt = db.prepare(
+        "DELETE FROM tmux_sessions WHERE tmux_session_name = ?",
+      );
+      const result = stmt.run(tmuxSessionName);
+      return result.changes > 0;
+    } catch (err) {
+      throw err;
+    }
+  },
+
+  // Get all tmux sessions for cleanup
+  getAllTmuxSessions: () => {
+    try {
+      const rows = db
+        .prepare(
+          "SELECT id, project_path, session_id, tmux_session_name, created_at, last_used FROM tmux_sessions ORDER BY last_used DESC",
+        )
+        .all();
+      return rows;
+    } catch (err) {
+      throw err;
+    }
+  },
+
+  // Delete multiple sessions by their IDs
+  deleteByIds: (ids) => {
+    try {
+      if (!ids || ids.length === 0) return 0;
+      const placeholders = ids.map(() => "?").join(",");
+      const stmt = db.prepare(
+        `DELETE FROM tmux_sessions WHERE id IN (${placeholders})`,
+      );
+      const result = stmt.run(...ids);
+      return result.changes;
+    } catch (err) {
+      throw err;
+    }
+  },
+};
+
+// 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) => {
@@ -551,4 +771,6 @@ export {
   apiKeysDb,
   credentialsDb,
   githubTokensDb, // Backward compatibility
+  tmuxSessionsDb,
+  orchestratorTokensDb,
 };

package/server/database/init.sql

@@ -51,4 +51,30 @@ CREATE TABLE IF NOT EXISTS user_credentials (
 
 CREATE INDEX IF NOT EXISTS idx_user_credentials_user_id ON user_credentials(user_id);
 CREATE INDEX IF NOT EXISTS idx_user_credentials_type ON user_credentials(credential_type);
-CREATE INDEX IF NOT EXISTS idx_user_credentials_active ON user_credentials(is_active);
+CREATE INDEX IF NOT EXISTS idx_user_credentials_active ON user_credentials(is_active);
+
+-- tmux sessions table for persisting shell session mappings across server restarts
+CREATE TABLE IF NOT EXISTS tmux_sessions (
+    id INTEGER PRIMARY KEY AUTOINCREMENT,
+    project_path TEXT NOT NULL,
+    session_id TEXT,  -- null for plain shell sessions
+    tmux_session_name TEXT NOT NULL,
+    created_at DATETIME DEFAULT CURRENT_TIMESTAMP,
+    last_used DATETIME DEFAULT CURRENT_TIMESTAMP,
+    UNIQUE(project_path, session_id)
+);
+
+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);
+
+-- 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

@@ -0,0 +1,403 @@
+/**
+ * External Claude Session Detector
+ *
+ * Detects Claude CLI sessions running outside of this application.
+ * This helps prevent conflicts when users have both the UI and CLI
+ * running simultaneously on the same project.
+ *
+ * Detection methods:
+ * 1. Process detection via pgrep/ps
+ * 2. tmux session scanning
+ * 3. Session lock file detection (.claude/session.lock)
+ */
+
+import { spawnSync } from "child_process";
+import fs from "fs";
+import path from "path";
+import os from "os";
+
+// Cache to avoid repeated process scans
+const detectionCache = new Map();
+const CACHE_TTL = 5000; // 5 seconds
+
+/**
+ * Get the current process ID (for exclusion)
+ */
+const currentPid = process.pid;
+
+/**
+ * Detect external Claude processes
+ * @returns {Array<{ pid: number, command: string, cwd: string | null }>}
+ */
+function detectClaudeProcesses() {
+  const processes = [];
+
+  if (os.platform() === "win32") {
+    // Windows: use wmic or tasklist
+    try {
+      const result = spawnSync(
+        "wmic",
+        [
+          "process",
+          "where",
+          "name like '%claude%'",
+          "get",
+          "processid,commandline",
+        ],
+        { encoding: "utf8", stdio: "pipe" },
+      );
+
+      if (result.status === 0) {
+        const lines = result.stdout.trim().split("\n").slice(1); // Skip header
+        for (const line of lines) {
+          const match = line.match(/(\d+)\s*$/);
+          if (match) {
+            const pid = parseInt(match[1], 10);
+            if (pid !== currentPid) {
+              processes.push({ pid, command: line.trim(), cwd: null });
+            }
+          }
+        }
+      }
+    } catch {
+      // Ignore errors on Windows
+    }
+  } else {
+    // Unix: use pgrep and ps
+    try {
+      // First, get PIDs of claude processes
+      const pgrepResult = spawnSync("pgrep", ["-f", "claude"], {
+        encoding: "utf8",
+        stdio: "pipe",
+      });
+
+      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="], {
+            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];
+                  }
+                }
+              } catch {
+                // lsof may not be available
+              }
+
+              processes.push({ pid, command, cwd });
+            }
+          }
+        }
+      }
+    } catch {
+      // Ignore errors
+    }
+  }
+
+  return processes;
+}
+
+/**
+ * Check if a command is an external Claude process (not spawned by us)
+ * @param {string} command - The process command line
+ * @returns {boolean}
+ */
+function isExternalClaudeProcess(command) {
+  // Skip node processes (SDK internals)
+  if (command.startsWith("node ")) return false;
+
+  // Skip our own server
+  if (command.includes("claudecodeui/server")) return false;
+
+  // Look for actual claude CLI invocations
+  return (
+    command.includes("claude ") ||
+    command.includes("claude-code") ||
+    command.match(/\/claude\s/) ||
+    command.endsWith("/claude")
+  );
+}
+
+/**
+ * Detect tmux sessions that might be running Claude
+ * @returns {Array<{ sessionName: string, windows: number, attached: boolean }>}
+ */
+function detectClaudeTmuxSessions() {
+  const sessions = [];
+
+  try {
+    const result = spawnSync(
+      "tmux",
+      [
+        "list-sessions",
+        "-F",
+        "#{session_name}:#{session_windows}:#{session_attached}",
+      ],
+      { encoding: "utf8", stdio: "pipe" },
+    );
+
+    if (result.status === 0) {
+      const lines = result.stdout.trim().split("\n").filter(Boolean);
+
+      for (const line of lines) {
+        const [sessionName, windows, attached] = line.split(":");
+
+        // Skip our own sessions
+        if (sessionName.startsWith("claudeui-")) continue;
+
+        // Check if session might be running Claude
+        // We can peek at the pane content or just check window titles
+        if (mightBeClaudeSession(sessionName)) {
+          sessions.push({
+            sessionName,
+            windows: parseInt(windows, 10),
+            attached: attached === "1",
+          });
+        }
+      }
+    }
+  } catch {
+    // tmux not available or no server running
+  }
+
+  return sessions;
+}
+
+/**
+ * Heuristic check if a tmux session might be running Claude
+ * @param {string} sessionName - The session name
+ * @returns {boolean}
+ */
+function mightBeClaudeSession(sessionName) {
+  // Check common patterns
+  const claudePatterns = ["claude", "ai", "chat", "code"];
+  const lowerName = sessionName.toLowerCase();
+
+  for (const pattern of claudePatterns) {
+    if (lowerName.includes(pattern)) return true;
+  }
+
+  // Try to peek at the session's current command
+  try {
+    const result = spawnSync(
+      "tmux",
+      ["display-message", "-t", sessionName, "-p", "#{pane_current_command}"],
+      { encoding: "utf8", stdio: "pipe" },
+    );
+
+    if (result.status === 0) {
+      const currentCommand = result.stdout.trim().toLowerCase();
+      if (currentCommand.includes("claude")) return true;
+    }
+  } catch {
+    // Ignore
+  }
+
+  return false;
+}
+
+/**
+ * Check for session lock files in a project directory
+ * @param {string} projectPath - The project directory to check
+ * @returns {{ exists: boolean, lockFile: string | null, content: object | null }}
+ */
+function checkSessionLockFile(projectPath) {
+  const lockFile = path.join(projectPath, ".claude", "session.lock");
+
+  try {
+    if (fs.existsSync(lockFile)) {
+      const content = fs.readFileSync(lockFile, "utf8");
+      try {
+        const lockData = JSON.parse(content);
+
+        // Check if the lock is stale (process no longer exists)
+        if (lockData.pid) {
+          const isAlive = processExists(lockData.pid);
+          if (!isAlive) {
+            // Stale lock file, clean it up
+            try {
+              fs.unlinkSync(lockFile);
+            } catch {
+              // Ignore cleanup errors
+            }
+            return { exists: false, lockFile: null, content: null };
+          }
+        }
+
+        return { exists: true, lockFile, content: lockData };
+      } catch {
+        // Invalid JSON, treat as text lock
+        return { exists: true, lockFile, content: { raw: content } };
+      }
+    }
+  } catch {
+    // Cannot read lock file
+  }
+
+  return { exists: false, lockFile: null, content: null };
+}
+
+/**
+ * Check if a process exists
+ * @param {number} pid - Process ID
+ * @returns {boolean}
+ */
+function processExists(pid) {
+  try {
+    // Sending signal 0 checks if process exists without actually sending a signal
+    process.kill(pid, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * 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 }}
+ */
+function detectExternalClaude(projectPath) {
+  // Check cache
+  const cacheKey = projectPath || "__global__";
+  const cached = detectionCache.get(cacheKey);
+  if (cached && Date.now() - cached.timestamp < CACHE_TTL) {
+    return cached.result;
+  }
+
+  const result = {
+    hasExternalSession: false,
+    processes: [],
+    tmuxSessions: [],
+    lockFile: { exists: false, lockFile: null, content: null },
+  };
+
+  // Detect processes
+  result.processes = detectClaudeProcesses();
+  if (projectPath) {
+    // Filter to processes in this project
+    result.processes = result.processes.filter(
+      (p) => !p.cwd || p.cwd.startsWith(projectPath),
+    );
+  }
+
+  // Detect tmux sessions
+  result.tmuxSessions = detectClaudeTmuxSessions();
+
+  // Check lock file
+  if (projectPath) {
+    result.lockFile = checkSessionLockFile(projectPath);
+  }
+
+  // Determine if there's an external session
+  result.hasExternalSession =
+    result.processes.length > 0 ||
+    result.tmuxSessions.length > 0 ||
+    result.lockFile.exists;
+
+  // Cache the result
+  detectionCache.set(cacheKey, {
+    timestamp: Date.now(),
+    result,
+  });
+
+  return result;
+}
+
+/**
+ * Clear the detection cache
+ */
+function clearCache() {
+  detectionCache.clear();
+}
+
+/**
+ * Create a session lock file for this application
+ * @param {string} projectPath - The project directory
+ * @param {string} sessionId - The session ID
+ * @returns {boolean}
+ */
+function createSessionLock(projectPath, sessionId) {
+  const claudeDir = path.join(projectPath, ".claude");
+  const lockFile = path.join(claudeDir, "session.lock");
+
+  try {
+    // Ensure .claude directory exists
+    if (!fs.existsSync(claudeDir)) {
+      fs.mkdirSync(claudeDir, { recursive: true });
+    }
+
+    const lockData = {
+      pid: process.pid,
+      sessionId,
+      createdAt: new Date().toISOString(),
+      app: "claudecodeui",
+    };
+
+    fs.writeFileSync(lockFile, JSON.stringify(lockData, null, 2));
+    return true;
+  } catch (err) {
+    console.error(
+      "[ExternalSessionDetector] Failed to create lock file:",
+      err.message,
+    );
+    return false;
+  }
+}
+
+/**
+ * Remove a session lock file
+ * @param {string} projectPath - The project directory
+ * @returns {boolean}
+ */
+function removeSessionLock(projectPath) {
+  const lockFile = path.join(projectPath, ".claude", "session.lock");
+
+  try {
+    if (fs.existsSync(lockFile)) {
+      fs.unlinkSync(lockFile);
+    }
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+export {
+  detectExternalClaude,
+  detectClaudeProcesses,
+  detectClaudeTmuxSessions,
+  checkSessionLockFile,
+  createSessionLock,
+  removeSessionLock,
+  clearCache,
+};