termbeam 1.18.0 → 1.19.0

package/src/server/routes.js

@@ -4,6 +4,8 @@ const fs = require('fs');
 const crypto = require('crypto');
 const express = require('express');
 const { detectShells } = require('../utils/shells');
+const { getAvailableAgents } = require('../utils/agents');
+const { getAgentSessions, getResumeCommand } = require('../utils/agent-sessions');
 const log = require('../utils/logger');
 const rateLimit = require('express-rate-limit');
 
@@ -362,6 +364,44 @@ function setupRoutes(app, { auth, sessions, config, state, pushManager }) {
     res.json({ shells, default: match ? match.cmd : ds, cwd: config.cwd });
   });
 
+  // Available AI agents
+  app.get('/api/agents', apiRateLimit, auth.middleware, async (_req, res) => {
+    try {
+      const agents = await getAvailableAgents();
+      res.json({ agents });
+    } catch (err) {
+      log.warn(`Agent detection failed: ${err.message}`);
+      res.json({ agents: [] });
+    }
+  });
+
+  // Agent session history (for resume)
+  app.get('/api/agent-sessions', apiRateLimit, auth.middleware, async (req, res) => {
+    try {
+      const limit = Math.min(Math.max(parseInt(req.query.limit, 10) || 100, 1), 500);
+      const agent = req.query.agent || null;
+      const search = req.query.search || null;
+      const sessions = await getAgentSessions({ limit, agent, search });
+      res.json({ sessions });
+    } catch (err) {
+      log.warn(`Failed to read agent sessions: ${err.message}`);
+      res.json({ sessions: [] });
+    }
+  });
+
+  // Get resume command for a specific session
+  app.get(
+    '/api/agent-sessions/:agent/:id/resume-command',
+    apiRateLimit,
+    auth.middleware,
+    (req, res) => {
+      const { agent, id } = req.params;
+      const command = getResumeCommand({ agent, id });
+      if (!command) return res.status(400).json({ error: 'Unknown agent' });
+      res.json({ command });
+    },
+  );
+
   app.get('/api/sessions/:id/detect-port', auth.middleware, (req, res) => {
     log.debug(`Port detection requested for session ${req.params.id}`);
     const session = sessions.get(req.params.id);
@@ -595,7 +635,7 @@ function setupRoutes(app, { auth, sessions, config, state, pushManager }) {
       return res.status(400).json({ error: 'Invalid dir parameter' });
     }
 
-    const rootDir = path.resolve(session.cwd);
+    const rootDir = path.resolve(sessions.getSessionCwd(req.params.id));
     const dir = path.resolve(rootDir, req.query.dir || '.');
 
     const MAX_ENTRIES = 1000;
@@ -666,7 +706,7 @@ function setupRoutes(app, { auth, sessions, config, state, pushManager }) {
       depth = parsedDepth;
     }
     depth = Math.min(Math.max(depth, 1), MAX_DEPTH);
-    const rootDir = path.resolve(session.cwd);
+    const rootDir = path.resolve(sessions.getSessionCwd(req.params.id));
     let totalEntries = 0;
 
     function buildTree(dir, currentDepth) {
@@ -749,7 +789,7 @@ function setupRoutes(app, { auth, sessions, config, state, pushManager }) {
       return res.status(400).json({ error: 'Missing file parameter' });
     }
 
-    const rootDir = path.resolve(session.cwd);
+    const rootDir = path.resolve(sessions.getSessionCwd(req.params.id));
     const filePath = path.resolve(rootDir, file);
 
     try {
@@ -780,7 +820,7 @@ function setupRoutes(app, { auth, sessions, config, state, pushManager }) {
       return res.status(400).json({ error: 'Missing file parameter' });
     }
 
-    const rootDir = path.resolve(session.cwd);
+    const rootDir = path.resolve(sessions.getSessionCwd(req.params.id));
     const filePath = path.resolve(rootDir, file);
 
     try {
@@ -811,7 +851,7 @@ function setupRoutes(app, { auth, sessions, config, state, pushManager }) {
       return res.status(400).json({ error: 'Missing file parameter' });
     }
 
-    const rootDir = path.resolve(session.cwd);
+    const rootDir = path.resolve(sessions.getSessionCwd(req.params.id));
     const filePath = path.resolve(rootDir, file);
 
     try {
@@ -849,7 +889,7 @@ function setupRoutes(app, { auth, sessions, config, state, pushManager }) {
     if (!session) return res.status(404).json({ error: 'Session not found' });
 
     try {
-      const status = await getDetailedStatus(session.cwd);
+      const status = await getDetailedStatus(sessions.getSessionCwd(req.params.id));
       res.json(status);
     } catch (err) {
       log.warn(`Git status failed: ${err.message}`);
@@ -876,7 +916,11 @@ function setupRoutes(app, { auth, sessions, config, state, pushManager }) {
       }
     }
     try {
-      const diff = await getFileDiff(session.cwd, file, { staged, untracked, context });
+      const diff = await getFileDiff(sessions.getSessionCwd(req.params.id), file, {
+        staged,
+        untracked,
+        context,
+      });
       res.json(diff);
     } catch (err) {
       log.warn(`Git diff failed: ${err.message}`);
@@ -894,7 +938,7 @@ function setupRoutes(app, { auth, sessions, config, state, pushManager }) {
     }
 
     try {
-      const blame = await getFileBlame(session.cwd, file);
+      const blame = await getFileBlame(sessions.getSessionCwd(req.params.id), file);
       res.json(blame);
     } catch (err) {
       log.warn(`Git blame failed: ${err.message}`);
@@ -913,7 +957,10 @@ function setupRoutes(app, { auth, sessions, config, state, pushManager }) {
     }
 
     try {
-      const logResult = await getGitLog(session.cwd, { limit, file: file || null });
+      const logResult = await getGitLog(sessions.getSessionCwd(req.params.id), {
+        limit,
+        file: file || null,
+      });
       res.json(logResult);
     } catch (err) {
       log.warn(`Git log failed: ${err.message}`);
@@ -991,69 +1038,9 @@ function setupRoutes(app, { auth, sessions, config, state, pushManager }) {
     });
   });
 
-  app.post('/api/tunnel/renew', apiRateLimit, auth.middleware, (_req, res) => {
-    const { spawn } = require('child_process');
-    const { findDevtunnel } = require('../tunnel');
-    const cmd = findDevtunnel() || 'devtunnel';
-    const proc = spawn(cmd, ['user', 'login', '-d'], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-
-    let output = '';
-    let responded = false;
-
-    const timeout = setTimeout(() => {
-      if (!responded) {
-        responded = true;
-        proc.kill();
-        res.status(504).json({ error: 'Timed out waiting for device code' });
-      }
-    }, 15000);
-
-    function tryParse(data) {
-      if (responded || output.length > 10_000) return;
-      output += data;
-      // Entra: "open the page https://... and enter the code ABC123 to authenticate"
-      // GitHub: "Browse to https://... and enter the code: AB12-CD34"
-      const match =
-        output.match(/open the page (https:\/\/[^\s]+) and enter the code ([A-Z0-9]+)/i) ||
-        output.match(/Browse to (https:\/\/[^\s]+) and enter the code:?\s*([A-Z0-9-]+)/i);
-      if (match) {
-        responded = true;
-        clearTimeout(timeout);
-        // Stop reading output — we have what we need
-        proc.stdout.removeAllListeners('data');
-        proc.stderr.removeAllListeners('data');
-        res.json({
-          url: match[1],
-          code: match[2],
-        });
-      }
-    }
-
-    proc.stdout.on('data', (d) => tryParse(d.toString()));
-    proc.stderr.on('data', (d) => tryParse(d.toString()));
-
-    proc.on('close', (code) => {
-      clearTimeout(timeout);
-      if (!responded) {
-        responded = true;
-        if (code === 0) {
-          res.json({ ok: true, message: 'Already authenticated' });
-        } else {
-          res.status(500).json({ error: 'DevTunnel login failed' });
-        }
-      }
-    });
-
-    proc.on('error', (err) => {
-      clearTimeout(timeout);
-      if (!responded) {
-        responded = true;
-        res.status(500).json({ error: err.message });
-      }
-    });
-  });
+  // Tunnel renew endpoint removed — DevTunnel CLI auto-refreshes OAuth
+  // tokens. If auth truly expires, user must run "devtunnel user login" on
+  // the host machine; the watchdog auto-reconnects after re-auth.
 }
 
 function cleanupUploadedFiles() {

package/src/server/sessions.js

@@ -407,10 +407,30 @@ class SessionManager {
     return true;
   }
 
+  /** Get the live CWD for a session (detected from PTY process). */
+  getSessionCwd(id) {
+    const s = this.sessions.get(id);
+    if (!s) return null;
+    const cached = _gitCache.get(id);
+    if (cached && cached.cwd) {
+      // Update session.cwd so endpoints using session.cwd directly get fresh values
+      s.cwd = cached.cwd;
+      return cached.cwd;
+    }
+    // Trigger a refresh for next time
+    scheduleGitRefresh(id, s.pty.pid, s.cwd);
+    return s.cwd;
+  }
+
   list() {
     const list = [];
     for (const [id, s] of this.sessions) {
       const { cwd, git } = getCachedGitInfo(id, s.pty.pid, s.cwd);
+      // Keep session.cwd in sync with detected live CWD
+      if (cwd !== s.cwd) {
+        log.debug(`Session ${id} CWD changed: ${s.cwd} → ${cwd}`);
+        s.cwd = cwd;
+      }
       list.push({
         id,
         name: s.name,

package/src/tunnel/index.js

@@ -293,13 +293,11 @@ function checkTokenExpiry() {
   if (remaining <= TOKEN_EXPIRY_WARN_SECONDS && !expiryWarned) {
     expiryWarned = true;
     const minutes = Math.round(remaining / 60);
-    log.warn(`DevTunnel token expires in ${minutes}m`);
-    tunnelEvents.emit('auth-expiring', {
-      expiresIn: remaining * 1000,
-      provider: info.provider,
-    });
+    log.warn(`DevTunnel token expires in ${minutes}m (will auto-refresh)`);
+  } else if (remaining > TOKEN_EXPIRY_WARN_SECONDS && expiryWarned) {
+    expiryWarned = false;
+    log.info('DevTunnel token was auto-refreshed');
   } else if (remaining > TOKEN_EXPIRY_WARN_SECONDS) {
-    // Reset the warning flag when token is refreshed
     expiryWarned = false;
   }
 }

package/src/utils/agent-sessions.js

@@ -0,0 +1,210 @@
+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);
+      if (!fs.statSync(fullProjDir).isDirectory()) continue;
+
+      // 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 and split into lines
+          const 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 [];
+  }
+}
+
+/**
+ * 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));
+  }
+
+  // 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) {
+  switch (session.agent) {
+    case 'copilot':
+      return `copilot --resume=${session.id}`;
+    case 'claude':
+      return `claude --resume ${session.id}`;
+    default:
+      return null;
+  }
+}
+
+module.exports = { getAgentSessions, getResumeCommand, readCopilotSessions, readClaudeSessions };

package/src/utils/agents.js

@@ -0,0 +1,116 @@
+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']],
+  },
+];
+
+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, stdio: ['pipe', 'pipe', 'pipe'], 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.