@aicloud360/360-aidrive 0.8.28

package/tools/auto-backup-monitor/server.mjs

@@ -0,0 +1,866 @@
+#!/usr/bin/env node
+
+import fs from 'fs';
+import http from 'http';
+import path from 'path';
+import { fileURLToPath } from 'url';
+import { homedir } from 'os';
+import { execFileSync, spawn } from 'child_process';
+
+const DEFAULT_HOST = '127.0.0.1';
+const DEFAULT_PORT = 3210;
+
+function getDefaultCliName() {
+  try {
+    const scriptDir = path.dirname(fileURLToPath(import.meta.url));
+    const candidates = [
+      path.resolve(scriptDir, '../../package.json'),
+      path.resolve(scriptDir, '../../../package.json'),
+      path.resolve(process.cwd(), 'package.json'),
+    ];
+    for (const candidate of candidates) {
+      if (!fs.existsSync(candidate)) continue;
+      const pkg = JSON.parse(fs.readFileSync(candidate, 'utf8'));
+      if (pkg?.cli?.name) {
+        return pkg.cli.name;
+      }
+    }
+  } catch {
+    // ignore package lookup failures
+  }
+  return '360disk';
+}
+
+const DEFAULT_STATE_FILE_PATH = path.join(homedir(), `.${getDefaultCliName()}`, 'claw-auto-backup.json');
+
+function parseArgs(argv) {
+  const options = {
+    eventLog: '',
+    stateFile: DEFAULT_STATE_FILE_PATH,
+    host: DEFAULT_HOST,
+    port: DEFAULT_PORT,
+    open: false,
+  };
+
+  for (let index = 0; index < argv.length; index += 1) {
+    const arg = argv[index];
+    switch (arg) {
+      case '--event-log':
+        options.eventLog = path.resolve(argv[++index] || '.');
+        break;
+      case '--state-file':
+        options.stateFile = path.resolve(argv[++index] || DEFAULT_STATE_FILE_PATH);
+        break;
+      case '--host':
+        options.host = String(argv[++index] || DEFAULT_HOST);
+        break;
+      case '--port': {
+        const port = Number(argv[++index] || DEFAULT_PORT);
+        if (!Number.isInteger(port) || port <= 0 || port > 65535) {
+          throw new Error('--port 必须是 1-65535 的整数');
+        }
+        options.port = port;
+        break;
+      }
+      case '--open':
+        options.open = true;
+        break;
+      case '--help':
+      case '-h':
+        printHelp();
+        process.exit(0);
+        break;
+      default:
+        throw new Error(`未知参数: ${arg}`);
+    }
+  }
+
+  return options;
+}
+
+function printHelp() {
+  const cli = getDefaultCliName();
+  process.stdout.write(`Usage: node tools/auto-backup-monitor/server.mjs [options]
+
+Options:
+  --event-log <path>   初始事件日志文件路径；不传时由网页输入框指定
+  --state-file <path>  自动备份状态文件路径，默认 ~/.${cli}/claw-auto-backup.json
+  --host <host>        监听地址，默认 127.0.0.1
+  --port <port>        监听端口，默认 3210
+  --open               启动后自动打开浏览器
+  -h, --help           显示帮助
+`);
+}
+
+function htmlEscape(value) {
+  return String(value)
+    .replace(/&/g, '&amp;')
+    .replace(/</g, '&lt;')
+    .replace(/>/g, '&gt;');
+}
+
+function readJsonFile(filePath, fallback) {
+  try {
+    if (!fs.existsSync(filePath)) return fallback;
+    return JSON.parse(fs.readFileSync(filePath, 'utf8'));
+  } catch {
+    return fallback;
+  }
+}
+
+function isProcessAlive(pid) {
+  if (!Number.isInteger(pid) || Number(pid) <= 0) {
+    return false;
+  }
+  try {
+    process.kill(Number(pid), 0);
+    return true;
+  } catch (error) {
+    if (error?.code === 'EPERM') return true;
+    return false;
+  }
+}
+
+function getProcessCommand(pid) {
+  if (!Number.isInteger(pid) || Number(pid) <= 0) return '';
+  try {
+    if (process.platform === 'win32') {
+      return execFileSync('powershell.exe', [
+        '-NoProfile',
+        '-Command',
+        `(Get-CimInstance Win32_Process -Filter "ProcessId = ${String(pid)}" | Select-Object -ExpandProperty CommandLine)`,
+      ], {
+        encoding: 'utf8',
+        stdio: ['ignore', 'pipe', 'ignore'],
+      }).trim();
+    }
+    return execFileSync('ps', ['-p', String(pid), '-o', 'command='], {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'ignore'],
+    }).trim();
+  } catch {
+    return '';
+  }
+}
+
+function isMatchingWatcherProcess(state) {
+  if (!state?.pid || !state?.instance_id || !isProcessAlive(state.pid)) {
+    return false;
+  }
+  const command = getProcessCommand(state.pid);
+  if (!command) return false;
+  return command.includes('claw-auto-backup __watch')
+    && command.includes(`--instance-id ${state.instance_id}`);
+}
+
+function resolveEventLogPath(input) {
+  const raw = String(input || '').trim();
+  return raw ? path.resolve(raw) : '';
+}
+
+function buildStatus(stateFile, eventLog) {
+  const state = readJsonFile(stateFile, { enabled: false, watch_pairs: [] });
+  const running = state.enabled && isMatchingWatcherProcess(state);
+  return {
+    ...state,
+    enabled: state.enabled && running,
+    running,
+    event_log_path: eventLog || state.event_log_path || '',
+  };
+}
+
+function parseSinceOffset(input) {
+  const value = Number(input || 0);
+  if (!Number.isInteger(value) || value < 0) {
+    return 0;
+  }
+  return value;
+}
+
+function hasExplicitSince(input) {
+  return input !== null;
+}
+
+function getInitialOffset(filePath) {
+  if (!filePath) return 0;
+  try {
+    if (!fs.existsSync(filePath)) return 0;
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) return 0;
+    return stat.size;
+  } catch {
+    return 0;
+  }
+}
+
+function readEventsSnapshot(filePath, limit = 300) {
+  if (!filePath) {
+    return { eventLogPath: '', events: [], snapshotOffset: 0, error: null };
+  }
+  try {
+    if (!fs.existsSync(filePath)) {
+      return { eventLogPath: filePath, events: [], snapshotOffset: 0, error: `日志文件不存在: ${filePath}` };
+    }
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) {
+      return { eventLogPath: filePath, events: [], snapshotOffset: 0, error: `不是文件: ${filePath}` };
+    }
+    const fd = fs.openSync(filePath, 'r');
+    try {
+      const targetLines = limit > 0 ? limit : Number.MAX_SAFE_INTEGER;
+      const chunkSize = 64 * 1024;
+      let position = stat.size;
+      let startOffset = 0;
+      let linesFound = 0;
+      let skipTrailingNewline = false;
+
+      if (stat.size > 0) {
+        const lastByte = Buffer.alloc(1);
+        fs.readSync(fd, lastByte, 0, 1, stat.size - 1);
+        skipTrailingNewline = lastByte[0] === 0x0A;
+      }
+
+      while (position > 0 && linesFound < targetLines) {
+        const readSize = Math.min(chunkSize, position);
+        position -= readSize;
+        const buffer = Buffer.alloc(readSize);
+        fs.readSync(fd, buffer, 0, readSize, position);
+
+        for (let index = buffer.length - 1; index >= 0; index -= 1) {
+          if (buffer[index] !== 0x0A) continue;
+          const absoluteIndex = position + index;
+          if (skipTrailingNewline && absoluteIndex === stat.size - 1) {
+            skipTrailingNewline = false;
+            continue;
+          }
+          linesFound += 1;
+          if (linesFound === targetLines) {
+            startOffset = absoluteIndex + 1;
+            break;
+          }
+        }
+      }
+
+      const readLength = stat.size - startOffset;
+      const tailBuffer = Buffer.alloc(readLength);
+      if (readLength > 0) {
+        fs.readSync(fd, tailBuffer, 0, readLength, startOffset);
+      }
+      const lines = tailBuffer
+        .toString('utf8')
+        .split('\n')
+        .map((line) => line.trim())
+        .filter(Boolean);
+      const events = [];
+      for (const line of lines) {
+        try {
+          events.push(JSON.parse(line));
+        } catch {
+          // ignore malformed lines in temp event log
+        }
+      }
+      const trimmedEvents = limit > 0 ? events.slice(-limit) : events;
+      return {
+        eventLogPath: filePath,
+        events: trimmedEvents,
+        snapshotOffset: stat.size,
+        error: null,
+      };
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch (error) {
+    return {
+      eventLogPath: filePath,
+      events: [],
+      snapshotOffset: 0,
+      error: error?.message || String(error),
+    };
+  }
+}
+
+function renderPage(eventLogPath, stateFilePath) {
+  const embeddedEventPath = JSON.stringify(eventLogPath);
+  const embeddedStatePath = JSON.stringify(stateFilePath);
+  const displayEventPath = htmlEscape(eventLogPath);
+  const displayStatePath = htmlEscape(stateFilePath);
+  const displayCliName = htmlEscape(getDefaultCliName());
+
+  return `<!doctype html>
+<html lang="zh-CN">
+<head>
+  <meta charset="utf-8" />
+  <meta name="viewport" content="width=device-width, initial-scale=1" />
+  <title>Auto Backup Monitor</title>
+  <style>
+    :root {
+      --bg: #f5efe6;
+      --panel: rgba(255, 250, 244, 0.9);
+      --ink: #1d1a17;
+      --muted: #6d655d;
+      --line: rgba(49, 34, 23, 0.12);
+      --ok: #0f715f;
+      --warn: #b3582d;
+      --shadow: 0 20px 40px rgba(57, 35, 18, 0.08);
+    }
+    * { box-sizing: border-box; }
+    body {
+      margin: 0;
+      color: var(--ink);
+      font-family: "Avenir Next", "Segoe UI", sans-serif;
+      background:
+        radial-gradient(circle at top left, rgba(15,113,95,0.12), transparent 28%),
+        radial-gradient(circle at top right, rgba(179,88,45,0.10), transparent 22%),
+        linear-gradient(180deg, #f8f4ed 0%, #efe4d7 100%);
+    }
+    .shell {
+      max-width: 1120px;
+      margin: 0 auto;
+      padding: 28px 20px 48px;
+    }
+    .hero h1 {
+      margin: 0;
+      font-size: clamp(28px, 4vw, 44px);
+      line-height: 1;
+      letter-spacing: -0.03em;
+    }
+    .hero p {
+      margin: 12px 0 0;
+      color: var(--muted);
+      max-width: 860px;
+    }
+    .mono {
+      font-family: "SFMono-Regular", Menlo, monospace;
+      font-size: 12px;
+    }
+    .grid {
+      display: grid;
+      gap: 14px;
+      grid-template-columns: repeat(4, minmax(0, 1fr));
+      margin: 22px 0 24px;
+    }
+    .card, .panel {
+      background: var(--panel);
+      border: 1px solid var(--line);
+      border-radius: 18px;
+      box-shadow: var(--shadow);
+      backdrop-filter: blur(12px);
+    }
+    .card {
+      padding: 16px 18px;
+    }
+    .label {
+      color: var(--muted);
+      font-size: 12px;
+      text-transform: uppercase;
+      letter-spacing: 0.08em;
+    }
+    .value {
+      margin-top: 8px;
+      font-size: 28px;
+      font-weight: 700;
+      letter-spacing: -0.03em;
+    }
+    .layout {
+      display: grid;
+      gap: 16px;
+      grid-template-columns: 1.1fr 1.9fr;
+    }
+    .panel {
+      padding: 18px;
+    }
+    .panel h2 {
+      margin: 0 0 14px;
+      font-size: 16px;
+    }
+    .meta {
+      display: grid;
+      gap: 10px;
+    }
+    .meta-row {
+      display: flex;
+      justify-content: space-between;
+      gap: 16px;
+      border-bottom: 1px solid var(--line);
+      padding-bottom: 10px;
+      font-size: 14px;
+    }
+    .meta-row:last-child { border-bottom: 0; padding-bottom: 0; }
+    .timeline {
+      display: grid;
+      gap: 10px;
+      max-height: 72vh;
+      overflow: auto;
+    }
+    .event {
+      border: 1px solid var(--line);
+      border-radius: 14px;
+      padding: 14px;
+      background: rgba(255,255,255,0.58);
+    }
+    .event-top {
+      display: flex;
+      justify-content: space-between;
+      gap: 16px;
+      margin-bottom: 8px;
+      align-items: center;
+    }
+    .chip {
+      display: inline-flex;
+      border-radius: 999px;
+      padding: 5px 10px;
+      font-size: 11px;
+      font-weight: 700;
+      letter-spacing: 0.06em;
+      text-transform: uppercase;
+      background: rgba(15,113,95,0.12);
+      color: var(--ok);
+    }
+    .chip.fail {
+      background: rgba(179,88,45,0.12);
+      color: var(--warn);
+    }
+    .event-sub {
+      color: var(--muted);
+      font-size: 13px;
+      line-height: 1.45;
+      word-break: break-all;
+    }
+    .empty {
+      padding: 24px 0;
+      text-align: center;
+      color: var(--muted);
+    }
+    @media (max-width: 900px) {
+      .grid, .layout { grid-template-columns: 1fr; }
+    }
+  </style>
+</head>
+<body>
+  <div class="shell">
+    <section class="hero">
+      <h1>Auto Backup Monitor</h1>
+      <p>独立监控页。状态文件 <span class="mono">${displayStatePath}</span> 用来展示 watcher 状态；事件日志路径由下方输入框指定，实时展示自动备份触发、开始、结束和耗时。</p>
+    </section>
+
+    <section class="panel" style="margin: 20px 0 16px;">
+      <h2>Event Log</h2>
+      <div style="display:flex; gap:10px; flex-wrap:wrap; align-items:center;">
+        <input id="eventLogInput" class="mono" placeholder="/path/to/events.ndjson" value="${displayEventPath}" style="flex:1 1 480px; padding:12px 14px; border-radius:12px; border:1px solid var(--line); background:rgba(255,255,255,0.72); color:var(--ink);" />
+        <button id="connectBtn" style="padding:12px 16px; border:0; border-radius:12px; background:#0f715f; color:#fff; font-weight:700; cursor:pointer;">Connect</button>
+      </div>
+      <p class="event-sub" style="margin:10px 0 0;">不指定日志路径时，页面不会读取任何事件。需要和 ${displayCliName} claw-auto-backup enable --event-log &lt;path&gt; 使用同一路径。</p>
+    </section>
+
+    <section class="grid">
+      <article class="card"><div class="label">Total Events</div><div class="value" id="totalEvents">0</div></article>
+      <article class="card"><div class="label">Backups OK</div><div class="value" id="okCount">0</div></article>
+      <article class="card"><div class="label">Backups Failed</div><div class="value" id="failCount">0</div></article>
+      <article class="card"><div class="label">Avg Duration</div><div class="value" id="avgDuration">-</div></article>
+    </section>
+
+    <section class="layout">
+      <article class="panel">
+        <h2>Status</h2>
+        <div class="meta" id="statusPanel"></div>
+      </article>
+      <article class="panel">
+        <h2>Timeline</h2>
+        <div class="timeline" id="timeline"></div>
+      </article>
+    </section>
+  </div>
+
+  <script>
+    const initialEventLogPath = ${embeddedEventPath};
+    const stateFilePath = ${embeddedStatePath};
+    const timeline = document.getElementById('timeline');
+    const statusPanel = document.getElementById('statusPanel');
+    const eventLogInput = document.getElementById('eventLogInput');
+    const connectBtn = document.getElementById('connectBtn');
+    const totalEvents = document.getElementById('totalEvents');
+    const okCount = document.getElementById('okCount');
+    const failCount = document.getElementById('failCount');
+    const avgDuration = document.getElementById('avgDuration');
+    const events = [];
+    let activeEventLogPath = initialEventLogPath || '';
+    let source = null;
+
+    function fmtTime(ts) {
+      if (!ts) return '-';
+      try { return new Date(ts).toLocaleString(); } catch { return ts; }
+    }
+
+    function fmtDuration(ms) {
+      if (typeof ms !== 'number') return '-';
+      if (ms < 1000) return ms + 'ms';
+      return (ms / 1000).toFixed(2) + 's';
+    }
+
+    function esc(value) {
+      return String(value ?? '')
+        .replace(/&/g, '&amp;')
+        .replace(/</g, '&lt;')
+        .replace(/>/g, '&gt;')
+        .replace(/"/g, '&quot;')
+        .replace(/'/g, '&#39;');
+    }
+
+    function eventTitle(evt) {
+      switch (evt.type) {
+        case 'watcher_started': return 'Watcher started';
+        case 'watcher_stopped': return 'Watcher stopped';
+        case 'watch_event': return 'Filesystem change detected';
+        case 'backup_scheduled': return 'Backup scheduled';
+        case 'backup_deferred': return 'Backup deferred';
+        case 'backup_started': return 'Backup started';
+        case 'backup_finished': return 'Backup finished';
+        case 'backup_failed': return 'Backup failed';
+        default: return evt.type || 'event';
+      }
+    }
+
+    function eventDetail(evt) {
+      const bits = [];
+      if (evt.source) bits.push('source: ' + evt.source);
+      if (evt.dest) bits.push('dest: ' + evt.dest);
+      if (evt.path) bits.push('path: ' + evt.path);
+      if (evt.fs_event) bits.push('fs_event: ' + evt.fs_event);
+      if (evt.run_id) bits.push('run_id: ' + evt.run_id);
+      if (typeof evt.duration_ms === 'number') bits.push('duration: ' + fmtDuration(evt.duration_ms));
+      if (evt.error) bits.push('error: ' + evt.error);
+      if (evt.message) bits.push('message: ' + evt.message);
+      return bits.join(' | ');
+    }
+
+    function renderStatus(status) {
+      const rows = [
+        ['Enabled', status.enabled ? 'true' : 'false'],
+        ['PID', status.pid || '-'],
+        ['Started', fmtTime(status.started_at)],
+        ['Event Log', activeEventLogPath || '-'],
+        ['State File', stateFilePath],
+        ['Last Event', fmtTime(status.last_event_at)],
+        ['Last Backup', fmtTime(status.last_backup_at)],
+        ['Last Result', status.last_backup_result ? ((status.last_backup_result.success ? 'success' : 'failed') + ' - ' + status.last_backup_result.message) : '-'],
+      ];
+      statusPanel.innerHTML = rows.map(([k, v]) => '<div class="meta-row"><strong>' + esc(k) + '</strong><span class="mono">' + esc(v) + '</span></div>').join('');
+    }
+
+    function renderSummary() {
+      totalEvents.textContent = String(events.length);
+      const ok = events.filter((evt) => evt.type === 'backup_finished' && evt.success !== false).length;
+      const fail = events.filter((evt) => evt.type === 'backup_failed' || (evt.type === 'backup_finished' && evt.success === false)).length;
+      const durations = events.filter((evt) => typeof evt.duration_ms === 'number').map((evt) => evt.duration_ms);
+      const avg = durations.length ? Math.round(durations.reduce((sum, value) => sum + value, 0) / durations.length) : null;
+      okCount.textContent = String(ok);
+      failCount.textContent = String(fail);
+      avgDuration.textContent = avg === null ? '-' : fmtDuration(avg);
+    }
+
+    function renderTimeline() {
+      if (!events.length) {
+        timeline.innerHTML = '<div class="empty">还没有事件，先触发一次自动备份。</div>';
+        return;
+      }
+      timeline.innerHTML = events.slice().reverse().map((evt) => {
+        const fail = evt.type === 'backup_failed' || evt.success === false;
+        return '<div class="event">'
+          + '<div class="event-top"><div><strong>' + esc(eventTitle(evt)) + '</strong></div><div class="chip ' + (fail ? 'fail' : '') + '">' + esc(evt.type) + '</div></div>'
+          + '<div class="event-sub">' + esc(fmtTime(evt.ts)) + '</div>'
+          + '<div class="event-sub">' + esc(eventDetail(evt) || 'no detail') + '</div>'
+          + '</div>';
+      }).join('');
+    }
+
+    function pushEvents(nextEvents) {
+      events.push(...nextEvents);
+      renderSummary();
+      renderTimeline();
+    }
+
+    function resetEvents() {
+      events.length = 0;
+      renderSummary();
+      renderTimeline();
+    }
+
+    async function refreshStatus() {
+      const res = await fetch('/api/status');
+      const data = await res.json();
+      renderStatus(data.result || {});
+    }
+
+    async function loadInitial(logPath) {
+      const [statusRes, eventsRes] = await Promise.all([
+        fetch('/api/status'),
+        fetch('/api/events?limit=300&eventLog=' + encodeURIComponent(logPath || '')),
+      ]);
+      const statusData = await statusRes.json();
+      const eventsData = await eventsRes.json();
+      renderStatus(statusData.result || {});
+      resetEvents();
+      pushEvents(eventsData.result?.events || []);
+      if (eventsData.result?.error) {
+        timeline.innerHTML = '<div class="empty">日志读取失败: ' + esc(eventsData.result.error) + '</div>';
+      }
+      return eventsData.result?.snapshotOffset || 0;
+    }
+
+    function connect(logPath, snapshotOffset) {
+      if (source) {
+        source.close();
+      }
+      source = new EventSource(
+        '/api/events/stream?eventLog=' + encodeURIComponent(logPath || '')
+        + '&since=' + encodeURIComponent(String(snapshotOffset || 0))
+      );
+      source.onmessage = (message) => {
+        try {
+          const evt = JSON.parse(message.data);
+          pushEvents([evt]);
+          refreshStatus().catch(() => {});
+        } catch {}
+      };
+      source.addEventListener('log-error', (message) => {
+        try {
+          const payload = JSON.parse(message.data);
+          timeline.innerHTML = '<div class="empty">日志读取失败: ' + esc(payload.error || 'unknown error') + '</div>';
+        } catch {}
+      });
+    }
+
+    async function connectToLogPath() {
+      const nextPath = String(eventLogInput.value || '').trim();
+      activeEventLogPath = nextPath;
+      const snapshotOffset = await loadInitial(nextPath);
+      connect(nextPath, snapshotOffset);
+    }
+
+    connectBtn.addEventListener('click', () => {
+      connectToLogPath().catch((error) => {
+        timeline.innerHTML = '<div class="empty">加载失败: ' + esc(error?.message || error) + '</div>';
+      });
+    });
+    eventLogInput.addEventListener('keydown', (event) => {
+      if (event.key === 'Enter') {
+        event.preventDefault();
+        connectBtn.click();
+      }
+    });
+
+    if (activeEventLogPath) {
+      connectToLogPath().catch((error) => {
+        timeline.innerHTML = '<div class="empty">加载失败: ' + esc(error?.message || error) + '</div>';
+      });
+    } else {
+      refreshStatus().catch(() => {});
+      renderSummary();
+      renderTimeline();
+    }
+    setInterval(() => { refreshStatus().catch(() => {}); }, 5000);
+  </script>
+</body>
+</html>`;
+}
+
+function json(res, statusCode, payload) {
+  res.writeHead(statusCode, {
+    'Content-Type': 'application/json; charset=utf-8',
+    'Cache-Control': 'no-cache',
+  });
+  res.end(JSON.stringify(payload));
+}
+
+function readNewEventsSince(filePath, offset, remainder) {
+  if (!filePath) {
+    return { offset: 0, remainder: '', events: [], error: null };
+  }
+  try {
+    if (!fs.existsSync(filePath)) {
+      return { offset: 0, remainder: '', events: [], error: `日志文件不存在: ${filePath}` };
+    }
+    const stat = fs.statSync(filePath);
+    if (!stat.isFile()) {
+      return { offset, remainder, events: [], error: `不是文件: ${filePath}` };
+    }
+    if (stat.size < offset) {
+      offset = 0;
+      remainder = '';
+    }
+    if (stat.size === offset) {
+      return { offset, remainder, events: [], error: null };
+    }
+
+    const fd = fs.openSync(filePath, 'r');
+    try {
+      const length = stat.size - offset;
+      const buffer = Buffer.alloc(length);
+      fs.readSync(fd, buffer, 0, length, offset);
+      const text = remainder + buffer.toString('utf8');
+      const lines = text.split('\n');
+      const nextRemainder = lines.pop() || '';
+      const events = lines
+        .map((line) => line.trim())
+        .filter(Boolean)
+        .flatMap((line) => {
+          try {
+            return [JSON.parse(line)];
+          } catch {
+            return [];
+          }
+        });
+      return { offset: stat.size, remainder: nextRemainder, events, error: null };
+    } finally {
+      fs.closeSync(fd);
+    }
+  } catch (error) {
+    return {
+      offset,
+      remainder,
+      events: [],
+      error: error?.message || String(error),
+    };
+  }
+}
+
+function maybeOpenBrowser(url) {
+  let command;
+  let args;
+  if (process.platform === 'darwin') {
+    command = 'open';
+    args = [url];
+  } else if (process.platform === 'win32') {
+    command = 'cmd';
+    args = ['/c', 'start', '', url];
+  } else {
+    command = 'xdg-open';
+    args = [url];
+  }
+  try {
+    const child = spawn(command, args, { detached: true, stdio: 'ignore' });
+    child.unref();
+  } catch {
+    // ignore browser open failures
+  }
+}
+
+async function main() {
+  const options = parseArgs(process.argv.slice(2));
+  const clients = new Set();
+  const clientStates = new Map();
+
+  const server = http.createServer((req, res) => {
+    const url = new URL(req.url || '/', `http://${req.headers.host || `${options.host}:${options.port}`}`);
+
+    if (url.pathname === '/') {
+      res.writeHead(200, { 'Content-Type': 'text/html; charset=utf-8' });
+      res.end(renderPage(options.eventLog, options.stateFile));
+      return;
+    }
+
+    if (url.pathname === '/api/status') {
+      json(res, 200, {
+        success: true,
+        result: buildStatus(options.stateFile, ''),
+      });
+      return;
+    }
+
+    if (url.pathname === '/api/events') {
+      const limit = Number(url.searchParams.get('limit') || 300);
+      const eventLog = resolveEventLogPath(url.searchParams.get('eventLog') || options.eventLog);
+      const snapshot = readEventsSnapshot(eventLog, limit);
+      json(res, 200, {
+        success: true,
+        result: {
+          eventLogPath: snapshot.eventLogPath,
+          events: snapshot.events,
+          snapshotOffset: snapshot.snapshotOffset,
+          error: snapshot.error,
+        },
+      });
+      return;
+    }
+
+    if (url.pathname === '/api/events/stream') {
+      const eventLog = resolveEventLogPath(url.searchParams.get('eventLog') || options.eventLog);
+      const sinceInput = url.searchParams.get('since');
+      const since = parseSinceOffset(sinceInput);
+      res.writeHead(200, {
+        'Content-Type': 'text/event-stream',
+        'Cache-Control': 'no-cache',
+        Connection: 'keep-alive',
+      });
+      res.write(': connected\n\n');
+      clients.add(res);
+      clientStates.set(res, {
+        eventLog,
+        offset: hasExplicitSince(sinceInput) ? since : getInitialOffset(eventLog),
+        remainder: '',
+      });
+      const heartbeat = setInterval(() => {
+        res.write(': heartbeat\n\n');
+      }, 15000);
+      req.on('close', () => {
+        clearInterval(heartbeat);
+        clients.delete(res);
+        clientStates.delete(res);
+      });
+      return;
+    }
+
+    json(res, 404, {
+      success: false,
+      error: 'not found',
+    });
+  });
+
+  const poll = setInterval(() => {
+    for (const client of clients) {
+      const state = clientStates.get(client);
+      if (!state) continue;
+      const next = readNewEventsSince(state.eventLog, state.offset, state.remainder);
+      state.offset = next.offset;
+      state.remainder = next.remainder;
+      if (next.error && next.error !== state.lastError) {
+        client.write(`event: log-error\ndata: ${JSON.stringify({ error: next.error, eventLogPath: state.eventLog })}\n\n`);
+        state.lastError = next.error;
+      } else if (!next.error) {
+        state.lastError = null;
+      }
+      for (const event of next.events) {
+        client.write(`data: ${JSON.stringify(event)}\n\n`);
+      }
+    }
+  }, 1000);
+
+  await new Promise((resolve, reject) => {
+    server.listen(options.port, options.host, resolve);
+    server.on('error', reject);
+  });
+
+  const url = `http://${options.host}:${options.port}`;
+  process.stdout.write(`Auto backup monitor running at ${url}\n`);
+  process.stdout.write(`Initial event log: ${options.eventLog || '(not set)'}\n`);
+  process.stdout.write(`State file: ${options.stateFile}\n`);
+  if (options.open) {
+    maybeOpenBrowser(url);
+  }
+
+  const shutdown = () => {
+    clearInterval(poll);
+    for (const client of clients) {
+      client.end();
+    }
+    server.close(() => process.exit(0));
+  };
+
+  process.on('SIGINT', shutdown);
+  process.on('SIGTERM', shutdown);
+}
+
+main().catch((error) => {
+  process.stderr.write(`Auto backup monitor failed: ${error.message || error}\n`);
+  process.exit(1);
+});