@web-auto/camo 0.1.2

package/src/lifecycle/cleanup.mjs

@@ -0,0 +1,83 @@
+#!/usr/bin/env node
+/**
+ * Browser session cleanup and resource reclamation
+ */
+import { BROWSER_SERVICE_URL } from '../utils/config.mjs';
+
+export async function cleanupSession(profileId) {
+  try {
+    const r = await fetch(`${BROWSER_SERVICE_URL}/command`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'stop', args: { profileId } }),
+      signal: AbortSignal.timeout(5000),
+    });
+    
+    if (!r.ok) {
+      const body = await r.json().catch(() => ({}));
+      throw new Error(body?.error || `HTTP ${r.status}`);
+    }
+    
+    return await r.json();
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+export async function forceCleanupSession(profileId) {
+  try {
+    const r = await fetch(`${BROWSER_SERVICE_URL}/command`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'stop', args: { profileId, force: true } }),
+      signal: AbortSignal.timeout(10000),
+    });
+    
+    return await r.json();
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+export async function shutdownBrowserService() {
+  try {
+    const r = await fetch(`${BROWSER_SERVICE_URL}/command`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'service:shutdown', args: {} }),
+      signal: AbortSignal.timeout(10000),
+    });
+    
+    return await r.json();
+  } catch (err) {
+    return { ok: false, error: err.message };
+  }
+}
+
+export async function getActiveSessions() {
+  try {
+    const r = await fetch(`${BROWSER_SERVICE_URL}/command`, {
+      method: 'POST',
+      headers: { 'Content-Type': 'application/json' },
+      body: JSON.stringify({ action: 'getStatus', args: {} }),
+      signal: AbortSignal.timeout(3000),
+    });
+    
+    const body = await r.json();
+    return body?.sessions || [];
+  } catch (err) {
+    return [];
+  }
+}
+
+export async function cleanupAllSessions() {
+  const sessions = await getActiveSessions();
+  const results = [];
+  
+  for (const session of sessions) {
+    const result = await cleanupSession(session.profileId);
+    results.push({ profileId: session.profileId, ...result });
+  }
+  
+  return results;
+}

package/src/lifecycle/lock.mjs

@@ -0,0 +1,122 @@
+#!/usr/bin/env node
+/**
+ * Lock manager for browser session lifecycle
+ * Prevents multiple instances from conflicting
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const LOCK_DIR = path.join(os.homedir(), '.webauto', 'locks');
+
+function ensureLockDir() {
+  if (!fs.existsSync(LOCK_DIR)) {
+    fs.mkdirSync(LOCK_DIR, { recursive: true });
+  }
+}
+
+export function getLockFile(profileId) {
+  return path.join(LOCK_DIR, `${profileId}.lock`);
+}
+
+export function getLockInfo(profileId) {
+  const lockFile = getLockFile(profileId);
+  if (!fs.existsSync(lockFile)) return null;
+  
+  try {
+    const content = fs.readFileSync(lockFile, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+export function acquireLock(profileId, sessionInfo = {}) {
+  ensureLockDir();
+  const lockFile = getLockFile(profileId);
+  
+  const lockData = {
+    profileId,
+    pid: process.pid,
+    startTime: Date.now(),
+    ...sessionInfo,
+  };
+  
+  fs.writeFileSync(lockFile, JSON.stringify(lockData, null, 2));
+  return lockData;
+}
+
+export function releaseLock(profileId) {
+  const lockFile = getLockFile(profileId);
+  if (fs.existsSync(lockFile)) {
+    fs.unlinkSync(lockFile);
+    return true;
+  }
+  return false;
+}
+
+export function isLocked(profileId) {
+  const lockFile = getLockFile(profileId);
+  return fs.existsSync(lockFile);
+}
+
+export function cleanupStaleLocks() {
+  ensureLockDir();
+  const files = fs.readdirSync(LOCK_DIR);
+  const now = Date.now();
+  const staleThreshold = 24 * 60 * 60 * 1000; // 24 hours
+  
+  let cleaned = 0;
+  for (const file of files) {
+    if (!file.endsWith('.lock')) continue;
+    
+    const lockFile = path.join(LOCK_DIR, file);
+    try {
+      const stats = fs.statSync(lockFile);
+      const age = now - stats.mtimeMs;
+      
+      if (age > staleThreshold) {
+        fs.unlinkSync(lockFile);
+        cleaned++;
+        continue;
+      }
+      
+      const content = fs.readFileSync(lockFile, 'utf-8');
+      const lockData = JSON.parse(content);
+      
+      // Check if process is still alive
+      if (lockData.pid) {
+        try {
+          process.kill(lockData.pid, 0); // Signal 0 checks existence
+        } catch {
+          // Process not running, lock is stale
+          fs.unlinkSync(lockFile);
+          cleaned++;
+        }
+      }
+    } catch (err) {
+      // Corrupted lock file, remove it
+      try {
+        fs.unlinkSync(lockFile);
+        cleaned++;
+      } catch {}
+    }
+  }
+  
+  return cleaned;
+}
+
+export function listActiveLocks() {
+  ensureLockDir();
+  const files = fs.readdirSync(LOCK_DIR);
+  const locks = [];
+  
+  for (const file of files) {
+    if (!file.endsWith('.lock')) continue;
+    const profileId = file.replace('.lock', '');
+    const info = getLockInfo(profileId);
+    if (info) locks.push({ profileId, ...info });
+  }
+  
+  return locks;
+}

package/src/lifecycle/session-registry.mjs

@@ -0,0 +1,163 @@
+#!/usr/bin/env node
+/**
+ * Session registry - persistent session state management
+ * Stores session metadata locally for recovery/reconnection
+ */
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+const SESSION_DIR = path.join(os.homedir(), '.webauto', 'sessions');
+
+function ensureSessionDir() {
+  if (!fs.existsSync(SESSION_DIR)) {
+    fs.mkdirSync(SESSION_DIR, { recursive: true });
+  }
+}
+
+export function getSessionFile(profileId) {
+  return path.join(SESSION_DIR, `${profileId}.json`);
+}
+
+export function registerSession(profileId, sessionInfo = {}) {
+  ensureSessionDir();
+  const sessionFile = getSessionFile(profileId);
+  
+  const sessionData = {
+    profileId,
+    pid: process.pid,
+    startTime: Date.now(),
+    lastSeen: Date.now(),
+    status: 'active',
+    ...sessionInfo,
+  };
+  
+  fs.writeFileSync(sessionFile, JSON.stringify(sessionData, null, 2));
+  return sessionData;
+}
+
+export function updateSession(profileId, updates = {}) {
+  const sessionFile = getSessionFile(profileId);
+  if (!fs.existsSync(sessionFile)) {
+    return registerSession(profileId, updates);
+  }
+  
+  try {
+    const existing = JSON.parse(fs.readFileSync(sessionFile, 'utf-8'));
+    const updated = {
+      ...existing,
+      ...updates,
+      lastSeen: Date.now(),
+      profileId,
+    };
+    fs.writeFileSync(sessionFile, JSON.stringify(updated, null, 2));
+    return updated;
+  } catch {
+    return registerSession(profileId, updates);
+  }
+}
+
+export function getSessionInfo(profileId) {
+  const sessionFile = getSessionFile(profileId);
+  if (!fs.existsSync(sessionFile)) return null;
+  
+  try {
+    const content = fs.readFileSync(sessionFile, 'utf-8');
+    return JSON.parse(content);
+  } catch {
+    return null;
+  }
+}
+
+export function unregisterSession(profileId) {
+  const sessionFile = getSessionFile(profileId);
+  if (fs.existsSync(sessionFile)) {
+    fs.unlinkSync(sessionFile);
+    return true;
+  }
+  return false;
+}
+
+export function listRegisteredSessions() {
+  ensureSessionDir();
+  const files = fs.readdirSync(SESSION_DIR);
+  const sessions = [];
+  
+  for (const file of files) {
+    if (!file.endsWith('.json')) continue;
+    const profileId = file.replace('.json', '');
+    const info = getSessionInfo(profileId);
+    if (info) sessions.push(info);
+  }
+  
+  return sessions;
+}
+
+export function markSessionReconnecting(profileId) {
+  return updateSession(profileId, { status: 'reconnecting', reconnectAttempt: Date.now() });
+}
+
+export function markSessionActive(profileId, updates = {}) {
+  return updateSession(profileId, { status: 'active', ...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));
+  }
+  return unregisterSession(profileId);
+}
+
+export function cleanupStaleSessions(maxAgeMs = 7 * 24 * 60 * 60 * 1000) {
+  ensureSessionDir();
+  const files = fs.readdirSync(SESSION_DIR);
+  const now = Date.now();
+  let cleaned = 0;
+  
+  for (const file of files) {
+    if (!file.endsWith('.json')) continue;
+    
+    const sessionFile = path.join(SESSION_DIR, file);
+    try {
+      const content = fs.readFileSync(sessionFile, 'utf-8');
+      const session = JSON.parse(content);
+      
+      // Clean if session is too old or marked as closed
+      if (session.status === 'closed' || (session.lastSeen && (now - session.lastSeen) > maxAgeMs)) {
+        fs.unlinkSync(sessionFile);
+        cleaned++;
+      }
+    } catch {
+      // Remove corrupted session files
+      try {
+        fs.unlinkSync(sessionFile);
+        cleaned++;
+      } catch {}
+    }
+  }
+  
+  return cleaned;
+}
+
+export async function recoverSession(profileId, checkHealthFn) {
+  const info = getSessionInfo(profileId);
+  if (!info) return null;
+  
+  // Check if browser service is still running
+  const isHealthy = await checkHealthFn();
+  
+  if (!isHealthy) {
+    // Service is down, mark as needing recovery
+    markSessionReconnecting(profileId);
+    return { status: 'needs_recovery', info };
+  }
+  
+  // Service is up, check if session is still active
+  markSessionActive(profileId, { recoveredAt: Date.now() });
+  return { status: 'recovered', info };
+}

package/src/utils/args.mjs

@@ -0,0 +1,25 @@
+export function resolveProfileId(args, argIndex, getDefaultProfile) {
+  let profileId = args[argIndex];
+  if (!profileId) {
+    profileId = getDefaultProfile();
+  }
+  return profileId;
+}
+
+export function ensureUrlScheme(rawUrl) {
+  if (typeof rawUrl !== 'string') return rawUrl;
+  const trimmed = rawUrl.trim();
+  if (!trimmed) return trimmed;
+  if (/^[a-zA-Z][a-zA-Z0-9+.-]*:\/\//.test(trimmed)) return trimmed;
+  return `https://${trimmed}`;
+}
+
+export function looksLikeUrlToken(token) {
+  if (!token || typeof token !== 'string') return false;
+  if (token.includes('://')) return true;
+  return /^[a-zA-Z0-9-]+(\.[a-zA-Z0-9-]+)+/.test(token);
+}
+
+export function getPositionals(args, startIndex = 1) {
+  return args.slice(startIndex).filter((a) => a && !a.startsWith('--'));
+}

package/src/utils/browser-service.mjs

@@ -0,0 +1,194 @@
+#!/usr/bin/env node
+import { execSync } from 'node:child_process';
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { BROWSER_SERVICE_URL, loadConfig, setRepoRoot } from './config.mjs';
+
+export async function callAPI(action, payload = {}) {
+  const r = await fetch(`${BROWSER_SERVICE_URL}/command`, {
+    method: 'POST',
+    headers: { 'Content-Type': 'application/json' },
+    body: JSON.stringify({ action, args: payload }),
+  });
+
+  let body;
+  try {
+    body = await r.json();
+  } catch {
+    const text = await r.text();
+    throw new Error(`HTTP ${r.status}: ${text}`);
+  }
+
+  if (!r.ok) throw new Error(body?.error || `HTTP ${r.status}`);
+  return body;
+}
+
+export async function getSessionByProfile(profileId) {
+  const status = await callAPI('getStatus', {});
+  return status?.sessions?.find((s) => s.profileId === profileId) || null;
+}
+
+export async function checkBrowserService() {
+  try {
+    const r = await fetch(`${BROWSER_SERVICE_URL}/health`, { signal: AbortSignal.timeout(2000) });
+    return r.ok;
+  } catch {
+    return false;
+  }
+}
+
+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'],
+    });
+    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;
+}
+
+export function ensureCamoufox() {
+  if (detectCamoufoxPath()) return;
+  console.log('Camoufox is not found. Installing...');
+  execSync('npx --yes --package=camoufox camoufox fetch', { stdio: 'inherit' });
+  if (!detectCamoufoxPath()) {
+    throw new Error('Camoufox install finished but executable was not detected');
+  }
+  console.log('Camoufox installed.');
+}
+
+const START_SCRIPT_REL = path.join('runtime', 'infra', 'utils', 'scripts', 'service', 'start-browser-service.mjs');
+
+function hasStartScript(root) {
+  if (!root) return false;
+  return fs.existsSync(path.join(root, START_SCRIPT_REL));
+}
+
+function walkUpForRepoRoot(startDir) {
+  if (!startDir) return null;
+  let cursor = path.resolve(startDir);
+  for (;;) {
+    if (hasStartScript(cursor)) return cursor;
+    const parent = path.dirname(cursor);
+    if (parent === cursor) return null;
+    cursor = parent;
+  }
+}
+
+function scanCommonRepoRoots() {
+  const home = os.homedir();
+  const roots = [
+    path.join(home, 'Documents', 'github'),
+    path.join(home, 'github'),
+  path.join(home, 'code'),
+    path.join(home, 'projects'),
+  path.join('/Volumes', 'extension', 'code'),
+  path.join('C:', 'code'),
+  path.join('D:', 'code'),
+  path.join('C:', 'projects'),
+  path.join('D:', 'projects'),
+  path.join('C:', 'Users', os.userInfo().username, 'code'),
+  path.join('C:', 'Users', os.userInfo().username, 'projects'),
+    path.join('C:', 'Users', os.userInfo().username, 'Documents', 'github'),
+  ].filter(Boolean);
+
+  for (const root of roots) {
+    if (!fs.existsSync(root)) continue;
+    try {
+      const entries = fs.readdirSync(root, { withFileTypes: true });
+      for (const entry of entries) {
+        if (!entry.isDirectory()) continue;
+        if (!entry.name.toLowerCase().includes('webauto')) continue;
+        const candidate = path.join(root, entry.name);
+        if (hasStartScript(candidate)) return candidate;
+      }
+    } catch {
+      // ignore scanning errors and continue
+    }
+  }
+
+  return null;
+}
+
+export function findRepoRootCandidate() {
+  const cfg = loadConfig();
+  const candidates = [
+    process.env.WEBAUTO_REPO_ROOT,
+    cfg.repoRoot,
+    process.cwd(),
+    path.join('/Volumes', 'extension', 'code', 'webauto'),
+    path.join('/Volumes', 'extension', 'code', 'WebAuto'),
+    path.join(os.homedir(), 'Documents', 'github', 'webauto'),
+    path.join(os.homedir(), 'Documents', 'github', 'WebAuto'),
+    path.join(os.homedir(), 'github', 'webauto'),
+    path.join(os.homedir(), 'github', 'WebAuto'),
+    path.join('C:', 'code', 'webauto'),
+    path.join('C:', 'code', 'WebAuto'),
+    path.join('C:', 'Users', os.userInfo().username, 'code', 'webauto'),
+    path.join('C:', 'Users', os.userInfo().username, 'code', 'WebAuto'),
+  ].filter(Boolean);
+
+  for (const root of candidates) {
+    if (hasStartScript(root)) {
+      if (cfg.repoRoot !== root) {
+        setRepoRoot(root);
+      }
+      return root;
+    }
+  }
+
+  for (const startDir of [process.cwd()]) {
+    const found = walkUpForRepoRoot(startDir);
+    if (found) {
+      if (cfg.repoRoot !== found) {
+        setRepoRoot(found);
+      }
+      return found;
+    }
+  }
+
+  const scanned = scanCommonRepoRoots();
+  if (scanned) {
+    if (cfg.repoRoot !== scanned) {
+      setRepoRoot(scanned);
+    }
+    return scanned;
+  }
+
+  return null;
+}
+
+export async function ensureBrowserService() {
+  if (await checkBrowserService()) return;
+
+  const repoRoot = findRepoRootCandidate();
+  if (!repoRoot) {
+    throw new Error(
+      `Cannot locate browser-service start script (${START_SCRIPT_REL}). ` +
+      'Run from webauto repo once or set WEBAUTO_REPO_ROOT=/path/to/webauto.',
+    );
+  }
+
+  const scriptPath = path.join(repoRoot, START_SCRIPT_REL);
+  console.log('Starting browser-service daemon...');
+  execSync(`node "${scriptPath}"`, { stdio: 'inherit', cwd: repoRoot });
+
+  for (let i = 0; i < 20; i += 1) {
+    await new Promise((r) => setTimeout(r, 400));
+    if (await checkBrowserService()) {
+      console.log('Browser-service is ready.');
+      return;
+    }
+  }
+
+  throw new Error('Browser-service failed to become healthy within timeout');
+}

package/src/utils/config.mjs

@@ -0,0 +1,90 @@
+#!/usr/bin/env node
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+
+export const CONFIG_DIR = path.join(os.homedir(), '.webauto');
+export const PROFILES_DIR = path.join(CONFIG_DIR, 'profiles');
+export const CONFIG_FILE = path.join(CONFIG_DIR, 'camo-cli.json');
+export const BROWSER_SERVICE_URL = process.env.WEBAUTO_BROWSER_URL || 'http://127.0.0.1:7704';
+
+export function ensureDir(p) {
+  if (!fs.existsSync(p)) fs.mkdirSync(p, { recursive: true });
+}
+
+export function readJson(p) {
+  try {
+    if (!fs.existsSync(p)) return null;
+    return JSON.parse(fs.readFileSync(p, 'utf8'));
+  } catch {
+    return null;
+  }
+}
+
+export function writeJson(p, data) {
+  ensureDir(path.dirname(p));
+  fs.writeFileSync(p, JSON.stringify(data, null, 2));
+}
+
+export function loadConfig() {
+  const raw = readJson(CONFIG_FILE) || {};
+  return {
+    defaultProfile: typeof raw.defaultProfile === 'string' ? raw.defaultProfile : null,
+    repoRoot: typeof raw.repoRoot === 'string' ? raw.repoRoot : null,
+  };
+}
+
+export function saveConfig(config) {
+  writeJson(CONFIG_FILE, config);
+}
+
+export function listProfiles() {
+  if (!fs.existsSync(PROFILES_DIR)) return [];
+  return fs.readdirSync(PROFILES_DIR, { withFileTypes: true })
+    .filter((d) => d.isDirectory())
+    .map((d) => d.name)
+    .filter((name) => !name.includes(':') && !name.includes('/') && !name.startsWith('.'))
+    .sort();
+}
+
+export function isValidProfileId(profileId) {
+  return typeof profileId === 'string' && /^[a-zA-Z0-9._-]+$/.test(profileId);
+}
+
+export function createProfile(profileId) {
+  if (!isValidProfileId(profileId)) {
+    throw new Error('Invalid profileId. Use only letters, numbers, dot, underscore, dash.');
+  }
+  const profileDir = path.join(PROFILES_DIR, profileId);
+  if (fs.existsSync(profileDir)) throw new Error(`Profile already exists: ${profileId}`);
+  ensureDir(profileDir);
+}
+
+export function deleteProfile(profileId) {
+  const profileDir = path.join(PROFILES_DIR, profileId);
+  if (!fs.existsSync(profileDir)) throw new Error(`Profile not found: ${profileId}`);
+  fs.rmSync(profileDir, { recursive: true, force: true });
+}
+
+export function setDefaultProfile(profileId) {
+  const cfg = loadConfig();
+  cfg.defaultProfile = profileId;
+  saveConfig(cfg);
+}
+
+export function setRepoRoot(repoRoot) {
+  const cfg = loadConfig();
+  cfg.repoRoot = repoRoot;
+  saveConfig(cfg);
+}
+
+export function getDefaultProfile() {
+  return loadConfig().defaultProfile;
+}
+
+const START_SCRIPT_REL = path.join('runtime', 'infra', 'utils', 'scripts', 'service', 'start-browser-service.mjs');
+
+export function hasStartScript(root) {
+  if (!root) return false;
+  return fs.existsSync(path.join(root, START_SCRIPT_REL));
+}