termbeam 1.17.3 → 1.17.5

package/src/server/index.js

@@ -13,7 +13,7 @@ const { createAuth } = require('./auth');
 const { SessionManager } = require('./sessions');
 const { setupRoutes, cleanupUploadedFiles } = require('./routes');
 const { setupWebSocket } = require('./websocket');
-const { startTunnel, cleanupTunnel, findDevtunnel } = require('../tunnel');
+const { startTunnel, cleanupTunnel, findDevtunnel, tunnelEvents } = require('../tunnel');
 const { createPreviewProxy } = require('./preview');
 const { writeConnectionConfig, removeConnectionConfig } = require('../cli/resume');
 const { checkForUpdate, detectInstallMethod } = require('../utils/update-check');
@@ -110,6 +110,7 @@ function createTermBeamServer(overrides = {}) {
     auth.cleanup();
     sessions.shutdown();
     cleanupUploadedFiles();
+    tunnelEvents.removeAllListeners();
     cleanupTunnel();
     removeConnectionConfig();
     for (const client of wss.clients) {
@@ -257,6 +258,22 @@ function createTermBeamServer(overrides = {}) {
             log.warn('Tunnel failed to start, falling back to LAN-only');
             console.log('  ⚠️  Tunnel failed to start. Using LAN only.');
           }
+
+          // Tunnel watchdog events
+          tunnelEvents.on('disconnected', () => {
+            log.warn('Tunnel disconnected — watchdog will attempt to reconnect');
+          });
+          tunnelEvents.on('reconnecting', ({ attempt, delay }) => {
+            log.info(`Tunnel reconnecting (attempt ${attempt}, backoff ${delay}ms)`);
+          });
+          tunnelEvents.on('connected', ({ url }) => {
+            log.info(`Tunnel connected: ${url}`);
+          });
+          tunnelEvents.on('failed', ({ attempts }) => {
+            log.error(
+              `Tunnel watchdog gave up after ${attempts} attempts — tunnel URL is unreachable`,
+            );
+          });
         }
 
         console.log(`  Shell:    ${config.shell}`);

package/src/tunnel/index.js

@@ -1,7 +1,8 @@
-const { execSync, execFileSync, spawn } = require('child_process');
+const { execSync, execFileSync, execFile, spawn } = require('child_process');
 const path = require('path');
 const fs = require('fs');
 const os = require('os');
+const EventEmitter = require('events');
 const log = require('../utils/logger');
 const { promptInstall } = require('./install');
 
@@ -12,6 +13,19 @@ let tunnelId = null;
 let tunnelProc = null;
 let devtunnelCmd = 'devtunnel';
 
+// --- Watchdog state ---
+const tunnelEvents = new EventEmitter();
+let healthCheckInterval = null;
+let consecutiveFailures = 0;
+let restartAttempts = 0;
+let isRestarting = false;
+let restartTimer = null;
+
+const HEALTH_CHECK_INTERVAL = 30_000; // 30s between checks
+const HEALTH_CHECK_GRACE = 2; // 2 consecutive failures before restart
+const MAX_RESTART_ATTEMPTS = 10;
+const BACKOFF_DELAYS = [1000, 2000, 5000, 10_000, 15_000, 30_000]; // then stays at 30s
+
 const SAFE_ID_RE = /^[a-zA-Z0-9._-]+$/;
 
 const DEVICE_CODE_INITIAL_TIMEOUT = 15000;
@@ -135,6 +149,203 @@ function isTunnelValid(id) {
 
 let isPersisted = false;
 
+// --- Watchdog: health check & auto-restart ---
+
+function checkTunnelHealth() {
+  if (!tunnelId || !tunnelProc || isRestarting) return;
+
+  const abortCtrl = new AbortController();
+  const timer = setTimeout(() => abortCtrl.abort(), 10_000);
+
+  execFile(
+    devtunnelCmd,
+    ['show', tunnelId],
+    { encoding: 'utf-8', signal: abortCtrl.signal },
+    (err, stdout) => {
+      clearTimeout(timer);
+
+      if (err) {
+        consecutiveFailures++;
+        log.warn(
+          `Tunnel health check error: ${err.message} (${consecutiveFailures}/${HEALTH_CHECK_GRACE})`,
+        );
+        if (consecutiveFailures >= HEALTH_CHECK_GRACE) {
+          handleTunnelFailure();
+        }
+        return;
+      }
+
+      const match = stdout.match(/Host connections\s*:\s*(\d+)/i);
+      if (!match) {
+        consecutiveFailures++;
+        log.warn(
+          `Tunnel health check: could not parse host connections (${consecutiveFailures}/${HEALTH_CHECK_GRACE})`,
+        );
+        if (consecutiveFailures >= HEALTH_CHECK_GRACE) {
+          handleTunnelFailure();
+        }
+        return;
+      }
+
+      const hostConns = parseInt(match[1], 10);
+      if (hostConns > 0) {
+        if (consecutiveFailures > 0) {
+          log.info(`Tunnel health restored (${hostConns} host connection(s))`);
+        }
+        consecutiveFailures = 0;
+        return;
+      }
+
+      consecutiveFailures++;
+      log.warn(
+        `Tunnel health check: 0 host connections (${consecutiveFailures}/${HEALTH_CHECK_GRACE})`,
+      );
+
+      if (consecutiveFailures >= HEALTH_CHECK_GRACE) {
+        log.warn('Tunnel connection lost — initiating restart');
+        handleTunnelFailure();
+      }
+    },
+  );
+}
+
+function startHealthCheck() {
+  stopHealthCheck();
+  consecutiveFailures = 0;
+  healthCheckInterval = setInterval(checkTunnelHealth, HEALTH_CHECK_INTERVAL);
+  healthCheckInterval.unref();
+}
+
+function stopHealthCheck() {
+  if (healthCheckInterval) {
+    clearInterval(healthCheckInterval);
+    healthCheckInterval = null;
+  }
+}
+
+function handleTunnelFailure() {
+  if (isRestarting) return;
+  stopHealthCheck();
+
+  // Kill the zombie process
+  if (tunnelProc) {
+    try {
+      if (process.platform === 'win32' && tunnelProc.pid) {
+        try {
+          execFileSync('taskkill', ['/pid', String(tunnelProc.pid), '/T', '/F'], {
+            stdio: 'pipe',
+            timeout: 5000,
+          });
+        } catch {
+          /* best effort */
+        }
+      } else {
+        tunnelProc.kill('SIGKILL');
+      }
+    } catch {
+      /* best effort */
+    }
+    tunnelProc = null;
+  }
+
+  tunnelEvents.emit('disconnected');
+  scheduleRestart();
+}
+
+function scheduleRestart() {
+  if (restartAttempts >= MAX_RESTART_ATTEMPTS) {
+    log.error(
+      `Tunnel restart failed after ${MAX_RESTART_ATTEMPTS} attempts — giving up. Tunnel URL is unreachable.`,
+    );
+    tunnelEvents.emit('failed', { attempts: restartAttempts });
+    isRestarting = false;
+    return;
+  }
+
+  isRestarting = true;
+  const delay = BACKOFF_DELAYS[Math.min(restartAttempts, BACKOFF_DELAYS.length - 1)];
+  restartAttempts++;
+
+  log.info(`Restarting tunnel in ${delay}ms (attempt ${restartAttempts}/${MAX_RESTART_ATTEMPTS})`);
+  tunnelEvents.emit('reconnecting', { attempt: restartAttempts, delay });
+
+  restartTimer = setTimeout(async () => {
+    restartTimer = null;
+    try {
+      const result = await hostTunnel();
+      if (result) {
+        log.info('Tunnel reconnected successfully');
+        restartAttempts = 0;
+        isRestarting = false;
+        tunnelEvents.emit('connected', { url: result.url });
+        startHealthCheck();
+      } else {
+        log.warn('Tunnel restart returned no URL');
+        isRestarting = false;
+        scheduleRestart();
+      }
+    } catch (err) {
+      log.error(`Tunnel restart error: ${err.message}`);
+      isRestarting = false;
+      scheduleRestart();
+    }
+  }, delay);
+  restartTimer.unref();
+}
+
+/**
+ * Spawn `devtunnel host` for the current tunnelId and wait for the URL.
+ * Used by both initial start and watchdog restarts.
+ */
+function hostTunnel() {
+  const hostProc = spawn(devtunnelCmd, ['host', tunnelId], {
+    stdio: ['pipe', 'pipe', 'pipe'],
+  });
+  tunnelProc = hostProc;
+
+  // Attach exit handler for crash detection
+  hostProc.on('exit', (code, signal) => {
+    if (tunnelProc !== hostProc) return; // stale reference
+    log.warn(`Tunnel process exited (code=${code}, signal=${signal})`);
+    tunnelProc = null;
+    if (!isRestarting) {
+      tunnelEvents.emit('disconnected');
+      scheduleRestart();
+    }
+  });
+
+  return new Promise((resolve) => {
+    let output = '';
+    const timeout = setTimeout(() => {
+      // Kill the process if URL wasn't detected in time
+      try {
+        hostProc.kill('SIGKILL');
+      } catch {
+        /* best effort */
+      }
+      if (tunnelProc === hostProc) tunnelProc = null;
+      resolve(null);
+    }, 15_000);
+
+    hostProc.stdout.on('data', (data) => {
+      output += data.toString();
+      const match = output.match(/(https:\/\/[^\s]+devtunnels\.ms[^\s]*)/);
+      if (match) {
+        clearTimeout(timeout);
+        resolve({ url: match[1] });
+      }
+    });
+    hostProc.stderr.on('data', (data) => {
+      output += data.toString();
+    });
+    hostProc.on('error', (err) => {
+      log.error(`Tunnel process error: ${err.message}`);
+      clearTimeout(timeout);
+      resolve(null);
+    });
+  });
+}
+
 async function startTunnel(port, options = {}) {
   // Check if devtunnel CLI is installed
   let found = findDevtunnel();
@@ -254,32 +465,14 @@ async function startTunnel(port, options = {}) {
       log.info('Tunnel access: private (owner-only via Microsoft login)');
     }
 
-    const hostProc = spawn(devtunnelCmd, ['host', tunnelId], {
-      stdio: ['pipe', 'pipe', 'pipe'],
-    });
-    tunnelProc = hostProc;
-
-    return new Promise((resolve) => {
-      let output = '';
-      const timeout = setTimeout(() => resolve(null), 15000);
-
-      hostProc.stdout.on('data', (data) => {
-        output += data.toString();
-        const match = output.match(/(https:\/\/[^\s]+devtunnels\.ms[^\s]*)/);
-        if (match) {
-          clearTimeout(timeout);
-          resolve({ url: match[1], mode: tunnelMode, expiry: tunnelExpiry });
-        }
-      });
-      hostProc.stderr.on('data', (data) => {
-        output += data.toString();
-      });
-      hostProc.on('error', (err) => {
-        log.error(`Tunnel process error: ${err.message}`);
-        clearTimeout(timeout);
-        resolve(null);
-      });
-    });
+    const result = await hostTunnel();
+    if (result) {
+      result.mode = tunnelMode;
+      result.expiry = tunnelExpiry;
+      startHealthCheck();
+      tunnelEvents.emit('connected', { url: result.url });
+    }
+    return result;
   } catch (e) {
     log.error(`Tunnel error: ${e.message}`);
     return null;
@@ -287,6 +480,14 @@ async function startTunnel(port, options = {}) {
 }
 
 function cleanupTunnel() {
+  // Stop watchdog first to prevent restart during cleanup
+  stopHealthCheck();
+  isRestarting = true; // prevent exit handler from restarting
+  if (restartTimer) {
+    clearTimeout(restartTimer);
+    restartTimer = null;
+  }
+
   const id = tunnelId;
   if (tunnelProc) {
     try {
@@ -321,6 +522,11 @@ function cleanupTunnel() {
       }
     }
   }
+
+  // Reset watchdog state
+  consecutiveFailures = 0;
+  restartAttempts = 0;
+  isRestarting = false;
 }
 
-module.exports = { startTunnel, cleanupTunnel, findDevtunnel };
+module.exports = { startTunnel, cleanupTunnel, findDevtunnel, tunnelEvents };

package/src/utils/git.js

@@ -132,6 +132,32 @@ const MAX_DIFF_BUFFER = 1024 * 1024; // 1 MB
 const MAX_BLAME_BUFFER = 2 * 1024 * 1024; // 2 MB
 const MAX_LOG_BUFFER = 1024 * 1024; // 1 MB
 
+// git status --porcelain returns paths relative to the repo root, so
+// commands that accept those paths (diff, blame, log --follow) must also
+// run from the repo root.  Cache per-cwd to avoid repeated rev-parse calls.
+const gitRootCache = new Map();
+
+async function getGitRoot(cwd) {
+  if (gitRootCache.has(cwd)) return gitRootCache.get(cwd);
+  try {
+    const root = await new Promise((resolve, reject) => {
+      require('child_process').execFile(
+        'git',
+        ['rev-parse', '--show-toplevel'],
+        { cwd, timeout: GIT_TIMEOUT },
+        (err, stdout) => {
+          if (err) return reject(err);
+          resolve(stdout.trim());
+        },
+      );
+    });
+    gitRootCache.set(cwd, root);
+    return root;
+  } catch {
+    return cwd; // fallback to session cwd
+  }
+}
+
 async function gitAsync(args, cwd, options = {}) {
   return new Promise((resolve, reject) => {
     require('child_process').execFile(
@@ -302,6 +328,8 @@ async function parseDiffOutput(raw, filePath) {
 
 async function getFileDiff(cwd, filePath, options = {}) {
   const { staged = false, untracked = false, context = 3 } = options;
+  // git status returns paths relative to the repo root, so run diff from there
+  const root = await getGitRoot(cwd);
 
   try {
     // Untracked files: use --no-index to diff against the null device
@@ -312,7 +340,7 @@ async function getFileDiff(cwd, filePath, options = {}) {
           'git',
           ['diff', '--no-index', '--no-color', `--unified=${context}`, '--', nullDevice, filePath],
           {
-            cwd,
+            cwd: root,
             timeout: GIT_TIMEOUT,
             maxBuffer: MAX_DIFF_BUFFER,
           },
@@ -330,7 +358,7 @@ async function getFileDiff(cwd, filePath, options = {}) {
     if (staged) args.push('--cached');
     args.push('--', filePath);
 
-    const raw = await gitAsync(args, cwd, { maxBuffer: MAX_DIFF_BUFFER });
+    const raw = await gitAsync(args, root, { maxBuffer: MAX_DIFF_BUFFER });
     return parseDiffOutput(raw, filePath);
   } catch (err) {
     // Empty diff or git error
@@ -350,9 +378,11 @@ async function getFileDiff(cwd, filePath, options = {}) {
 
 async function getFileBlame(cwd, filePath) {
   const result = { file: filePath, lines: [] };
+  // git status returns paths relative to the repo root, so run blame from there
+  const root = await getGitRoot(cwd);
 
   try {
-    const raw = await gitAsync(['blame', '--porcelain', '--', filePath], cwd, {
+    const raw = await gitAsync(['blame', '--porcelain', '--', filePath], root, {
       maxBuffer: MAX_BLAME_BUFFER,
     });
 
@@ -427,11 +457,14 @@ async function getGitLog(cwd, options = {}) {
 
   try {
     const args = ['log', `--format=${LOG_SEPARATOR}${LOG_FORMAT}`, `-n`, String(limit)];
+    // When filtering by file, run from repo root since paths are repo-root-relative
+    let runCwd = cwd;
     if (options.file) {
       args.push('--follow', '--', options.file);
+      runCwd = await getGitRoot(cwd);
     }
 
-    const raw = await gitAsync(args, cwd, { maxBuffer: MAX_LOG_BUFFER });
+    const raw = await gitAsync(args, runCwd, { maxBuffer: MAX_LOG_BUFFER });
 
     const entries = raw.split(LOG_SEPARATOR).filter((e) => e.trim());
     for (const entry of entries) {
@@ -462,4 +495,5 @@ module.exports = {
   getFileDiff,
   getFileBlame,
   getGitLog,
+  getGitRoot,
 };

package/public/assets/channel-spGqRIlf.js

@@ -1 +0,0 @@
-import{aq as o,ar as n}from"./index-pqtccC7s.js";const t=(r,a)=>o.lang.round(n.parse(r)[a]);export{t as c};

package/public/assets/classDiagram-VBA2DB6C-CwKQYDdP.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-WL4C6EOR-DY15q7Tk.js";import{_ as i}from"./index-pqtccC7s.js";import"./chunk-FMBD7UC4-cK52FAx0.js";import"./chunk-JSJVCQXG-CudZY5_F.js";import"./chunk-55IACEB6-CRSrEoDB.js";import"./chunk-KX2RTZJC-BZlXzthI.js";var u={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{u as diagram};

package/public/assets/classDiagram-v2-RAHNMMFH-CwKQYDdP.js

@@ -1 +0,0 @@
-import{s as a,c as s,a as e,C as t}from"./chunk-WL4C6EOR-DY15q7Tk.js";import{_ as i}from"./index-pqtccC7s.js";import"./chunk-FMBD7UC4-cK52FAx0.js";import"./chunk-JSJVCQXG-CudZY5_F.js";import"./chunk-55IACEB6-CRSrEoDB.js";import"./chunk-KX2RTZJC-BZlXzthI.js";var u={parser:e,get db(){return new t},renderer:s,styles:a,init:i(r=>{r.class||(r.class={}),r.class.arrowMarkerAbsolute=r.arrowMarkerAbsolute},"init")};export{u as diagram};

package/public/assets/clone-BQhUsBH5.js

@@ -1 +0,0 @@
-import{b as r}from"./_baseUniq-CmudMx6k.js";var e=4;function a(o){return r(o,e)}export{a as c};

package/public/assets/stateDiagram-v2-FVOUBMTO-Dr2a5PWq.js

@@ -1 +0,0 @@
-import{s as t,b as r,a,S as s}from"./chunk-NQ4KR5QH-BP6XJFdX.js";import{_ as i}from"./index-pqtccC7s.js";import"./chunk-55IACEB6-CRSrEoDB.js";import"./chunk-KX2RTZJC-BZlXzthI.js";var l={parser:a,get db(){return new s(2)},renderer:r,styles:t,init:i(e=>{e.state||(e.state={}),e.state.arrowMarkerAbsolute=e.arrowMarkerAbsolute},"init")};export{l as diagram};