termbeam 1.15.2 → 1.17.0

package/src/utils/git.js

@@ -125,4 +125,341 @@ function parseStatus(output, ahead, behind) {
   return { clean, modified, staged, untracked, ahead: ahead || 0, behind: behind || 0, summary };
 }
 
-module.exports = { getGitInfo, parseRemoteUrl, parseStatus };
+// --- Extended git utilities (async, using execFile for security) ---
+
+const GIT_TIMEOUT = 5000;
+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
+
+async function gitAsync(args, cwd, options = {}) {
+  return new Promise((resolve, reject) => {
+    require('child_process').execFile(
+      'git',
+      args,
+      {
+        cwd,
+        timeout: options.timeout || GIT_TIMEOUT,
+        maxBuffer: options.maxBuffer || MAX_DIFF_BUFFER,
+      },
+      (err, stdout) => {
+        if (err) return reject(err);
+        resolve(stdout);
+      },
+    );
+  });
+}
+
+async function getDetailedStatus(cwd) {
+  try {
+    await gitAsync(['rev-parse', '--is-inside-work-tree'], cwd);
+  } catch {
+    return { isGitRepo: false };
+  }
+
+  const result = {
+    branch: null,
+    ahead: 0,
+    behind: 0,
+    staged: [],
+    modified: [],
+    untracked: [],
+    isGitRepo: true,
+  };
+
+  try {
+    const raw = await gitAsync(['status', '--porcelain=v1', '-b'], cwd);
+    const lines = raw.split('\n').filter(Boolean);
+
+    for (const line of lines) {
+      // Branch header line
+      if (line.startsWith('## ')) {
+        const branchInfo = line.slice(3);
+        const trackMatch = branchInfo.match(/^(.+?)(?:\.\.\.(.+?))?(?:\s+\[(.+)\])?$/);
+        if (trackMatch) {
+          result.branch = trackMatch[1];
+          const tracking = trackMatch[3];
+          if (tracking) {
+            const aheadMatch = tracking.match(/ahead (\d+)/);
+            const behindMatch = tracking.match(/behind (\d+)/);
+            if (aheadMatch) result.ahead = parseInt(aheadMatch[1], 10);
+            if (behindMatch) result.behind = parseInt(behindMatch[1], 10);
+          }
+        }
+        continue;
+      }
+
+      const index = line[0];
+      const working = line[1];
+      const filePart = line.slice(3);
+
+      // Untracked
+      if (index === '?' && working === '?') {
+        result.untracked.push(filePart);
+        continue;
+      }
+
+      // Staged changes (index column)
+      if (index !== ' ' && index !== '?') {
+        const entry = { path: filePart, status: index, oldPath: null };
+        if (index === 'R' || index === 'C') {
+          const parts = filePart.split(' -> ');
+          if (parts.length === 2) {
+            entry.oldPath = parts[0];
+            entry.path = parts[1];
+          }
+        }
+        result.staged.push(entry);
+      }
+
+      // Working tree changes (working column)
+      if (working !== ' ' && working !== '?') {
+        result.modified.push({ path: filePart, status: working, oldPath: null });
+      }
+    }
+  } catch (err) {
+    log.warn(`getDetailedStatus failed: ${err.message}`);
+  }
+
+  return result;
+}
+
+async function parseDiffOutput(raw, filePath) {
+  const result = {
+    file: filePath,
+    hunks: [],
+    additions: 0,
+    deletions: 0,
+    isBinary: false,
+  };
+
+  if (!raw.trim()) return result;
+
+  // Binary file detection — only check the diff header (lines before the first hunk).
+  // Content lines (prefixed with +/-/ ) may contain "Binary files ... differ" as text.
+  const firstHunkIdx = raw.indexOf('\n@@');
+  const header = firstHunkIdx >= 0 ? raw.slice(0, firstHunkIdx) : raw;
+  if (header.includes('Binary files') && header.includes('differ')) {
+    result.isBinary = true;
+    return result;
+  }
+
+  // Parse unified diff into hunks
+  const lines = raw.split('\n');
+  let currentHunk = null;
+  let oldLine = 0;
+  let newLine = 0;
+
+  for (const line of lines) {
+    // Hunk header
+    const hunkMatch = line.match(/^@@ -(\d+)(?:,(\d+))? \+(\d+)(?:,(\d+))? @@/);
+    if (hunkMatch) {
+      currentHunk = {
+        header: line.match(/^@@.*@@/)[0],
+        oldStart: parseInt(hunkMatch[1], 10),
+        oldLines: parseInt(hunkMatch[2] ?? '1', 10),
+        newStart: parseInt(hunkMatch[3], 10),
+        newLines: parseInt(hunkMatch[4] ?? '1', 10),
+        lines: [],
+      };
+      result.hunks.push(currentHunk);
+      oldLine = currentHunk.oldStart;
+      newLine = currentHunk.newStart;
+      continue;
+    }
+
+    if (!currentHunk) continue;
+
+    if (line.startsWith('+')) {
+      currentHunk.lines.push({
+        type: 'add',
+        content: line.slice(1),
+        oldLine: null,
+        newLine: newLine++,
+      });
+      result.additions++;
+    } else if (line.startsWith('-')) {
+      currentHunk.lines.push({
+        type: 'remove',
+        content: line.slice(1),
+        oldLine: oldLine++,
+        newLine: null,
+      });
+      result.deletions++;
+    } else if (line.startsWith(' ')) {
+      currentHunk.lines.push({
+        type: 'context',
+        content: line.slice(1),
+        oldLine: oldLine++,
+        newLine: newLine++,
+      });
+    }
+    // Skip diff header lines (diff --git, index, ---, +++)
+  }
+
+  return result;
+}
+
+async function getFileDiff(cwd, filePath, options = {}) {
+  const { staged = false, untracked = false, context = 3 } = options;
+
+  try {
+    // Untracked files: use --no-index to diff against the null device
+    const nullDevice = process.platform === 'win32' ? 'NUL' : '/dev/null';
+    if (untracked) {
+      const raw = await new Promise((resolve, reject) => {
+        require('child_process').execFile(
+          'git',
+          ['diff', '--no-index', '--no-color', `--unified=${context}`, '--', nullDevice, filePath],
+          {
+            cwd,
+            timeout: GIT_TIMEOUT,
+            maxBuffer: MAX_DIFF_BUFFER,
+          },
+          (err, stdout) => {
+            // git diff --no-index exits with 1 when files differ — that's expected
+            if (err && err.code !== 1) return reject(err);
+            resolve(stdout || '');
+          },
+        );
+      });
+      return parseDiffOutput(raw, filePath);
+    }
+
+    const args = ['diff', `--unified=${context}`, '--no-color'];
+    if (staged) args.push('--cached');
+    args.push('--', filePath);
+
+    const raw = await gitAsync(args, cwd, { maxBuffer: MAX_DIFF_BUFFER });
+    return parseDiffOutput(raw, filePath);
+  } catch (err) {
+    // Empty diff or git error
+    if (err.code !== 1) {
+      log.warn(`getFileDiff failed: ${err.message}`);
+    }
+  }
+
+  return {
+    file: filePath,
+    hunks: [],
+    additions: 0,
+    deletions: 0,
+    isBinary: false,
+  };
+}
+
+async function getFileBlame(cwd, filePath) {
+  const result = { file: filePath, lines: [] };
+
+  try {
+    const raw = await gitAsync(['blame', '--porcelain', '--', filePath], cwd, {
+      maxBuffer: MAX_BLAME_BUFFER,
+    });
+
+    const rawLines = raw.split('\n');
+    let currentCommit = null;
+    let currentLine = null;
+    const commitInfo = {}; // cache commit metadata
+
+    for (let i = 0; i < rawLines.length; i++) {
+      const line = rawLines[i];
+
+      // Commit line: <40-char-hash> <orig-line> <final-line> [<num-lines>]
+      const commitMatch = line.match(/^([0-9a-f]{40})\s+(\d+)\s+(\d+)(?:\s+(\d+))?$/);
+      if (commitMatch) {
+        currentCommit = commitMatch[1];
+        currentLine = parseInt(commitMatch[3], 10);
+
+        if (!commitInfo[currentCommit]) {
+          commitInfo[currentCommit] = {
+            author: null,
+            date: null,
+            summary: null,
+          };
+        }
+        continue;
+      }
+
+      // Metadata lines
+      if (currentCommit && line.startsWith('author ')) {
+        commitInfo[currentCommit].author = line.slice(7);
+      } else if (currentCommit && line.startsWith('author-time ')) {
+        const timestamp = parseInt(line.slice(12), 10);
+        commitInfo[currentCommit].date = new Date(timestamp * 1000).toISOString();
+      } else if (currentCommit && line.startsWith('summary ')) {
+        commitInfo[currentCommit].summary = line.slice(8);
+      } else if (currentCommit && line.startsWith('\t')) {
+        // Content line
+        const info = commitInfo[currentCommit];
+        const isUncommitted = currentCommit === '0000000000000000000000000000000000000000';
+        result.lines.push({
+          line: currentLine,
+          content: line.slice(1),
+          commit: isUncommitted ? null : currentCommit.slice(0, 7),
+          author: isUncommitted ? 'Not Committed Yet' : info.author || 'Unknown',
+          date: isUncommitted ? null : info.date || null,
+          summary: isUncommitted ? 'Uncommitted changes' : info.summary || '',
+        });
+      }
+    }
+  } catch (err) {
+    log.warn(`getFileBlame failed: ${err.message}`);
+  }
+
+  return result;
+}
+
+const LOG_SEPARATOR = '---GIT_LOG_SEP---';
+const LOG_FIELD_SEP = '---GIT_FIELD_SEP---';
+const LOG_FORMAT = [
+  '%H', // hash
+  '%h', // short hash
+  '%an', // author name
+  '%ae', // author email
+  '%aI', // author date ISO
+  '%s', // subject
+  '%b', // body
+].join(LOG_FIELD_SEP);
+
+async function getGitLog(cwd, options = {}) {
+  const limit = Math.min(Math.max(parseInt(options.limit, 10) || 20, 1), 100);
+  const result = { commits: [] };
+
+  try {
+    const args = ['log', `--format=${LOG_SEPARATOR}${LOG_FORMAT}`, `-n`, String(limit)];
+    if (options.file) {
+      args.push('--follow', '--', options.file);
+    }
+
+    const raw = await gitAsync(args, cwd, { maxBuffer: MAX_LOG_BUFFER });
+
+    const entries = raw.split(LOG_SEPARATOR).filter((e) => e.trim());
+    for (const entry of entries) {
+      const fields = entry.trim().split(LOG_FIELD_SEP);
+      if (fields.length < 6) continue;
+      result.commits.push({
+        hash: fields[0],
+        shortHash: fields[1],
+        author: fields[2],
+        email: fields[3],
+        date: fields[4],
+        subject: fields[5],
+        body: (fields[6] || '').trim(),
+      });
+    }
+  } catch (err) {
+    log.warn(`getGitLog failed: ${err.message}`);
+  }
+
+  return result;
+}
+
+module.exports = {
+  getGitInfo,
+  parseRemoteUrl,
+  parseStatus,
+  getDetailedStatus,
+  getFileDiff,
+  getFileBlame,
+  getGitLog,
+};

package/src/utils/update-check.js

@@ -73,6 +73,8 @@ function normalizeVersion(version) {
 /**
  * Compare two semver version strings (e.g. "1.10.2" vs "1.11.0").
  * Returns true if `latest` is newer than `current`.
+ * Pre-release versions (e.g. "1.15.3-rc.1") are considered older than
+ * the same stable version ("1.15.3"), so an update will be offered.
  * Returns false if either version cannot be parsed.
  */
 function isNewerVersion(current, latest) {
@@ -83,9 +85,25 @@ function isNewerVersion(current, latest) {
     if (lat[i] > cur[i]) return true;
     if (lat[i] < cur[i]) return false;
   }
+  // Same base version — if current is a pre-release but latest is stable,
+  // the stable release is newer (e.g. 1.15.3-rc.1 → 1.15.3)
+  if (isPreRelease(current) && !isPreRelease(latest)) return true;
   return false;
 }
 
+/**
+ * Check if a version string contains pre-release metadata (e.g. "-rc.1", "-dev.5").
+ */
+function isPreRelease(version) {
+  if (typeof version !== 'string') return false;
+  let v = version.trim();
+  if (v[0] === 'v' || v[0] === 'V') v = v.slice(1);
+  // Strip build metadata first (+foo)
+  const plusIdx = v.indexOf('+');
+  if (plusIdx !== -1) v = v.slice(0, plusIdx);
+  return v.includes('-');
+}
+
 /**
  * Strip ANSI escape sequences and control characters from a string.
  * Prevents terminal injection if the registry returns malicious data.
@@ -222,39 +240,151 @@ async function checkForUpdate({ currentVersion, force = false } = {}) {
 }
 
 /**
- * Detect how TermBeam was installed and return the appropriate update command.
- * @returns {{ method: string, command: string }}
+ * Detect how TermBeam was installed and return the appropriate update command,
+ * whether it can auto-update, and the restart strategy.
+ * @returns {{ method: string, command: string, canAutoUpdate: boolean, restartStrategy: 'pm2'|'exit'|'none', installCmd: string|null, installArgs: string[]|null }}
+ * Note: installCmd/installArgs are internal — stripped before sending to API clients.
  */
 function detectInstallMethod() {
   // npx / npm exec — npm sets npm_command=exec
   if (process.env.npm_command === 'exec') {
     log.debug('Install method: npx');
-    return { method: 'npx', command: 'npx termbeam@latest' };
+    return {
+      method: 'npx',
+      command: 'npx termbeam@latest',
+      installCmd: 'npx',
+      installArgs: ['termbeam@latest'],
+      canAutoUpdate: false,
+      restartStrategy: 'none',
+    };
   }
 
+  // PM2 managed — detect via PM2 environment variables
+  const isPm2 = isRunningUnderPm2();
+
   // Detect package manager from npm_execpath (set during npm/yarn/pnpm lifecycle)
+  // Check this before file-system checks since env vars are more reliable
   const execPath = process.env.npm_execpath || '';
   if (execPath.includes('yarn')) {
-    log.debug('Install method: yarn');
-    return { method: 'yarn', command: 'yarn global add termbeam@latest' };
+    log.debug(`Install method: yarn${isPm2 ? ' (PM2)' : ''}`);
+    return {
+      method: 'yarn',
+      command: 'yarn global add termbeam@latest',
+      installCmd: 'yarn',
+      installArgs: ['global', 'add', 'termbeam@latest'],
+      canAutoUpdate: true,
+      restartStrategy: isPm2 ? 'pm2' : 'exit',
+    };
   }
   if (execPath.includes('pnpm')) {
-    log.debug('Install method: pnpm');
-    return { method: 'pnpm', command: 'pnpm add -g termbeam@latest' };
+    log.debug(`Install method: pnpm${isPm2 ? ' (PM2)' : ''}`);
+    return {
+      method: 'pnpm',
+      command: 'pnpm add -g termbeam@latest',
+      installCmd: 'pnpm',
+      installArgs: ['add', '-g', 'termbeam@latest'],
+      canAutoUpdate: true,
+      restartStrategy: isPm2 ? 'pm2' : 'exit',
+    };
+  }
+
+  // Development / git clone — not in node_modules and .git exists
+  // Check before Docker: a git checkout running inside a container (CI/devcontainers)
+  // should be treated as source, not Docker
+  if (isRunningFromSource()) {
+    log.debug('Install method: source');
+    return {
+      method: 'source',
+      command: 'git pull && npm install && npm run build:frontend',
+      installCmd: null,
+      installArgs: null,
+      canAutoUpdate: false,
+      restartStrategy: 'none',
+    };
+  }
+
+  // Docker — check for /.dockerenv or /proc/1/cgroup containing docker
+  if (isRunningInDocker()) {
+    log.debug('Install method: docker');
+    return {
+      method: 'docker',
+      command: 'docker pull termbeam:latest && docker-compose up -d',
+      installCmd: null,
+      installArgs: null,
+      canAutoUpdate: false,
+      restartStrategy: 'none',
+    };
   }
 
   // Default: npm global install
-  log.debug('Install method: npm');
-  return { method: 'npm', command: 'npm install -g termbeam@latest' };
+  log.debug(`Install method: npm${isPm2 ? ' (PM2)' : ''}`);
+  return {
+    method: 'npm',
+    command: 'npm install -g termbeam@latest',
+    installCmd: 'npm',
+    installArgs: ['install', '-g', 'termbeam@latest'],
+    canAutoUpdate: true,
+    restartStrategy: isPm2 ? 'pm2' : 'exit',
+  };
+}
+
+/**
+ * Detect if running inside a Docker container.
+ */
+function isRunningInDocker() {
+  try {
+    if (fs.existsSync('/.dockerenv')) return true;
+  } catch {
+    // ignore
+  }
+  try {
+    const cgroup = fs.readFileSync('/proc/1/cgroup', 'utf8');
+    if (cgroup.includes('docker') || cgroup.includes('containerd')) return true;
+  } catch {
+    // Not Linux or no access — not Docker
+  }
+  return false;
+}
+
+/**
+ * Detect if running from a git source checkout (not installed as a package).
+ * Walks upward from __dirname looking for .git to avoid fragile fixed-depth assumptions.
+ */
+function isRunningFromSource() {
+  // If __dirname is inside node_modules, it's a package install
+  if (__dirname.includes('node_modules')) return false;
+  try {
+    let currentDir = __dirname;
+    for (let i = 0; i < 10; i++) {
+      if (fs.existsSync(path.join(currentDir, '.git'))) return true;
+      const parentDir = path.dirname(currentDir);
+      if (!parentDir || parentDir === currentDir) break;
+      currentDir = parentDir;
+    }
+    return false;
+  } catch {
+    return false;
+  }
+}
+
+/**
+ * Detect if running under PM2 process manager.
+ */
+function isRunningUnderPm2() {
+  return !!(process.env.PM2_HOME || process.env.pm_id || process.env.PM2_USAGE);
 }
 
 module.exports = {
   checkForUpdate,
   isNewerVersion,
+  isPreRelease,
   normalizeVersion,
   fetchLatestVersion,
   readCache,
   writeCache,
   sanitizeVersion,
   detectInstallMethod,
+  isRunningInDocker,
+  isRunningFromSource,
+  isRunningUnderPm2,
 };