@web-auto/camo 0.1.3 → 0.1.4

package/src/events/ws-server.mjs

@@ -0,0 +1,239 @@
+import crypto from 'node:crypto';
+import fs from 'node:fs';
+import http from 'node:http';
+import { ensureProgressEventStore, getProgressEventsFile, readRecentProgressEvents } from './progress-log.mjs';
+
+const WS_GUID = '258EAFA5-E914-47DA-95CA-C5AB0DC85B11';
+const DEFAULT_POLL_MS = 220;
+const DEFAULT_REPLAY_LIMIT = 50;
+
+function parseList(value) {
+  return String(value || '')
+    .split(',')
+    .map((item) => item.trim())
+    .filter(Boolean);
+}
+
+function buildFilter(reqUrl = '/') {
+  const url = new URL(reqUrl, 'http://127.0.0.1');
+  const events = new Set(parseList(url.searchParams.get('events')));
+  return {
+    profileId: url.searchParams.get('profileId') || null,
+    runId: url.searchParams.get('runId') || null,
+    mode: url.searchParams.get('mode') || null,
+    events,
+    replay: Math.max(0, Number(url.searchParams.get('replay') ?? DEFAULT_REPLAY_LIMIT) || DEFAULT_REPLAY_LIMIT),
+  };
+}
+
+function matchesFilter(filter, event) {
+  if (!event || typeof event !== 'object') return false;
+  if (filter.profileId && String(event.profileId || '') !== filter.profileId) return false;
+  if (filter.runId && String(event.runId || '') !== filter.runId) return false;
+  if (filter.mode && String(event.mode || '') !== filter.mode) return false;
+  if (filter.events.size > 0 && !filter.events.has(String(event.event || ''))) return false;
+  return true;
+}
+
+function frameText(text) {
+  const payload = Buffer.from(String(text), 'utf8');
+  const length = payload.length;
+  if (length < 126) {
+    return Buffer.concat([Buffer.from([0x81, length]), payload]);
+  }
+  if (length < 65536) {
+    const header = Buffer.alloc(4);
+    header[0] = 0x81;
+    header[1] = 126;
+    header.writeUInt16BE(length, 2);
+    return Buffer.concat([header, payload]);
+  }
+  const header = Buffer.alloc(10);
+  header[0] = 0x81;
+  header[1] = 127;
+  header.writeBigUInt64BE(BigInt(length), 2);
+  return Buffer.concat([header, payload]);
+}
+
+function framePong() {
+  return Buffer.from([0x8A, 0x00]);
+}
+
+function frameClose() {
+  return Buffer.from([0x88, 0x00]);
+}
+
+function parseOpcode(chunk) {
+  if (!Buffer.isBuffer(chunk) || chunk.length === 0) return null;
+  return chunk[0] & 0x0f;
+}
+
+function acceptWebSocketKey(key) {
+  return crypto.createHash('sha1').update(`${key}${WS_GUID}`).digest('base64');
+}
+
+export function createProgressWsServer({
+  host = '127.0.0.1',
+  port = 7788,
+  pollMs = DEFAULT_POLL_MS,
+  fromStart = false,
+} = {}) {
+  ensureProgressEventStore();
+  const eventsFile = getProgressEventsFile();
+  const clients = new Set();
+  let carry = '';
+  let cursor = fromStart ? 0 : fs.statSync(eventsFile).size;
+  let pollTimer = null;
+
+  const server = http.createServer((req, res) => {
+    if (req.url === '/health') {
+      res.writeHead(200, { 'Content-Type': 'application/json' });
+      res.end(JSON.stringify({
+        ok: true,
+        wsPath: '/events',
+        clients: clients.size,
+        file: eventsFile,
+      }));
+      return;
+    }
+    res.writeHead(200, { 'Content-Type': 'application/json' });
+    res.end(JSON.stringify({
+      ok: true,
+      message: 'Use WebSocket upgrade on /events',
+      ws: `ws://${host}:${port}/events`,
+      file: eventsFile,
+    }));
+  });
+
+  const sendEvent = (client, event) => {
+    if (!client.socket.writable) return;
+    if (!matchesFilter(client.filter, event)) return;
+    client.socket.write(frameText(JSON.stringify(event)));
+  };
+
+  const broadcast = (event) => {
+    for (const client of clients) {
+      sendEvent(client, event);
+    }
+  };
+
+  const pollEvents = () => {
+    let stat = null;
+    try {
+      stat = fs.statSync(eventsFile);
+    } catch {
+      return;
+    }
+    if (stat.size < cursor) {
+      cursor = 0;
+      carry = '';
+    }
+    if (stat.size === cursor) return;
+
+    const fd = fs.openSync(eventsFile, 'r');
+    try {
+      const length = stat.size - cursor;
+      const buffer = Buffer.alloc(length);
+      fs.readSync(fd, buffer, 0, length, cursor);
+      cursor = stat.size;
+      carry += buffer.toString('utf8');
+      const lines = carry.split('\n');
+      carry = lines.pop() || '';
+      for (const line of lines) {
+        const raw = line.trim();
+        if (!raw) continue;
+        try {
+          const event = JSON.parse(raw);
+          broadcast(event);
+        } catch {
+          // ignore malformed lines
+        }
+      }
+    } finally {
+      fs.closeSync(fd);
+    }
+  };
+
+  server.on('upgrade', (req, socket) => {
+    try {
+      const reqUrl = req.url || '/';
+      const parsed = new URL(reqUrl, 'http://127.0.0.1');
+      if (parsed.pathname !== '/events') {
+        socket.write('HTTP/1.1 404 Not Found\r\n\r\n');
+        socket.destroy();
+        return;
+      }
+
+      const key = req.headers['sec-websocket-key'];
+      if (!key || Array.isArray(key)) {
+        socket.write('HTTP/1.1 400 Bad Request\r\n\r\n');
+        socket.destroy();
+        return;
+      }
+
+      const accept = acceptWebSocketKey(key);
+      socket.write([
+        'HTTP/1.1 101 Switching Protocols',
+        'Upgrade: websocket',
+        'Connection: Upgrade',
+        `Sec-WebSocket-Accept: ${accept}`,
+        '\r\n',
+      ].join('\r\n'));
+
+      const filter = buildFilter(reqUrl);
+      const client = { socket, filter };
+      clients.add(client);
+
+      if (filter.replay > 0) {
+        const replay = readRecentProgressEvents(filter.replay);
+        for (const event of replay) {
+          sendEvent(client, event);
+        }
+      }
+
+      socket.on('data', (chunk) => {
+        const opcode = parseOpcode(chunk);
+        if (opcode === 0x8) {
+          socket.end(frameClose());
+        } else if (opcode === 0x9) {
+          socket.write(framePong());
+        }
+      });
+      socket.on('error', () => {
+        clients.delete(client);
+      });
+      socket.on('close', () => {
+        clients.delete(client);
+      });
+      socket.on('end', () => {
+        clients.delete(client);
+      });
+    } catch {
+      socket.destroy();
+    }
+  });
+
+  return {
+    async start() {
+      await new Promise((resolve, reject) => {
+        server.once('error', reject);
+        server.listen(Number(port), host, resolve);
+      });
+      pollTimer = setInterval(pollEvents, Math.max(80, Number(pollMs) || DEFAULT_POLL_MS));
+      return {
+        host,
+        port: Number(port),
+        wsUrl: `ws://${host}:${port}/events`,
+        file: eventsFile,
+      };
+    },
+    async stop() {
+      if (pollTimer) {
+        clearInterval(pollTimer);
+        pollTimer = null;
+      }
+      await new Promise((resolve) => server.close(resolve));
+    },
+  };
+}
+

package/src/lib/client.mjs

@@ -1,6 +1,11 @@
 // Camo Container Client - High-level API for container subscription
 
-import { callAPI, getSessionByProfile, checkBrowserService } from '../utils/browser-service.mjs';
+import {
+  checkBrowserService,
+  getDomSnapshotByProfile,
+  getSessionByProfile,
+  getViewportByProfile,
+} from '../utils/browser-service.mjs';
 import { getDefaultProfile } from '../utils/config.mjs';
 import { getChangeNotifier } from '../container/change-notifier.mjs';
 import { createElementFilter } from '../container/element-filter.mjs';
@@ -36,8 +41,7 @@ export class CamoContainerClient {
   async getSnapshot() {
     await this.ensureSession();
 
-    const result = await callAPI(`/session/${this.session.session_id}/dom-tree`, { method: 'POST' });
-    this.lastSnapshot = result.dom_tree || result;
+    this.lastSnapshot = await getDomSnapshotByProfile(this.profileId);
     return this.lastSnapshot;
   }
 
@@ -45,8 +49,7 @@ export class CamoContainerClient {
     await this.ensureSession();
 
     try {
-      const result = await callAPI(`/session/${this.session.session_id}/viewport`);
-      this.viewport = result.viewport || this.viewport;
+      this.viewport = await getViewportByProfile(this.profileId);
     } catch {}
 
     return this.viewport;

package/src/lifecycle/session-registry.mjs

@@ -105,10 +105,14 @@ export function markSessionActive(profileId, updates = {}) {
 export function markSessionClosed(profileId) {
   const sessionFile = getSessionFile(profileId);
   if (fs.existsSync(sessionFile)) {
-    const existing = JSON.parse(fs.readFileSync(sessionFile, 'utf-8'));
-    existing.status = 'closed';
-    existing.closedAt = Date.now();
-    fs.writeFileSync(sessionFile, JSON.stringify(existing, null, 2));
+    try {
+      const existing = JSON.parse(fs.readFileSync(sessionFile, 'utf-8'));
+      existing.status = 'closed';
+      existing.closedAt = Date.now();
+      fs.writeFileSync(sessionFile, JSON.stringify(existing, null, 2));
+    } catch {
+      // Best-effort close: continue with removal even for corrupted metadata.
+    }
   }
   return unregisterSession(profileId);
 }

package/src/lifecycle/session-watchdog.mjs

@@ -0,0 +1,220 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import os from 'node:os';
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+import { callAPI } from '../utils/browser-service.mjs';
+import { releaseLock } from './lock.mjs';
+import { getSessionInfo, markSessionClosed } from './session-registry.mjs';
+
+const WATCHDOG_DIR = path.join(os.homedir(), '.webauto', 'run', 'camo-watchdogs');
+
+function ensureWatchdogDir() {
+  if (!fs.existsSync(WATCHDOG_DIR)) {
+    fs.mkdirSync(WATCHDOG_DIR, { recursive: true });
+  }
+}
+
+function getWatchdogFile(profileId) {
+  ensureWatchdogDir();
+  return path.join(WATCHDOG_DIR, `${profileId}.json`);
+}
+
+function readWatchdogRecord(profileId) {
+  const file = getWatchdogFile(profileId);
+  if (!fs.existsSync(file)) return null;
+  try {
+    return JSON.parse(fs.readFileSync(file, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+function writeWatchdogRecord(profileId, record) {
+  const file = getWatchdogFile(profileId);
+  fs.writeFileSync(file, JSON.stringify(record, null, 2));
+}
+
+function removeWatchdogRecord(profileId) {
+  const file = getWatchdogFile(profileId);
+  if (fs.existsSync(file)) {
+    fs.unlinkSync(file);
+  }
+}
+
+function isProcessAlive(pid) {
+  const target = Number(pid);
+  if (!Number.isFinite(target) || target <= 0) return false;
+  try {
+    process.kill(target, 0);
+    return true;
+  } catch {
+    return false;
+  }
+}
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function isBlankUrl(url) {
+  const text = String(url || '').trim().toLowerCase();
+  return text === '' || text === 'about:blank' || text === 'about:blank#blocked';
+}
+
+function shouldExitMonitor(profileId) {
+  const info = getSessionInfo(profileId);
+  return !info || info.status !== 'active';
+}
+
+async function cleanupSession(profileId) {
+  await callAPI('stop', { profileId }).catch(() => {});
+  releaseLock(profileId);
+  markSessionClosed(profileId);
+}
+
+async function runMonitor(profileId, options = {}) {
+  const intervalMs = Math.max(500, Number(options.intervalMs) || 1200);
+  const emptyThreshold = Math.max(1, Number(options.emptyThreshold) || 2);
+  const blankThreshold = Math.max(1, Number(options.blankThreshold) || 3);
+
+  let seenAnyPage = false;
+  let seenNonBlankPage = false;
+  let emptyStreak = 0;
+  let blankOnlyStreak = 0;
+
+  while (true) {
+    if (shouldExitMonitor(profileId)) return;
+
+    let sessions = [];
+    try {
+      const status = await callAPI('getStatus', {});
+      sessions = Array.isArray(status?.sessions) ? status.sessions : [];
+    } catch {
+      // Service unavailable; exit monitor silently.
+      return;
+    }
+
+    const liveSession = sessions.find((item) => item?.profileId === profileId);
+    if (!liveSession) {
+      releaseLock(profileId);
+      markSessionClosed(profileId);
+      return;
+    }
+
+    let pages = [];
+    try {
+      const listed = await callAPI('page:list', { profileId });
+      pages = Array.isArray(listed?.pages) ? listed.pages : [];
+    } catch {
+      // Session lookup failed in page:list: treat as closed.
+      releaseLock(profileId);
+      markSessionClosed(profileId);
+      return;
+    }
+
+    if (pages.length > 0) {
+      seenAnyPage = true;
+      if (pages.some((item) => !isBlankUrl(item?.url))) {
+        seenNonBlankPage = true;
+      }
+    }
+
+    const blankOnly = pages.length > 0 && pages.every((item) => isBlankUrl(item?.url));
+
+    if (seenAnyPage && pages.length === 0) {
+      emptyStreak += 1;
+    } else {
+      emptyStreak = 0;
+    }
+
+    if (seenNonBlankPage && blankOnly) {
+      blankOnlyStreak += 1;
+    } else {
+      blankOnlyStreak = 0;
+    }
+
+    if (emptyStreak >= emptyThreshold || blankOnlyStreak >= blankThreshold) {
+      await cleanupSession(profileId);
+      return;
+    }
+
+    await sleep(intervalMs);
+  }
+}
+
+export function startSessionWatchdog(profileId) {
+  const normalized = String(profileId || '').trim();
+  if (!normalized) return { ok: false, reason: 'profile_required' };
+
+  const existing = readWatchdogRecord(normalized);
+  if (existing?.pid && isProcessAlive(existing.pid)) {
+    return { ok: true, started: false, pid: existing.pid };
+  }
+
+  const commandPath = fileURLToPath(new URL('../cli.mjs', import.meta.url));
+  const child = spawn(process.execPath, [commandPath, '__session-watchdog', normalized], {
+    detached: true,
+    stdio: 'ignore',
+    env: {
+      ...process.env,
+      CAMO_WATCHDOG_CHILD: '1',
+    },
+  });
+  child.unref();
+
+  const childPid = Number(child.pid);
+  if (!Number.isFinite(childPid) || childPid <= 0) {
+    return { ok: false, reason: 'spawn_failed' };
+  }
+
+  writeWatchdogRecord(normalized, {
+    profileId: normalized,
+    pid: childPid,
+    startedAt: Date.now(),
+  });
+  return { ok: true, started: true, pid: childPid };
+}
+
+export function stopSessionWatchdog(profileId) {
+  const normalized = String(profileId || '').trim();
+  if (!normalized) return false;
+  const record = readWatchdogRecord(normalized);
+  if (record?.pid && isProcessAlive(record.pid)) {
+    try {
+      process.kill(record.pid, 'SIGTERM');
+    } catch {
+      // Ignore kill failure and still cleanup record.
+    }
+  }
+  removeWatchdogRecord(normalized);
+  return true;
+}
+
+export function stopAllSessionWatchdogs() {
+  ensureWatchdogDir();
+  const files = fs.readdirSync(WATCHDOG_DIR).filter((name) => name.endsWith('.json'));
+  for (const file of files) {
+    const profileId = file.slice(0, -'.json'.length);
+    stopSessionWatchdog(profileId);
+  }
+}
+
+export async function handleSessionWatchdogCommand(args) {
+  const profileId = String(args[1] || '').trim();
+  if (!profileId) {
+    throw new Error('Usage: camo __session-watchdog <profileId>');
+  }
+
+  const cleanup = () => removeWatchdogRecord(profileId);
+  process.on('SIGINT', cleanup);
+  process.on('SIGTERM', cleanup);
+  process.on('exit', cleanup);
+
+  try {
+    await runMonitor(profileId);
+  } finally {
+    cleanup();
+  }
+}