@web-auto/camo 0.1.2

package/src/commands/cookies.mjs

@@ -0,0 +1,69 @@
+import { getDefaultProfile } from '../utils/config.mjs';
+import { callAPI, ensureBrowserService } from '../utils/browser-service.mjs';
+import { getPositionals } from '../utils/args.mjs';
+
+export async function handleCookiesCommand(args) {
+  await ensureBrowserService();
+
+  const sub = args[1];
+  const profileId = getPositionals(args, 2)[0] || getDefaultProfile();
+  if (!profileId) throw new Error('No profile specified and no default profile set');
+
+  switch (sub) {
+    case 'get':
+      await handleGetCookies(profileId);
+      break;
+    case 'save':
+      await handleSaveCookies(profileId, args);
+      break;
+    case 'load':
+      await handleLoadCookies(profileId, args);
+      break;
+    case 'auto':
+      await handleAutoCookies(profileId, args);
+      break;
+    default:
+      throw new Error('Usage: camo cookies <get|save|load|auto> [profileId] [--path <path>] [--interval <ms>]');
+  }
+}
+
+async function handleGetCookies(profileId) {
+  const result = await callAPI('getCookies', { profileId });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function handleSaveCookies(profileId, args) {
+  const pathIdx = args.indexOf('--path');
+  if (pathIdx === -1) throw new Error('--path <file> is required for save');
+  const cookiePath = args[pathIdx + 1];
+  const result = await callAPI('saveCookies', { profileId, path: cookiePath });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function handleLoadCookies(profileId, args) {
+  const pathIdx = args.indexOf('--path');
+  if (pathIdx === -1) throw new Error('--path <file> is required for load');
+  const cookiePath = args[pathIdx + 1];
+  const result = await callAPI('loadCookies', { profileId, path: cookiePath });
+  console.log(JSON.stringify(result, null, 2));
+}
+
+async function handleAutoCookies(profileId, args) {
+  const action = args[2];
+  if (!action) throw new Error('Usage: camo cookies auto <start|stop|status> [profileId] [--interval <ms>]');
+
+  if (action === 'start') {
+    const intervalIdx = args.indexOf('--interval');
+    const intervalMs = intervalIdx >= 0 ? parseInt(args[intervalIdx + 1]) : 2500;
+    const result = await callAPI('autoCookies:start', { profileId, intervalMs });
+    console.log(JSON.stringify(result, null, 2));
+  } else if (action === 'stop') {
+    const result = await callAPI('autoCookies:stop', { profileId });
+    console.log(JSON.stringify(result, null, 2));
+  } else if (action === 'status') {
+    const result = await callAPI('autoCookies:status', { profileId });
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    throw new Error('auto subcommand must be start, stop, or status');
+  }
+}

package/src/commands/create.mjs

@@ -0,0 +1,98 @@
+import fs from 'node:fs';
+import path from 'node:path';
+import os from 'node:os';
+import { CONFIG_DIR, PROFILES_DIR, ensureDir, createProfile, listProfiles } from '../utils/config.mjs';
+import { generateFingerprint, listAvailableRegions, listAvailableOS, GEOIP_REGIONS, OS_OPTIONS } from '../utils/fingerprint.mjs';
+
+const FINGERPRINTS_DIR = path.join(CONFIG_DIR, 'fingerprints');
+
+export async function handleCreateCommand(args) {
+  const what = args[1];
+  
+  if (what === 'fingerprint') {
+    await handleCreateFingerprint(args);
+    return;
+  }
+  
+  if (what === 'profile') {
+    const profileId = args[2];
+    if (!profileId) throw new Error('Usage: camo create profile <profileId>');
+    createProfile(profileId);
+    console.log(`Created profile: ${profileId}`);
+    return;
+  }
+  
+  throw new Error('Usage: camo create <profile|fingerprint> [options]');
+}
+
+async function handleCreateFingerprint(args) {
+  // Parse options
+  const osIdx = args.indexOf('--os');
+  const regionIdx = args.indexOf('--region');
+  const outputIdx = args.indexOf('--output');
+  const nameIdx = args.indexOf('--name');
+  
+  const osKey = osIdx >= 0 ? args[osIdx + 1] : 'mac';
+  const regionKey = regionIdx >= 0 ? args[regionIdx + 1] : 'us';
+  const output = outputIdx >= 0 ? args[outputIdx + 1] : null;
+  const name = nameIdx >= 0 ? args[nameIdx + 1] : null;
+  
+  // Validate options
+  if (!OS_OPTIONS[osKey]) {
+    console.error(`Invalid OS: ${osKey}`);
+    console.error('Available:', Object.keys(OS_OPTIONS).join(', '));
+    process.exit(1);
+  }
+  
+  if (!GEOIP_REGIONS[regionKey]) {
+    console.error(`Invalid region: ${regionKey}`);
+    console.error('Available:', Object.keys(GEOIP_REGIONS).join(', '));
+    process.exit(1);
+  }
+  
+  // Generate fingerprint
+  const fingerprint = generateFingerprint({ os: osKey, region: regionKey });
+  
+  // Add metadata
+  fingerprint.name = name || `fingerprint-${osKey}-${regionKey}-${Date.now()}`;
+  fingerprint.createdAt = new Date().toISOString();
+  fingerprint.id = `fp_${Buffer.from(fingerprint.name).toString('base64').slice(0, 12)}`;
+  
+  // Save or output
+  if (output) {
+    fs.writeFileSync(output, JSON.stringify(fingerprint, null, 2));
+    console.log(`Fingerprint saved to: ${output}`);
+  } else {
+    // Save to fingerprints directory
+    ensureDir(FINGERPRINTS_DIR);
+    const fpPath = path.join(FINGERPRINTS_DIR, `${fingerprint.id}.json`);
+    fs.writeFileSync(fpPath, JSON.stringify(fingerprint, null, 2));
+    console.log(JSON.stringify({
+      ok: true,
+      fingerprint,
+      path: fpPath,
+    }, null, 2));
+  }
+}
+
+export function listFingerprints() {
+  if (!fs.existsSync(FINGERPRINTS_DIR)) return [];
+  return fs.readdirSync(FINGERPRINTS_DIR, { withFileTypes: true })
+    .filter((f) => f.isFile() && f.name.endsWith('.json'))
+    .map((f) => {
+      try {
+        const content = fs.readFileSync(path.join(FINGERPRINTS_DIR, f.name), 'utf8');
+        const fp = JSON.parse(content);
+        return { id: fp.id, name: fp.name, os: fp.os, country: fp.country };
+      } catch {
+        return null;
+      }
+    })
+    .filter(Boolean);
+}
+
+export function getFingerprint(id) {
+  const fpPath = path.join(FINGERPRINTS_DIR, `${id}.json`);
+  if (!fs.existsSync(fpPath)) return null;
+  return JSON.parse(fs.readFileSync(fpPath, 'utf8'));
+}

package/src/commands/init.mjs

@@ -0,0 +1,68 @@
+import { ensureCamoufox } from '../utils/browser-service.mjs';
+import { listProfiles, getDefaultProfile } from '../utils/config.mjs';
+import { downloadGeoIP, hasGeoIP, listAvailableRegions, listAvailableOS } from '../utils/fingerprint.mjs';
+
+export async function handleInitCommand(args) {
+  const subCmd = args[1];
+  
+  if (subCmd === 'geoip') {
+    await handleInitGeoIP();
+    return;
+  }
+  
+  if (subCmd === 'list') {
+    handleInitList();
+    return;
+  }
+  
+  // Default init: ensure camoufox + browser-service
+  ensureCamoufox();
+  const { ensureBrowserService } = await import('../utils/browser-service.mjs');
+  await ensureBrowserService();
+  
+  const profiles = listProfiles();
+  const defaultProfile = getDefaultProfile();
+  const geoipReady = hasGeoIP();
+  
+  console.log(JSON.stringify({
+    ok: true,
+    profiles,
+    defaultProfile,
+    count: profiles.length,
+    geoip: geoipReady,
+    camoufox: true,
+    browserService: true,
+  }, null, 2));
+}
+
+async function handleInitGeoIP() {
+  try {
+    const path = await downloadGeoIP(console.log);
+    console.log(JSON.stringify({
+      ok: true,
+      path,
+      message: 'GeoIP database ready',
+    }, null, 2));
+  } catch (err) {
+    console.error(`Error: ${err.message}`);
+    process.exit(1);
+  }
+}
+
+function handleInitList() {
+  console.log('\n=== Available OS Options ===');
+  const osList = listAvailableOS();
+  osList.forEach(item => {
+    console.log(`  ${item.key.padEnd(12)} - ${item.os} ${item.osVersion} (${item.platform})`);
+  });
+  
+  console.log('\n=== Available Regions ===');
+  const regions = listAvailableRegions();
+  regions.forEach(item => {
+    console.log(`  ${item.key.padEnd(12)} - ${item.country}, ${item.city} (${item.timezone})`);
+  });
+  
+  console.log('\nUsage:');
+  console.log('  camo create fingerprint --os mac --region us');
+  console.log('  camo create fingerprint --os windows --region uk');
+}

package/src/commands/lifecycle.mjs

@@ -0,0 +1,256 @@
+#!/usr/bin/env node
+/**
+ * Lifecycle commands: cleanup, force-stop, lock management, session recovery
+ */
+import { getDefaultProfile } from '../utils/config.mjs';
+import { callAPI, ensureBrowserService, checkBrowserService } from '../utils/browser-service.mjs';
+import { resolveProfileId } from '../utils/args.mjs';
+import { acquireLock, getLockInfo, releaseLock, isLocked, cleanupStaleLocks, listActiveLocks } from '../lifecycle/lock.mjs';
+import { 
+  getSessionInfo, unregisterSession, markSessionClosed, cleanupStaleSessions,
+  listRegisteredSessions, registerSession, updateSession
+} from '../lifecycle/session-registry.mjs';
+
+export async function handleCleanupCommand(args) {
+  const sub = args[1];
+  
+  if (sub === 'locks') {
+    const cleaned = cleanupStaleLocks();
+    console.log(JSON.stringify({ ok: true, cleanedStaleLocks: cleaned }, null, 2));
+    return;
+  }
+  
+  if (sub === 'sessions') {
+    const cleaned = cleanupStaleSessions();
+    console.log(JSON.stringify({ ok: true, cleanedStaleSessions: cleaned }, null, 2));
+    return;
+  }
+  
+  if (sub === 'all') {
+    const serviceUp = await checkBrowserService();
+    const results = [];
+    
+    if (serviceUp) {
+      try {
+        const status = await callAPI('getStatus', {});
+        const sessions = Array.isArray(status?.sessions) ? status.sessions : [];
+        
+        for (const session of sessions) {
+          try {
+            await callAPI('stop', { profileId: session.profileId });
+            releaseLock(session.profileId);
+            markSessionClosed(session.profileId);
+            results.push({ profileId: session.profileId, ok: true });
+          } catch (err) {
+            results.push({ profileId: session.profileId, ok: false, error: err.message });
+          }
+        }
+      } catch {}
+    }
+    
+    // Cleanup stale locks and sessions
+    const cleanedLocks = cleanupStaleLocks();
+    const cleanedSessions = cleanupStaleSessions();
+    
+    console.log(JSON.stringify({
+      ok: true,
+      sessions: results,
+      cleanedStaleLocks: cleanedLocks,
+      cleanedStaleSessions: cleanedSessions,
+    }, null, 2));
+    return;
+  }
+  
+  // Clean specific profile
+  const profileId = resolveProfileId(args, 1, getDefaultProfile);
+  if (!profileId) {
+    throw new Error('Usage: camo cleanup [profileId] | camo cleanup all | camo cleanup locks | camo cleanup sessions');
+  }
+  
+  const serviceUp = await checkBrowserService();
+  if (serviceUp) {
+    try {
+      await callAPI('stop', { profileId });
+    } catch {}
+  }
+  
+  releaseLock(profileId);
+  markSessionClosed(profileId);
+  console.log(JSON.stringify({ ok: true, profileId }, null, 2));
+}
+
+export async function handleForceStopCommand(args) {
+  await ensureBrowserService();
+  const profileId = resolveProfileId(args, 1, getDefaultProfile);
+  if (!profileId) throw new Error('Usage: camo force-stop [profileId]');
+  
+  try {
+    const result = await callAPI('stop', { profileId, force: true });
+    releaseLock(profileId);
+    markSessionClosed(profileId);
+    console.log(JSON.stringify({ ok: true, profileId, ...result }, null, 2));
+  } catch (err) {
+    // Even if stop fails, cleanup local state
+    releaseLock(profileId);
+    markSessionClosed(profileId);
+    console.log(JSON.stringify({ ok: true, profileId, warning: 'Session stopped locally but remote stop failed: ' + err.message }, null, 2));
+  }
+}
+
+export async function handleLockCommand(args) {
+  const sub = args[1];
+  
+  if (sub === 'list') {
+    const locks = listActiveLocks();
+    console.log(JSON.stringify({ ok: true, locks, count: locks.length }, null, 2));
+    return;
+  }
+  
+  if (sub === 'cleanup') {
+    const cleaned = cleanupStaleLocks();
+    console.log(JSON.stringify({ ok: true, cleanedStaleLocks: cleaned }, null, 2));
+    return;
+  }
+  
+  const profileId = resolveProfileId(args, 1, getDefaultProfile);
+  if (!profileId) {
+    throw new Error('Usage: camo lock list | camo lock cleanup | camo lock [profileId]');
+  }
+  
+  const info = getLockInfo(profileId);
+  if (!info) {
+    console.log(JSON.stringify({ ok: true, locked: false, profileId }, null, 2));
+    return;
+  }
+  
+  console.log(JSON.stringify({ ok: true, locked: true, ...info }, null, 2));
+}
+
+export async function handleUnlockCommand(args) {
+  const profileId = resolveProfileId(args, 1, getDefaultProfile);
+  if (!profileId) throw new Error('Usage: camo unlock [profileId]');
+  
+  const released = releaseLock(profileId);
+  console.log(JSON.stringify({ ok: released, profileId, released }, null, 2));
+}
+
+export async function handleSessionsCommand(args) {
+  const serviceUp = await checkBrowserService();
+  const registeredSessions = listRegisteredSessions();
+  
+  let liveSessions = [];
+  if (serviceUp) {
+    try {
+      const status = await callAPI('getStatus', {});
+      liveSessions = Array.isArray(status?.sessions) ? status.sessions : [];
+    } catch {}
+  }
+  
+  // Build a map of live sessions
+  const liveMap = new Map(liveSessions.map(s => [s.profileId, s]));
+  
+  // Merge live and registered sessions
+  const merged = [];
+  
+  // Add all live sessions
+  for (const live of liveSessions) {
+    const reg = getSessionInfo(live.profileId);
+    merged.push({
+      profileId: live.profileId,
+      sessionId: live.session_id || live.profileId,
+      url: live.current_url,
+      mode: live.mode,
+      live: true,
+      registered: !!reg,
+      registryStatus: reg?.status,
+      lastSeen: reg?.lastSeen,
+    });
+  }
+  
+  // Add registered sessions that are not live (orphaned)
+  for (const reg of registeredSessions) {
+    if (!liveMap.has(reg.profileId) && reg.status !== 'closed') {
+      merged.push({
+        ...reg,
+        live: false,
+        orphaned: true,
+        needsRecovery: reg.status === 'active',
+      });
+    }
+  }
+  
+  console.log(JSON.stringify({
+    ok: true,
+    serviceUp,
+    sessions: merged,
+    count: merged.length,
+    registered: registeredSessions.length,
+    live: liveSessions.length,
+    orphaned: merged.filter(s => s.orphaned).length,
+  }, null, 2));
+}
+
+export async function handleRecoverCommand(args) {
+  const profileId = resolveProfileId(args, 1, getDefaultProfile);
+  if (!profileId) throw new Error('Usage: camo recover [profileId]');
+  
+  const reg = getSessionInfo(profileId);
+  if (!reg) {
+    console.log(JSON.stringify({ ok: false, error: 'No registered session found for profile', profileId }, null, 2));
+    return;
+  }
+  
+  const serviceUp = await checkBrowserService();
+  
+  if (!serviceUp) {
+    // Service is down - session cannot be recovered, clean up
+    unregisterSession(profileId);
+    releaseLock(profileId);
+    console.log(JSON.stringify({
+      ok: true,
+      recovered: false,
+      reason: 'browser_service_down',
+      profileId,
+      message: 'Browser service is down. Session cleaned up. Restart with: camo start ' + profileId,
+    }, null, 2));
+    return;
+  }
+  
+  // Service is up - check if session is still there
+  try {
+    const status = await callAPI('getStatus', {});
+    const existing = status?.sessions?.find(s => s.profileId === profileId);
+    
+    if (existing) {
+      // Session is alive - update registry
+      updateSession(profileId, {
+        sessionId: existing.session_id || existing.profileId,
+        url: existing.current_url,
+        status: 'active',
+        recoveredAt: Date.now(),
+      });
+      acquireLock(profileId, { sessionId: existing.session_id || existing.profileId });
+      console.log(JSON.stringify({
+        ok: true,
+        recovered: true,
+        profileId,
+        sessionId: existing.session_id || existing.profileId,
+        url: existing.current_url,
+        message: 'Session reconnected successfully',
+      }, null, 2));
+    } else {
+      // Session not in browser service - clean up
+      unregisterSession(profileId);
+      releaseLock(profileId);
+      console.log(JSON.stringify({
+        ok: true,
+        recovered: false,
+        reason: 'session_not_found',
+        profileId,
+        message: 'Session not found in browser service. Cleaned up. Restart with: camo start ' + profileId,
+      }, null, 2));
+    }
+  } catch (err) {
+    console.log(JSON.stringify({ ok: false, error: err.message, profileId }, null, 2));
+  }
+}

package/src/commands/mouse.mjs

@@ -0,0 +1,49 @@
+import { getDefaultProfile } from '../utils/config.mjs';
+import { callAPI, ensureBrowserService } from '../utils/browser-service.mjs';
+import { getPositionals } from '../utils/args.mjs';
+
+export async function handleMouseCommand(args) {
+  await ensureBrowserService();
+
+  const sub = args[1];
+  const profileId = getPositionals(args, 2)[0] || getDefaultProfile();
+  if (!profileId) throw new Error('No profile specified and no default profile set');
+
+  if (sub === 'move') {
+    const xIdx = args.indexOf('--x');
+    const yIdx = args.indexOf('--y');
+    const stepsIdx = args.indexOf('--steps');
+    if (xIdx === -1 || yIdx === -1) throw new Error('Usage: camo mouse move [profileId] --x <x> --y <y> [--steps <n>]');
+    const x = parseInt(args[xIdx + 1]);
+    const y = parseInt(args[yIdx + 1]);
+    const steps = stepsIdx >= 0 ? parseInt(args[stepsIdx + 1]) : undefined;
+    const result = await callAPI('mouse:move', { profileId, x, y, steps });
+    console.log(JSON.stringify(result, null, 2));
+  } else if (sub === 'click') {
+    // Use existing click command? We already have click command for element clicking.
+    // This is for raw mouse click at coordinates.
+    const xIdx = args.indexOf('--x');
+    const yIdx = args.indexOf('--y');
+    const buttonIdx = args.indexOf('--button');
+    const clicksIdx = args.indexOf('--clicks');
+    const delayIdx = args.indexOf('--delay');
+    if (xIdx === -1 || yIdx === -1) throw new Error('Usage: camo mouse click [profileId] --x <x> --y <y> [--button left|right|middle] [--clicks <n>] [--delay <ms>]');
+    const x = parseInt(args[xIdx + 1]);
+    const y = parseInt(args[yIdx + 1]);
+    const button = buttonIdx >= 0 ? args[buttonIdx + 1] : 'left';
+    const clicks = clicksIdx >= 0 ? parseInt(args[clicksIdx + 1]) : 1;
+    const delay = delayIdx >= 0 ? parseInt(args[delayIdx + 1]) : undefined;
+    const result = await callAPI('mouse:click', { profileId, x, y, button, clicks, delay });
+    console.log(JSON.stringify(result, null, 2));
+  } else if (sub === 'wheel') {
+    const deltaXIdx = args.indexOf('--deltax');
+    const deltaYIdx = args.indexOf('--deltay');
+    if (deltaXIdx === -1 && deltaYIdx === -1) throw new Error('Usage: camo mouse wheel [profileId] [--deltax <px>] [--deltay <px>]');
+    const deltaX = deltaXIdx >= 0 ? parseInt(args[deltaXIdx + 1]) : 0;
+    const deltaY = deltaYIdx >= 0 ? parseInt(args[deltaYIdx + 1]) : 0;
+    const result = await callAPI('mouse:wheel', { profileId, deltaX, deltaY });
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    throw new Error('Usage: camo mouse <move|click|wheel> [profileId] [options]');
+  }
+}

package/src/commands/profile.mjs

@@ -0,0 +1,46 @@
+import { listProfiles, createProfile, deleteProfile, setDefaultProfile, getDefaultProfile, loadConfig, saveConfig } from '../utils/config.mjs';
+
+export async function handleProfileCommand(args) {
+  const sub = args[1];
+  const profileId = args[2];
+
+  if (sub === 'list' || !sub) {
+    const profiles = listProfiles();
+    const defaultProfile = getDefaultProfile();
+    console.log(JSON.stringify({ ok: true, profiles, defaultProfile, count: profiles.length }, null, 2));
+    return;
+  }
+
+  if (sub === 'create') {
+    if (!profileId) throw new Error('Usage: camo profile create <profileId>');
+    createProfile(profileId);
+    console.log(`Created profile: ${profileId}`);
+    return;
+  }
+
+  if (sub === 'delete' || sub === 'remove') {
+    if (!profileId) throw new Error('Usage: camo profile delete <profileId>');
+    deleteProfile(profileId);
+    const cfg = loadConfig();
+    if (cfg.defaultProfile === profileId) {
+      cfg.defaultProfile = null;
+      saveConfig(cfg);
+    }
+    console.log(`Deleted profile: ${profileId}`);
+    return;
+  }
+
+  if (sub === 'default') {
+    if (!profileId) {
+      console.log(JSON.stringify({ ok: true, defaultProfile: getDefaultProfile() }, null, 2));
+      return;
+    }
+    const profiles = listProfiles();
+    if (!profiles.includes(profileId)) throw new Error(`Profile not found: ${profileId}`);
+    setDefaultProfile(profileId);
+    console.log(`Default profile set to: ${profileId}`);
+    return;
+  }
+
+  throw new Error('Usage: camo profile <list|create|delete|default> [profileId]');
+}

package/src/commands/system.mjs

@@ -0,0 +1,14 @@
+import { callAPI, ensureBrowserService } from '../utils/browser-service.mjs';
+
+export async function handleSystemCommand(args) {
+  await ensureBrowserService();
+
+  const sub = args[1];
+
+  if (sub === 'display') {
+    const result = await callAPI('system:display', {});
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    throw new Error('Usage: camo system display');
+  }
+}

package/src/commands/window.mjs

@@ -0,0 +1,31 @@
+import { getDefaultProfile } from '../utils/config.mjs';
+import { callAPI, ensureBrowserService } from '../utils/browser-service.mjs';
+import { getPositionals } from '../utils/args.mjs';
+
+export async function handleWindowCommand(args) {
+  await ensureBrowserService();
+
+  const sub = args[1];
+  const profileId = getPositionals(args, 2)[0] || getDefaultProfile();
+  if (!profileId) throw new Error('No profile specified and no default profile set');
+
+  if (sub === 'move') {
+    const xIdx = args.indexOf('--x');
+    const yIdx = args.indexOf('--y');
+    if (xIdx === -1 || yIdx === -1) throw new Error('Usage: camo window move [profileId] --x <x> --y <y>');
+    const x = parseInt(args[xIdx + 1]);
+    const y = parseInt(args[yIdx + 1]);
+    const result = await callAPI('window:move', { profileId, x, y });
+    console.log(JSON.stringify(result, null, 2));
+  } else if (sub === 'resize') {
+    const widthIdx = args.indexOf('--width');
+    const heightIdx = args.indexOf('--height');
+    if (widthIdx === -1 || heightIdx === -1) throw new Error('Usage: camo window resize [profileId] --width <w> --height <h>');
+    const width = parseInt(args[widthIdx + 1]);
+    const height = parseInt(args[heightIdx + 1]);
+    const result = await callAPI('window:resize', { profileId, width, height });
+    console.log(JSON.stringify(result, null, 2));
+  } else {
+    throw new Error('Usage: camo window <move|resize> [profileId] --x <x> --y <y> / --width <w> --height <h>');
+  }
+}