termbeam 1.18.1 → 1.19.1

package/src/utils/agent-sessions.js

@@ -0,0 +1,288 @@
+const fs = require('fs');
+const path = require('path');
+const os = require('os');
+const log = require('./logger');
+
+/**
+ * Read Copilot sessions from SQLite store.
+ * Returns array of { id, agent, summary, cwd, repo, branch, updatedAt, turnCount }
+ */
+function readCopilotSessions(limit = 50) {
+  let Database;
+  try {
+    Database = require('better-sqlite3');
+  } catch {
+    return [];
+  }
+  const dbPath = path.join(os.homedir(), '.copilot', 'session-store.db');
+  if (!fs.existsSync(dbPath)) return [];
+
+  try {
+    const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+    const sessions = db
+      .prepare(
+        `
+      SELECT s.id, s.summary, s.cwd, s.repository, s.branch, s.updated_at,
+             (SELECT COUNT(*) FROM turns t WHERE t.session_id = s.id) as turn_count,
+             (SELECT substr(t.user_message, 1, 200) FROM turns t WHERE t.session_id = s.id ORDER BY t.turn_index ASC LIMIT 1) as first_msg
+      FROM sessions s
+      ORDER BY s.updated_at DESC
+      LIMIT ?
+    `,
+      )
+      .all(limit);
+    db.close();
+
+    return sessions
+      .filter((s) => s.turn_count > 0)
+      .map((s) => ({
+        id: s.id,
+        agent: 'copilot',
+        agentName: 'GitHub Copilot',
+        agentIcon: 'copilot',
+        summary: s.summary || s.first_msg || null,
+        cwd: s.cwd || null,
+        repo: s.repository || null,
+        branch: s.branch || null,
+        updatedAt: s.updated_at || null,
+        turnCount: s.turn_count || 0,
+      }));
+  } catch (err) {
+    log.warn(`Failed to read Copilot sessions: ${err.message}`);
+    return [];
+  }
+}
+
+/**
+ * Read Claude Code sessions from JSONL files.
+ * Returns array of unified session objects.
+ */
+function readClaudeSessions(limit = 50) {
+  const baseDir = path.join(os.homedir(), '.claude', 'projects');
+  if (!fs.existsSync(baseDir)) return [];
+
+  try {
+    const sessions = [];
+    const projectDirs = fs.readdirSync(baseDir);
+
+    for (const projDir of projectDirs) {
+      const fullProjDir = path.join(baseDir, projDir);
+      try {
+        if (!fs.statSync(fullProjDir).isDirectory()) continue;
+      } catch {
+        continue; // Directory may have been removed
+      }
+
+      // Decode CWD from directory name: -Users-foo-bar → /Users/foo/bar
+      const cwd = projDir.replace(/^-/, '/').replace(/-/g, '/');
+
+      const jsonlFiles = fs
+        .readdirSync(fullProjDir)
+        .filter((f) => f.endsWith('.jsonl'))
+        .map((f) => {
+          const fullPath = path.join(fullProjDir, f);
+          const stat = fs.statSync(fullPath);
+          return { file: f, path: fullPath, mtime: stat.mtime, size: stat.size };
+        })
+        .sort((a, b) => b.mtime - a.mtime);
+
+      for (const fileInfo of jsonlFiles.slice(0, 10)) {
+        try {
+          const sessionId = path.basename(fileInfo.file, '.jsonl');
+
+          // Read file — cap at 100KB to avoid blocking the event loop on large JSONL files
+          let content;
+          if (fileInfo.size > 100_000) {
+            const fd = fs.openSync(fileInfo.path, 'r');
+            const buf = Buffer.alloc(100_000);
+            const bytesRead = fs.readSync(fd, buf, 0, 100_000, 0);
+            fs.closeSync(fd);
+            content = buf.toString('utf8', 0, bytesRead);
+          } else {
+            content = fs.readFileSync(fileInfo.path, 'utf8');
+          }
+          const rawLines = content.split('\n');
+
+          let cwdFromFile = cwd;
+          let branch = null;
+          let userTurnCount = 0;
+          let firstUserMsg = null;
+
+          for (const line of rawLines) {
+            if (!line.trim()) continue;
+            try {
+              const entry = JSON.parse(line);
+              if (!branch && entry.gitBranch) branch = entry.gitBranch;
+              if (entry.cwd) cwdFromFile = entry.cwd;
+              if (entry.type === 'user') {
+                userTurnCount++;
+                if (!firstUserMsg) {
+                  // Claude stores user message at entry.message.content (not entry.data)
+                  const msg = entry.message;
+                  if (msg && typeof msg === 'object') {
+                    const content = msg.content;
+                    if (typeof content === 'string') {
+                      // Skip meta/command messages (XML-tagged system entries)
+                      if (!content.startsWith('<') && content.trim().length > 5) {
+                        firstUserMsg = content.slice(0, 200);
+                      }
+                    } else if (Array.isArray(content)) {
+                      for (const item of content) {
+                        if (item && item.type === 'text' && typeof item.text === 'string') {
+                          if (!item.text.startsWith('<') && item.text.trim().length > 5) {
+                            firstUserMsg = item.text.slice(0, 200);
+                            break;
+                          }
+                        }
+                      }
+                    }
+                  }
+                }
+              }
+            } catch {
+              // skip malformed line
+            }
+          }
+
+          // Skip empty sessions (no user interaction)
+          if (userTurnCount === 0) continue;
+
+          sessions.push({
+            id: sessionId,
+            agent: 'claude',
+            agentName: 'Claude Code',
+            agentIcon: 'claude',
+            summary: firstUserMsg || null,
+            cwd: cwdFromFile,
+            repo: null,
+            branch,
+            updatedAt: fileInfo.mtime.toISOString(),
+            turnCount: userTurnCount,
+          });
+        } catch (err) {
+          log.debug(`Failed to parse Claude session ${fileInfo.file}: ${err.message}`);
+        }
+      }
+    }
+
+    // Sort by updated time descending
+    sessions.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+    return sessions.slice(0, limit);
+  } catch (err) {
+    log.warn(`Failed to read Claude sessions: ${err.message}`);
+    return [];
+  }
+}
+
+/**
+ * Read OpenCode sessions from SQLite store.
+ * DB at ~/.local/share/opencode/opencode.db
+ */
+function readOpenCodeSessions(limit = 50) {
+  let Database;
+  try {
+    Database = require('better-sqlite3');
+  } catch {
+    return [];
+  }
+  const dbPath = path.join(os.homedir(), '.local', 'share', 'opencode', 'opencode.db');
+  if (!fs.existsSync(dbPath)) return [];
+
+  try {
+    const db = new Database(dbPath, { readonly: true, fileMustExist: true });
+    const sessions = db
+      .prepare(
+        `
+      SELECT s.id, s.title, s.directory, s.time_created, s.time_updated,
+             (SELECT COUNT(*) FROM message m WHERE m.session_id = s.id) as msg_count
+      FROM session s
+      WHERE s.time_archived IS NULL
+      ORDER BY s.time_updated DESC
+      LIMIT ?
+    `,
+      )
+      .all(limit);
+    db.close();
+
+    return sessions
+      .filter((s) => s.msg_count > 0)
+      .map((s) => ({
+        id: s.id,
+        agent: 'opencode',
+        agentName: 'OpenCode',
+        agentIcon: 'opencode',
+        summary: s.title || null,
+        cwd: s.directory || null,
+        repo: null,
+        branch: null,
+        updatedAt: s.time_updated || s.time_created || null,
+        turnCount: s.msg_count || 0,
+      }));
+  } catch (err) {
+    log.warn(`Failed to read OpenCode sessions: ${err.message}`);
+    return [];
+  }
+}
+
+/**
+ * Get all agent sessions from all sources, unified and sorted.
+ */
+async function getAgentSessions({ limit = 100, agent = null, search = null } = {}) {
+  const results = [];
+
+  if (!agent || agent === 'copilot') {
+    results.push(...readCopilotSessions(limit));
+  }
+  if (!agent || agent === 'claude') {
+    results.push(...readClaudeSessions(limit));
+  }
+  if (!agent || agent === 'opencode') {
+    results.push(...readOpenCodeSessions(limit));
+  }
+
+  // Sort all by updatedAt descending
+  results.sort((a, b) => new Date(b.updatedAt) - new Date(a.updatedAt));
+
+  // Apply search filter (case-insensitive substring match)
+  if (search) {
+    const q = search.toLowerCase();
+    const filtered = results.filter(
+      (s) =>
+        (s.summary && s.summary.toLowerCase().includes(q)) ||
+        (s.cwd && s.cwd.toLowerCase().includes(q)) ||
+        (s.repo && s.repo.toLowerCase().includes(q)) ||
+        (s.branch && s.branch.toLowerCase().includes(q)),
+    );
+    return filtered.slice(0, limit);
+  }
+
+  return results.slice(0, limit);
+}
+
+/**
+ * Build the resume command for a given agent session.
+ */
+function getResumeCommand(session) {
+  // Validate session ID to prevent command injection
+  // UUID format for copilot/claude, ses_xxx format for opencode
+  if (!/^[a-z0-9_-]{8,}$/i.test(session.id)) return null;
+
+  switch (session.agent) {
+    case 'copilot':
+      return `copilot --resume=${session.id}`;
+    case 'claude':
+      return `claude --resume ${session.id}`;
+    case 'opencode':
+      return `opencode --session ${session.id}`;
+    default:
+      return null;
+  }
+}
+
+module.exports = {
+  getAgentSessions,
+  getResumeCommand,
+  readCopilotSessions,
+  readClaudeSessions,
+  readOpenCodeSessions,
+};

package/src/utils/agents.js

@@ -0,0 +1,118 @@
+const child_process = require('child_process');
+const os = require('os');
+const log = require('./logger');
+
+const KNOWN_AGENTS = [
+  {
+    id: 'copilot',
+    name: 'GitHub Copilot',
+    cmd: 'copilot',
+    icon: 'copilot',
+    detect: ['copilot', ['--version']],
+  },
+  {
+    id: 'gh-copilot',
+    name: 'GitHub Copilot (gh)',
+    cmd: 'gh',
+    args: ['copilot'],
+    icon: 'copilot',
+    detect: ['gh', ['copilot', '--version']],
+  },
+  {
+    id: 'claude',
+    name: 'Claude Code',
+    cmd: 'claude',
+    icon: 'claude',
+    detect: ['claude', ['--version']],
+  },
+  {
+    id: 'aider',
+    name: 'Aider',
+    cmd: 'aider',
+    icon: 'aider',
+    detect: ['aider', ['--version']],
+  },
+  {
+    id: 'codex',
+    name: 'Codex CLI',
+    cmd: 'codex',
+    icon: 'codex',
+    detect: ['codex', ['--version']],
+  },
+  {
+    id: 'opencode',
+    name: 'OpenCode',
+    cmd: 'opencode',
+    icon: 'opencode',
+    detect: ['opencode', ['--version']],
+  },
+];
+
+let cachedAgents = null;
+let cacheTime = 0;
+const CACHE_TTL = 60_000; // 60 seconds
+
+function tryDetectAgent(agent) {
+  const [cmd, args] = agent.detect;
+  const isWindows = os.platform() === 'win32';
+  const candidates = isWindows ? [cmd, `${cmd}.cmd`, `${cmd}.exe`] : [cmd];
+
+  return new Promise((resolve) => {
+    let resolved = false;
+    let remaining = candidates.length;
+
+    for (const bin of candidates) {
+      child_process.execFile(bin, args, { timeout: 5000, encoding: 'utf8' }, (err, stdout) => {
+        remaining--;
+        if (resolved) return;
+        if (!err) {
+          resolved = true;
+          const version = (stdout || '').trim().split('\n')[0] || 'unknown';
+          resolve({
+            id: agent.id,
+            name: agent.name,
+            cmd: agent.cmd,
+            args: agent.args || [],
+            icon: agent.icon,
+            version,
+          });
+        } else if (remaining === 0) {
+          resolve(null);
+        }
+      });
+    }
+  });
+}
+
+async function detectAgents() {
+  log.debug('Detecting available AI agents...');
+  const results = await Promise.allSettled(KNOWN_AGENTS.map(tryDetectAgent));
+
+  const agents = [];
+  for (const result of results) {
+    if (result.status === 'fulfilled' && result.value) {
+      agents.push(result.value);
+    }
+  }
+
+  // Deduplicate: prefer standalone copilot over gh copilot
+  const hasCopilot = agents.some((a) => a.id === 'copilot');
+  const deduped = hasCopilot ? agents.filter((a) => a.id !== 'gh-copilot') : agents;
+
+  log.debug(
+    `Detected ${deduped.length} AI agent(s): ${deduped.map((a) => a.name).join(', ') || 'none'}`,
+  );
+  return deduped;
+}
+
+async function getAvailableAgents() {
+  const now = Date.now();
+  if (cachedAgents && now - cacheTime < CACHE_TTL) {
+    return cachedAgents;
+  }
+  cachedAgents = await detectAgents();
+  cacheTime = Date.now();
+  return cachedAgents;
+}
+
+module.exports = { detectAgents, getAvailableAgents, KNOWN_AGENTS };

package/src/utils/update-check.js

@@ -78,6 +78,16 @@ function normalizeVersion(version) {
  * Returns false if either version cannot be parsed.
  */
 function isNewerVersion(current, latest) {
+  // Dev builds (e.g. 1.18.1-dev+dirty) of the same base version are running
+  // from source — never prompt to "update" to the same stable release.
+  if (isDevBuild(current)) {
+    const cur = normalizeVersion(current);
+    const lat = normalizeVersion(latest);
+    if (!cur || !lat) return false;
+    const sameBase = cur[0] === lat[0] && cur[1] === lat[1] && cur[2] === lat[2];
+    if (sameBase) return false;
+    // Different base version — fall through to normal comparison
+  }
   const cur = normalizeVersion(current);
   const lat = normalizeVersion(latest);
   if (!cur || !lat) return false;
@@ -104,6 +114,15 @@ function isPreRelease(version) {
   return v.includes('-');
 }
 
+/**
+ * Check if a version is a local dev build (e.g. "1.18.1-dev+dirty", "1.18.1-dev.3+abcdef").
+ * Dev builds should never trigger update prompts — they're running from source.
+ */
+function isDevBuild(version) {
+  if (typeof version !== 'string') return false;
+  return /-(dev|dirty)/.test(version) || /\+(dirty|dev)/.test(version);
+}
+
 /**
  * Strip ANSI escape sequences and control characters from a string.
  * Prevents terminal injection if the registry returns malicious data.