@web-auto/camo 0.1.2 → 0.1.4

package/src/core/browser.mjs

@@ -0,0 +1,270 @@
+/**
+ * Core browser control module - Direct camoufox integration
+ * No external browser-service dependency
+ */
+import { spawn, execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const CONFIG_DIR = path.join(os.homedir(), '.webauto');
+const PROFILES_DIR = path.join(CONFIG_DIR, 'profiles');
+
+// Active browser instances registry (in-memory)
+const activeBrowsers = new Map();
+
+/**
+ * Detect camoufox executable path
+ */
+export function detectCamoufoxPath() {
+  try {
+    const cmd = process.platform === 'win32' ? 'python -m camoufox path' : 'python3 -m camoufox path';
+    const out = execSync(cmd, {
+      encoding: 'utf8',
+      stdio: ['ignore', 'pipe', 'pipe'],
+      timeout: 30000,
+    });
+    const lines = out.trim().split(/\r?\n/);
+    for (let i = lines.length - 1; i >= 0; i -= 1) {
+      const line = lines[i].trim();
+      if (line && (line.startsWith('/') || line.match(/^[A-Z]:\\/))) return line;
+    }
+  } catch {
+    return null;
+  }
+  return null;
+}
+
+/**
+ * Ensure camoufox is installed
+ */
+export async function ensureCamoufox() {
+  const camoufoxPath = detectCamoufoxPath();
+  if (camoufoxPath) return camoufoxPath;
+
+  console.log('Camoufox not found. Installing...');
+  try {
+    execSync('npx --yes --package=camoufox camoufox fetch', { stdio: 'inherit' });
+    const newPath = detectCamoufoxPath();
+    if (!newPath) throw new Error('Camoufox install finished but executable was not detected');
+    console.log('Camoufox installed at:', newPath);
+    return newPath;
+  } catch (err) {
+    throw new Error(`Failed to install camoufox: ${err.message}`);
+  }
+}
+
+/**
+ * Get profile directory
+ */
+export function getProfileDir(profileId) {
+  return path.join(PROFILES_DIR, profileId);
+}
+
+/**
+ * Ensure profile exists
+ */
+export function ensureProfile(profileId) {
+  const profileDir = getProfileDir(profileId);
+  if (!fs.existsSync(profileDir)) {
+    fs.mkdirSync(profileDir, { recursive: true });
+  }
+  return profileDir;
+}
+
+/**
+ * Check if browser is running for profile
+ */
+export function isBrowserRunning(profileId) {
+  const browser = activeBrowsers.get(profileId);
+  if (!browser) return false;
+  return browser.process && !browser.process.killed;
+}
+
+/**
+ * Launch browser for profile
+ */
+export async function launchBrowser(profileId, options = {}) {
+  if (isBrowserRunning(profileId)) {
+    throw new Error(`Browser already running for profile: ${profileId}`);
+  }
+
+  const camoufoxPath = await ensureCamoufox();
+  const profileDir = ensureProfile(profileId);
+
+  // Build launch arguments
+  const args = [
+    '-P', profileDir,
+    '--headless=false',
+  ];
+
+  if (options.url) {
+    args.push('-url', options.url);
+  }
+
+  // Launch camoufox
+  const browserProcess = spawn(camoufoxPath, args, {
+    detached: false,
+    stdio: ['ignore', 'pipe', 'pipe'],
+  });
+
+  const browser = {
+    profileId,
+    process: browserProcess,
+    profileDir,
+    startTime: Date.now(),
+    pages: [],
+    currentPage: 0,
+    wsEndpoint: null,
+  };
+
+  activeBrowsers.set(profileId, browser);
+
+  // Handle process exit
+  browserProcess.on('exit', (code) => {
+    activeBrowsers.delete(profileId);
+  });
+
+  // Wait for browser to be ready
+  await new Promise((resolve, reject) => {
+    const timeout = setTimeout(() => {
+      browserProcess.kill();
+      reject(new Error('Browser failed to start within timeout'));
+    }, 30000);
+
+    // Check for ready signal in stdout
+    browserProcess.stdout.on('data', (data) => {
+      const line = data.toString();
+      if (line.includes('Browser ready') || line.includes('Listening')) {
+        clearTimeout(timeout);
+        resolve();
+      }
+    });
+
+    // Also resolve after a short delay as fallback
+    setTimeout(() => {
+      clearTimeout(timeout);
+      resolve();
+    }, 5000);
+  });
+
+  return browser;
+}
+
+/**
+ * Stop browser for profile
+ */
+export async function stopBrowser(profileId) {
+  const browser = activeBrowsers.get(profileId);
+  if (!browser) {
+    throw new Error(`No browser running for profile: ${profileId}`);
+  }
+
+  if (browser.process && !browser.process.killed) {
+    browser.process.kill('SIGTERM');
+    // Wait for graceful shutdown
+    await new Promise((resolve) => {
+      const timeout = setTimeout(() => {
+        if (browser.process && !browser.process.killed) {
+          browser.process.kill('SIGKILL');
+        }
+        resolve();
+      }, 5000);
+
+      browser.process.on('exit', () => {
+        clearTimeout(timeout);
+        resolve();
+      });
+    });
+  }
+
+  activeBrowsers.delete(profileId);
+  return { ok: true, profileId, stopped: true };
+}
+
+/**
+ * Get browser status
+ */
+export function getBrowserStatus(profileId) {
+  if (profileId) {
+    const browser = activeBrowsers.get(profileId);
+    if (!browser) return null;
+    return {
+      profileId,
+      running: isBrowserRunning(profileId),
+      startTime: browser.startTime,
+      uptime: Date.now() - browser.startTime,
+      pages: browser.pages,
+      currentPage: browser.currentPage,
+    };
+  }
+
+  // Return all sessions
+  return Array.from(activeBrowsers.entries()).map(([id, b]) => ({
+    profileId: id,
+    running: isBrowserRunning(id),
+    startTime: b.startTime,
+    uptime: Date.now() - b.startTime,
+    pages: b.pages,
+    currentPage: b.currentPage,
+  }));
+}
+
+/**
+ * Get Playwright browser instance for profile
+ * Creates one if needed using camoufox-js
+ */
+export async function getPlaywrightBrowser(profileId) {
+  const { chromium } = await import('playwright');
+  
+  const browser = activeBrowsers.get(profileId);
+  if (!browser) {
+    throw new Error(`No browser session for profile: ${profileId}. Run 'camo start ${profileId}' first.`);
+  }
+
+  if (browser.pwBrowser) {
+    return browser.pwBrowser;
+  }
+
+  // Connect to camoufox using CDP
+  const pwBrowser = await chromium.connectOverCDP(browser.wsEndpoint || 'http://127.0.0.1:9222');
+  browser.pwBrowser = pwBrowser;
+  return pwBrowser;
+}
+
+/**
+ * Get current page for profile
+ */
+export async function getCurrentPage(profileId) {
+  const browser = activeBrowsers.get(profileId);
+  if (!browser) {
+    throw new Error(`No browser session for profile: ${profileId}`);
+  }
+
+  if (browser.currentPage) {
+    return browser.currentPage;
+  }
+
+  // Get page from Playwright
+  const pwBrowser = await getPlaywrightBrowser(profileId);
+  const contexts = pwBrowser.contexts();
+  if (contexts.length === 0) {
+    throw new Error('No browser contexts available');
+  }
+  const pages = contexts[0].pages();
+  if (pages.length === 0) {
+    throw new Error('No pages available');
+  }
+
+  browser.currentPage = pages[pages.length - 1];
+  return browser.currentPage;
+}
+
+
+/**
+ * Get active browser (alias for registry lookup)
+ */
+export function getActiveBrowser(profileId) {
+  return activeBrowsers.get(profileId) || null;
+}
+

package/src/core/index.mjs

@@ -0,0 +1,53 @@
+/**
+ * Core module exports
+ */
+
+export * from './browser.mjs';
+export * from './actions.mjs';
+export * from './utils.mjs';
+
+// Re-export commonly used functions
+export {
+  detectCamoufoxPath,
+  ensureCamoufox,
+  launchBrowser,
+  stopBrowser,
+  getBrowserStatus,
+  isBrowserRunning,
+  getPlaywrightBrowser,
+  getCurrentPage,
+  getActiveBrowser,
+} from './browser.mjs';
+
+export {
+  navigateTo,
+  goBack,
+  takeScreenshot,
+  scrollPage,
+  clickElement,
+  typeText,
+  pressKey,
+  highlightElement,
+  clearHighlights,
+  setViewport,
+  getPageInfo,
+  getDOMSnapshot,
+  queryElements,
+  evaluateJS,
+  createNewPage,
+  listPages,
+  switchPage,
+  closePage,
+  mouseMove,
+  mouseClick,
+  mouseWheel,
+} from './actions.mjs';
+
+export {
+  waitFor,
+  retry,
+  withTimeout,
+  ensureUrlScheme,
+  looksLikeUrlToken,
+  getPositionals,
+} from './utils.mjs';

package/src/core/utils.mjs

@@ -0,0 +1,87 @@
+/**
+ * Core utilities
+ */
+
+/**
+ * Wait helper
+ */
+export function waitFor(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+/**
+ * Retry with backoff
+ */
+export async function retry(fn, options = {}) {
+  const maxAttempts = options.maxAttempts || 3;
+  const delay = options.delay || 1000;
+  const backoff = options.backoff || 2;
+
+  let lastError;
+  for (let attempt = 1; attempt <= maxAttempts; attempt++) {
+    try {
+      return await fn();
+    } catch (err) {
+      lastError = err;
+      if (attempt < maxAttempts) {
+        await waitFor(delay * Math.pow(backoff, attempt - 1));
+      }
+    }
+  }
+
+  throw lastError;
+}
+
+/**
+ * Timeout wrapper
+ */
+export async function withTimeout(promise, ms, message = 'Timeout') {
+  const timeout = new Promise((_, reject) => {
+    setTimeout(() => reject(new Error(message)), ms);
+  });
+  return Promise.race([promise, timeout]);
+}
+
+/**
+ * Format URL (ensure scheme)
+ */
+export function ensureUrlScheme(url) {
+  if (!url) return url;
+  if (url.startsWith('http://') || url.startsWith('https://')) return url;
+  if (url.startsWith('localhost') || url.match(/^\\d+\\.\\d+/)) {
+    return `http://${url}`;
+  }
+  return `https://${url}`;
+}
+
+/**
+ * Looks like URL token
+ */
+export function looksLikeUrlToken(token) {
+  if (!token || typeof token !== 'string') return false;
+  if (token.startsWith('http://') || token.startsWith('https://')) return true;
+  if (token.includes('.') && !token.includes(' ')) return true;
+  return false;
+}
+
+/**
+ * Get positional args (exclude flags)
+ */
+export function getPositionals(args, excludeFlags = []) {
+  const result = [];
+  for (let i = 0; i < args.length; i++) {
+    const arg = args[i];
+    if (arg.startsWith('--')) {
+      if (!excludeFlags.includes(arg)) {
+        i++; // skip value
+      }
+      continue;
+    }
+    if (excludeFlags.includes(arg)) {
+      i++; // skip value
+      continue;
+    }
+    result.push(arg);
+  }
+  return result;
+}

package/src/events/daemon-entry.mjs

@@ -0,0 +1,33 @@
+import { createProgressWsServer } from './ws-server.mjs';
+
+function readFlagValue(args, names) {
+  for (let i = 0; i < args.length; i += 1) {
+    if (!names.includes(args[i])) continue;
+    const value = args[i + 1];
+    if (!value || String(value).startsWith('-')) return null;
+    return value;
+  }
+  return null;
+}
+
+async function main() {
+  const args = process.argv.slice(2);
+  const host = readFlagValue(args, ['--host']) || process.env.CAMO_PROGRESS_WS_HOST || '127.0.0.1';
+  const port = Math.max(1, Number(readFlagValue(args, ['--port']) || process.env.CAMO_PROGRESS_WS_PORT || 7788) || 7788);
+  const server = createProgressWsServer({ host, port });
+  await server.start();
+
+  const stop = async () => {
+    await server.stop();
+    process.exit(0);
+  };
+
+  process.on('SIGINT', stop);
+  process.on('SIGTERM', stop);
+  await new Promise(() => {});
+}
+
+main().catch(() => {
+  process.exit(1);
+});
+

package/src/events/daemon.mjs

@@ -0,0 +1,80 @@
+import path from 'node:path';
+import { spawn } from 'node:child_process';
+import { fileURLToPath } from 'node:url';
+
+const DEFAULT_HOST = process.env.CAMO_PROGRESS_WS_HOST || '127.0.0.1';
+const DEFAULT_PORT = Math.max(1, Number(process.env.CAMO_PROGRESS_WS_PORT || 7788) || 7788);
+const DEFAULT_HEALTH_TIMEOUT_MS = 800;
+const DEFAULT_START_TIMEOUT_MS = 4000;
+const HEALTH_POLL_INTERVAL_MS = 140;
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+export function resolveProgressWsConfig(options = {}) {
+  const host = String(options.host || DEFAULT_HOST).trim() || DEFAULT_HOST;
+  const port = Math.max(1, Number(options.port || DEFAULT_PORT) || DEFAULT_PORT);
+  return { host, port };
+}
+
+export function buildProgressHealthUrl(options = {}) {
+  const { host, port } = resolveProgressWsConfig(options);
+  return `http://${host}:${port}/health`;
+}
+
+export async function checkProgressEventDaemon(options = {}) {
+  const timeoutMs = Math.max(150, Number(options.timeoutMs || DEFAULT_HEALTH_TIMEOUT_MS) || DEFAULT_HEALTH_TIMEOUT_MS);
+  const healthUrl = buildProgressHealthUrl(options);
+  try {
+    const response = await fetch(healthUrl, { signal: AbortSignal.timeout(timeoutMs) });
+    if (!response.ok) return false;
+    const body = await response.json().catch(() => null);
+    return Boolean(body?.ok);
+  } catch {
+    return false;
+  }
+}
+
+function getDaemonEntryPath() {
+  const dir = path.dirname(fileURLToPath(import.meta.url));
+  return path.join(dir, 'daemon-entry.mjs');
+}
+
+function spawnProgressDaemon({ host, port }) {
+  const entry = getDaemonEntryPath();
+  const child = spawn(
+    process.execPath,
+    [entry, '--host', host, '--port', String(port)],
+    {
+      detached: true,
+      stdio: 'ignore',
+      env: {
+        ...process.env,
+        CAMO_PROGRESS_DAEMON: '1',
+      },
+    },
+  );
+  child.unref();
+}
+
+export async function ensureProgressEventDaemon(options = {}) {
+  const { host, port } = resolveProgressWsConfig(options);
+  const startTimeoutMs = Math.max(400, Number(options.startTimeoutMs || DEFAULT_START_TIMEOUT_MS) || DEFAULT_START_TIMEOUT_MS);
+  if (await checkProgressEventDaemon({ host, port })) {
+    return { ok: true, started: false, host, port };
+  }
+
+  spawnProgressDaemon({ host, port });
+
+  const deadline = Date.now() + startTimeoutMs;
+  while (Date.now() < deadline) {
+    if (await checkProgressEventDaemon({ host, port })) {
+      return { ok: true, started: true, host, port };
+    }
+    await sleep(HEALTH_POLL_INTERVAL_MS);
+  }
+
+  return { ok: false, started: true, host, port, error: 'progress_daemon_start_timeout' };
+}
+

package/src/events/progress-log.mjs

@@ -0,0 +1,109 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import { CONFIG_DIR, ensureDir } from '../utils/config.mjs';
+
+const DEFAULT_EVENTS_DIR = path.join(CONFIG_DIR, 'run', 'events');
+const DEFAULT_EVENTS_FILE = path.join(DEFAULT_EVENTS_DIR, 'progress-events.jsonl');
+const MAX_REPLAY_BYTES = Math.max(64 * 1024, Number(process.env.CAMO_PROGRESS_REPLAY_MAX_BYTES) || (2 * 1024 * 1024));
+
+let localSeq = 0;
+
+function resolveEventsFile() {
+  const raw = String(process.env.CAMO_PROGRESS_EVENTS_FILE || DEFAULT_EVENTS_FILE).trim();
+  return raw || DEFAULT_EVENTS_FILE;
+}
+
+function nextSeq() {
+  localSeq = (localSeq + 1) % 1_000_000_000;
+  return `${Date.now()}-${process.pid}-${localSeq}`;
+}
+
+function normalizePayload(payload) {
+  if (payload === undefined) return null;
+  if (payload === null) return null;
+  if (typeof payload === 'object') return payload;
+  return { value: payload };
+}
+
+export function getProgressEventsFile() {
+  return resolveEventsFile();
+}
+
+export function ensureProgressEventStore() {
+  const eventFile = resolveEventsFile();
+  ensureDir(path.dirname(eventFile));
+  if (!fs.existsSync(eventFile)) {
+    fs.writeFileSync(eventFile, '', 'utf8');
+  }
+  return eventFile;
+}
+
+export function buildProgressEvent({
+  ts = null,
+  seq = null,
+  source = 'camo',
+  mode = 'normal',
+  profileId = null,
+  runId = null,
+  event = 'unknown',
+  payload = null,
+} = {}) {
+  return {
+    ts: ts || new Date().toISOString(),
+    seq: seq || nextSeq(),
+    source: String(source || 'camo'),
+    mode: String(mode || 'normal'),
+    profileId: profileId ? String(profileId) : null,
+    runId: runId ? String(runId) : null,
+    event: String(event || 'unknown'),
+    payload: normalizePayload(payload),
+  };
+}
+
+export function appendProgressEvent(input = {}) {
+  const eventFile = ensureProgressEventStore();
+  const event = buildProgressEvent(input);
+  fs.appendFileSync(eventFile, `${JSON.stringify(event)}\n`, 'utf8');
+  return event;
+}
+
+export function safeAppendProgressEvent(input = {}) {
+  try {
+    return appendProgressEvent(input);
+  } catch {
+    return null;
+  }
+}
+
+export function readRecentProgressEvents(limit = 100) {
+  const eventFile = ensureProgressEventStore();
+  const maxItems = Math.max(0, Number(limit) || 0);
+  if (maxItems === 0) return [];
+  const stat = fs.statSync(eventFile);
+  if (stat.size <= 0) return [];
+
+  const start = Math.max(0, stat.size - MAX_REPLAY_BYTES);
+  const fd = fs.openSync(eventFile, 'r');
+  try {
+    const length = stat.size - start;
+    const buffer = Buffer.alloc(length);
+    fs.readSync(fd, buffer, 0, length, start);
+    const raw = buffer.toString('utf8');
+    return raw
+      .split('\n')
+      .map((line) => line.trim())
+      .filter(Boolean)
+      .slice(-maxItems)
+      .map((line) => {
+        try {
+          return JSON.parse(line);
+        } catch {
+          return null;
+        }
+      })
+      .filter(Boolean);
+  } finally {
+    fs.closeSync(fd);
+  }
+}
+