@web-auto/camo 0.1.4 → 0.1.5

package/README.md

@@ -68,12 +68,16 @@ camo create fingerprint --os <os> --region <region>
 ### Browser Control
 
 ```bash
-camo start [profileId] [--url <url>] [--headless]
+camo start [profileId] [--url <url>] [--headless] [--width <w> --height <h>]
 camo stop [profileId]
 camo status [profileId]
 camo shutdown                          # Shutdown browser-service (all sessions)
 ```
 
+`camo start` in headful mode now persists window size per profile and reuses that size on next start.  
+If no saved size exists, it defaults to near-fullscreen (full width, slight vertical reserve).  
+Use `--width/--height` to override and update the saved profile size.
+
 ### Lifecycle & Cleanup
 
 ```bash

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@web-auto/camo",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "Camoufox Browser CLI - Cross-platform browser automation",
   "type": "module",
   "bin": {

package/src/commands/browser.mjs

@@ -1,11 +1,145 @@
 import fs from 'node:fs';
-import { listProfiles, getDefaultProfile } from '../utils/config.mjs';
+import {
+  listProfiles,
+  getDefaultProfile,
+  getProfileWindowSize,
+  setProfileWindowSize,
+} from '../utils/config.mjs';
 import { callAPI, ensureCamoufox, ensureBrowserService, getSessionByProfile, checkBrowserService } from '../utils/browser-service.mjs';
 import { resolveProfileId, ensureUrlScheme, looksLikeUrlToken, getPositionals } from '../utils/args.mjs';
 import { acquireLock, releaseLock, isLocked, getLockInfo, cleanupStaleLocks } from '../lifecycle/lock.mjs';
 import { registerSession, updateSession, getSessionInfo, unregisterSession, listRegisteredSessions, markSessionClosed, cleanupStaleSessions, recoverSession } from '../lifecycle/session-registry.mjs';
 import { startSessionWatchdog, stopAllSessionWatchdogs, stopSessionWatchdog } from '../lifecycle/session-watchdog.mjs';
 
+const START_WINDOW_MIN_WIDTH = 960;
+const START_WINDOW_MIN_HEIGHT = 700;
+const START_WINDOW_MAX_RESERVE = 240;
+const START_WINDOW_DEFAULT_RESERVE = 72;
+
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function parseNumber(value, fallback = 0) {
+  const parsed = Number(value);
+  return Number.isFinite(parsed) ? parsed : fallback;
+}
+
+function clamp(value, min, max) {
+  return Math.min(Math.max(value, min), max);
+}
+
+export function computeTargetViewportFromWindowMetrics(measured) {
+  const innerWidth = Math.max(320, parseNumber(measured?.innerWidth, 0));
+  const innerHeight = Math.max(240, parseNumber(measured?.innerHeight, 0));
+  const outerWidth = Math.max(320, parseNumber(measured?.outerWidth, innerWidth));
+  const outerHeight = Math.max(240, parseNumber(measured?.outerHeight, innerHeight));
+
+  const rawDeltaW = Math.max(0, outerWidth - innerWidth);
+  const rawDeltaH = Math.max(0, outerHeight - innerHeight);
+  const frameW = rawDeltaW > 400 ? 16 : Math.min(rawDeltaW, 120);
+  const frameH = rawDeltaH > 400 ? 88 : Math.min(rawDeltaH, 180);
+
+  return {
+    width: Math.max(320, outerWidth - frameW),
+    height: Math.max(240, outerHeight - frameH),
+    frameW,
+    frameH,
+    innerWidth,
+    innerHeight,
+    outerWidth,
+    outerHeight,
+  };
+}
+
+export function computeStartWindowSize(metrics, options = {}) {
+  const display = metrics?.metrics || metrics || {};
+  const reserveFromEnv = parseNumber(process.env.CAMO_DEFAULT_WINDOW_VERTICAL_RESERVE, START_WINDOW_DEFAULT_RESERVE);
+  const reserve = clamp(
+    parseNumber(options.reservePx, reserveFromEnv),
+    0,
+    START_WINDOW_MAX_RESERVE,
+  );
+
+  const workWidth = parseNumber(display.workWidth, 0);
+  const workHeight = parseNumber(display.workHeight, 0);
+  const width = parseNumber(display.width, 0);
+  const height = parseNumber(display.height, 0);
+  const baseW = Math.floor(workWidth > 0 ? workWidth : width);
+  const baseH = Math.floor(workHeight > 0 ? workHeight : height);
+
+  if (baseW <= 0 || baseH <= 0) {
+    return {
+      width: 1920,
+      height: 1000,
+      reservePx: reserve,
+      source: 'fallback',
+    };
+  }
+
+  return {
+    width: Math.max(START_WINDOW_MIN_WIDTH, baseW),
+    height: Math.max(START_WINDOW_MIN_HEIGHT, baseH - reserve),
+    reservePx: reserve,
+    source: workWidth > 0 || workHeight > 0 ? 'workArea' : 'screen',
+  };
+}
+
+async function probeWindowMetrics(profileId) {
+  const measured = await callAPI('evaluate', {
+    profileId,
+    script: '({ innerWidth: window.innerWidth, innerHeight: window.innerHeight, outerWidth: window.outerWidth, outerHeight: window.outerHeight })',
+  });
+  return measured?.result || {};
+}
+
+export async function syncWindowViewportAfterResize(profileId, width, height, options = {}) {
+  const settleMs = Math.max(40, parseNumber(options.settleMs, 120));
+  const attempts = Math.max(1, Math.min(8, Math.floor(parseNumber(options.attempts, 4))));
+  const tolerancePx = Math.max(0, parseNumber(options.tolerancePx, 3));
+
+  const windowResult = await callAPI('window:resize', { profileId, width, height });
+  await sleep(settleMs);
+
+  let measured = {};
+  let verified = {};
+  let viewport = null;
+  let matched = false;
+  let target = { width: 1280, height: 720, frameW: 16, frameH: 88 };
+
+  for (let i = 0; i < attempts; i += 1) {
+    measured = await probeWindowMetrics(profileId);
+    target = computeTargetViewportFromWindowMetrics(measured);
+    viewport = await callAPI('page:setViewport', {
+      profileId,
+      width: target.width,
+      height: target.height,
+    });
+    await sleep(settleMs);
+    verified = await probeWindowMetrics(profileId);
+    const dw = Math.abs(parseNumber(verified?.innerWidth, 0) - target.width);
+    const dh = Math.abs(parseNumber(verified?.innerHeight, 0) - target.height);
+    if (dw <= tolerancePx && dh <= tolerancePx) {
+      matched = true;
+      break;
+    }
+  }
+
+  return {
+    window: windowResult,
+    measured,
+    verified,
+    targetViewport: {
+      width: target.width,
+      height: target.height,
+      frameW: target.frameW,
+      frameH: target.frameH,
+      matched,
+    },
+    viewport,
+  };
+}
+
 export async function handleStartCommand(args) {
   ensureCamoufox();
   await ensureBrowserService();
@@ -14,6 +148,19 @@ export async function handleStartCommand(args) {
 
   const urlIdx = args.indexOf('--url');
   const explicitUrl = urlIdx >= 0 ? args[urlIdx + 1] : undefined;
+  const widthIdx = args.indexOf('--width');
+  const heightIdx = args.indexOf('--height');
+  const explicitWidth = widthIdx >= 0 ? parseNumber(args[widthIdx + 1], NaN) : NaN;
+  const explicitHeight = heightIdx >= 0 ? parseNumber(args[heightIdx + 1], NaN) : NaN;
+  const hasExplicitWidth = Number.isFinite(explicitWidth);
+  const hasExplicitHeight = Number.isFinite(explicitHeight);
+  if (hasExplicitWidth !== hasExplicitHeight) {
+    throw new Error('Usage: camo start [profileId] [--url <url>] [--headless] [--width <w> --height <h>]');
+  }
+  if ((hasExplicitWidth && explicitWidth < START_WINDOW_MIN_WIDTH) || (hasExplicitHeight && explicitHeight < START_WINDOW_MIN_HEIGHT)) {
+    throw new Error(`Window size too small. Minimum is ${START_WINDOW_MIN_WIDTH}x${START_WINDOW_MIN_HEIGHT}`);
+  }
+  const hasExplicitWindowSize = hasExplicitWidth && hasExplicitHeight;
   const profileSet = new Set(listProfiles());
   let implicitUrl;
   
@@ -21,6 +168,7 @@ export async function handleStartCommand(args) {
   for (let i = 1; i < args.length; i++) {
     const arg = args[i];
     if (arg === '--url') { i++; continue; }
+    if (arg === '--width' || arg === '--height') { i++; continue; }
     if (arg === '--headless') continue;
     if (arg.startsWith('--')) continue;
 
@@ -87,6 +235,52 @@ export async function handleStartCommand(args) {
       headless,
     });
     startSessionWatchdog(profileId);
+
+    if (!headless) {
+      let windowTarget = null;
+      if (hasExplicitWindowSize) {
+        windowTarget = {
+          width: Math.floor(explicitWidth),
+          height: Math.floor(explicitHeight),
+          source: 'explicit',
+        };
+      } else {
+        const rememberedWindow = getProfileWindowSize(profileId);
+        if (rememberedWindow) {
+          windowTarget = {
+            width: rememberedWindow.width,
+            height: rememberedWindow.height,
+            source: 'profile',
+            updatedAt: rememberedWindow.updatedAt,
+          };
+        } else {
+          const display = await callAPI('system:display', {}).catch(() => null);
+          windowTarget = computeStartWindowSize(display);
+        }
+      }
+
+      result.startWindow = {
+        width: windowTarget.width,
+        height: windowTarget.height,
+        source: windowTarget.source,
+      };
+
+      const syncResult = await syncWindowViewportAfterResize(
+        profileId,
+        windowTarget.width,
+        windowTarget.height,
+      ).catch((err) => ({ error: err?.message || String(err) }));
+      result.windowSync = syncResult;
+
+      const measuredOuterWidth = Number(syncResult?.verified?.outerWidth);
+      const measuredOuterHeight = Number(syncResult?.verified?.outerHeight);
+      const savedWindow = setProfileWindowSize(
+        profileId,
+        Number.isFinite(measuredOuterWidth) ? measuredOuterWidth : windowTarget.width,
+        Number.isFinite(measuredOuterHeight) ? measuredOuterHeight : windowTarget.height,
+      );
+      result.profileWindow = savedWindow?.window || null;
+    }
   }
   console.log(JSON.stringify(result, null, 2));
 }

package/src/commands/window.mjs

@@ -1,7 +1,38 @@
-import { getDefaultProfile } from '../utils/config.mjs';
+import { getDefaultProfile, setProfileWindowSize } from '../utils/config.mjs';
 import { callAPI, ensureBrowserService } from '../utils/browser-service.mjs';
 import { getPositionals } from '../utils/args.mjs';
 
+function sleep(ms) {
+  return new Promise((resolve) => setTimeout(resolve, ms));
+}
+
+function computeTargetViewport(measured) {
+  const innerWidth = Math.max(320, Number(measured?.innerWidth || 0) || 0);
+  const innerHeight = Math.max(240, Number(measured?.innerHeight || 0) || 0);
+  const outerWidth = Math.max(320, Number(measured?.outerWidth || 0) || innerWidth);
+  const outerHeight = Math.max(240, Number(measured?.outerHeight || 0) || innerHeight);
+
+  const rawDeltaW = Math.max(0, outerWidth - innerWidth);
+  const rawDeltaH = Math.max(0, outerHeight - innerHeight);
+  const frameW = rawDeltaW > 400 ? 16 : Math.min(rawDeltaW, 120);
+  const frameH = rawDeltaH > 400 ? 88 : Math.min(rawDeltaH, 180);
+
+  return {
+    width: Math.max(320, outerWidth - frameW),
+    height: Math.max(240, outerHeight - frameH),
+    frameW,
+    frameH,
+  };
+}
+
+async function probeWindowMetrics(profileId) {
+  const measured = await callAPI('evaluate', {
+    profileId,
+    script: '({ innerWidth: window.innerWidth, innerHeight: window.innerHeight, outerWidth: window.outerWidth, outerHeight: window.outerHeight })',
+  });
+  return measured?.result || {};
+}
+
 export async function handleWindowCommand(args) {
   await ensureBrowserService();
 
@@ -24,36 +55,66 @@ export async function handleWindowCommand(args) {
     const width = parseInt(args[widthIdx + 1]);
     const height = parseInt(args[heightIdx + 1]);
     const result = await callAPI('window:resize', { profileId, width, height });
-    const measured = await callAPI('evaluate', {
-      profileId,
-      script: '({ innerWidth: window.innerWidth, innerHeight: window.innerHeight, outerWidth: window.outerWidth, outerHeight: window.outerHeight })',
-    });
-    const innerWidth = Math.max(320, Number(measured?.result?.innerWidth || 0) || 0);
-    const innerHeight = Math.max(240, Number(measured?.result?.innerHeight || 0) || 0);
-    const outerWidth = Math.max(320, Number(measured?.result?.outerWidth || 0) || innerWidth);
-    const outerHeight = Math.max(240, Number(measured?.result?.outerHeight || 0) || innerHeight);
-    const rawDeltaW = Math.max(0, outerWidth - innerWidth);
-    const rawDeltaH = Math.max(0, outerHeight - innerHeight);
-    const frameW = rawDeltaW > 400 ? 16 : Math.min(rawDeltaW, 120);
-    const frameH = rawDeltaH > 400 ? 88 : Math.min(rawDeltaH, 180);
-    const targetViewportWidth = Math.max(320, outerWidth - frameW);
-    const targetViewportHeight = Math.max(240, outerHeight - frameH);
-    const viewport = await callAPI('page:setViewport', {
+
+    const attempts = 4;
+    const settleMs = 120;
+    const tolerancePx = 3;
+    let measured = {};
+    let verified = {};
+    let viewport = null;
+    let targetViewportWidth = 1280;
+    let targetViewportHeight = 720;
+    let frameW = 16;
+    let frameH = 88;
+    let matched = false;
+
+    await sleep(settleMs);
+    for (let i = 0; i < attempts; i += 1) {
+      measured = await probeWindowMetrics(profileId);
+      const target = computeTargetViewport(measured);
+      targetViewportWidth = target.width;
+      targetViewportHeight = target.height;
+      frameW = target.frameW;
+      frameH = target.frameH;
+
+      viewport = await callAPI('page:setViewport', {
+        profileId,
+        width: targetViewportWidth,
+        height: targetViewportHeight,
+      });
+
+      await sleep(settleMs);
+      verified = await probeWindowMetrics(profileId);
+      const dw = Math.abs((Number(verified?.innerWidth || 0)) - targetViewportWidth);
+      const dh = Math.abs((Number(verified?.innerHeight || 0)) - targetViewportHeight);
+      if (dw <= tolerancePx && dh <= tolerancePx) {
+        matched = true;
+        break;
+      }
+    }
+
+    const measuredOuterWidth = Number(verified?.outerWidth);
+    const measuredOuterHeight = Number(verified?.outerHeight);
+    const savedWindow = setProfileWindowSize(
       profileId,
-      width: targetViewportWidth,
-      height: targetViewportHeight,
-    });
+      Number.isFinite(measuredOuterWidth) ? measuredOuterWidth : width,
+      Number.isFinite(measuredOuterHeight) ? measuredOuterHeight : height,
+    );
+
     console.log(JSON.stringify({
       ok: true,
       profileId,
       window: result,
-      measured: measured?.result || null,
+      measured: measured || null,
+      verified: verified || null,
       targetViewport: {
         width: targetViewportWidth,
         height: targetViewportHeight,
         frameW,
         frameH,
+        matched,
       },
+      profileWindow: savedWindow?.window || null,
       viewport,
     }, null, 2));
   } else {

package/src/lifecycle/session-watchdog.mjs

@@ -63,6 +63,45 @@ function isBlankUrl(url) {
   return text === '' || text === 'about:blank' || text === 'about:blank#blocked';
 }
 
+function computeTargetViewportFromWindow(measured) {
+  const innerWidth = Math.max(320, Number(measured?.innerWidth || 0) || 0);
+  const innerHeight = Math.max(240, Number(measured?.innerHeight || 0) || 0);
+  const outerWidth = Math.max(320, Number(measured?.outerWidth || 0) || innerWidth);
+  const outerHeight = Math.max(240, Number(measured?.outerHeight || 0) || innerHeight);
+  const rawDeltaW = Math.max(0, outerWidth - innerWidth);
+  const rawDeltaH = Math.max(0, outerHeight - innerHeight);
+  const frameW = rawDeltaW > 400 ? 16 : Math.min(rawDeltaW, 120);
+  const frameH = rawDeltaH > 400 ? 88 : Math.min(rawDeltaH, 180);
+  return {
+    width: Math.max(320, outerWidth - frameW),
+    height: Math.max(240, outerHeight - frameH),
+    innerWidth,
+    innerHeight,
+  };
+}
+
+async function probeWindowMetrics(profileId) {
+  const measured = await callAPI('evaluate', {
+    profileId,
+    script: '({ innerWidth: window.innerWidth, innerHeight: window.innerHeight, outerWidth: window.outerWidth, outerHeight: window.outerHeight })',
+  });
+  return measured?.result || {};
+}
+
+async function syncViewportWithWindow(profileId, tolerancePx = 3) {
+  const measured = await probeWindowMetrics(profileId);
+  const target = computeTargetViewportFromWindow(measured);
+  const dw = Math.abs(target.innerWidth - target.width);
+  const dh = Math.abs(target.innerHeight - target.height);
+  if (dw <= tolerancePx && dh <= tolerancePx) return false;
+  await callAPI('page:setViewport', {
+    profileId,
+    width: target.width,
+    height: target.height,
+  });
+  return true;
+}
+
 function shouldExitMonitor(profileId) {
   const info = getSessionInfo(profileId);
   return !info || info.status !== 'active';
@@ -78,6 +117,8 @@ 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);
+  const viewportSyncIntervalMs = Math.max(500, Number(options.viewportSyncIntervalMs) || 1500);
+  let lastViewportSyncAt = 0;
 
   let seenAnyPage = false;
   let seenNonBlankPage = false;
@@ -140,6 +181,12 @@ async function runMonitor(profileId, options = {}) {
       return;
     }
 
+    const now = Date.now();
+    if (pages.length > 0 && now - lastViewportSyncAt >= viewportSyncIntervalMs) {
+      lastViewportSyncAt = now;
+      await syncViewportWithWindow(profileId).catch(() => {});
+    }
+
     await sleep(intervalMs);
   }
 }

package/src/utils/config.mjs

@@ -6,6 +6,7 @@ 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 PROFILE_META_FILE = 'camo-profile.json';
 export const BROWSER_SERVICE_URL = process.env.WEBAUTO_BROWSER_URL || 'http://127.0.0.1:7704';
 
 export function ensureDir(p) {
@@ -55,13 +56,13 @@ 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);
+  const profileDir = getProfileDir(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);
+  const profileDir = getProfileDir(profileId);
   if (!fs.existsSync(profileDir)) throw new Error(`Profile not found: ${profileId}`);
   fs.rmSync(profileDir, { recursive: true, force: true });
 }
@@ -82,6 +83,61 @@ export function getDefaultProfile() {
   return loadConfig().defaultProfile;
 }
 
+export function getProfileDir(profileId) {
+  return path.join(PROFILES_DIR, String(profileId || '').trim());
+}
+
+export function getProfileMetaFile(profileId) {
+  return path.join(getProfileDir(profileId), PROFILE_META_FILE);
+}
+
+function loadProfileMeta(profileId) {
+  if (!isValidProfileId(profileId)) return {};
+  return readJson(getProfileMetaFile(profileId)) || {};
+}
+
+function saveProfileMeta(profileId, patch) {
+  if (!isValidProfileId(profileId)) return null;
+  const profileDir = getProfileDir(profileId);
+  ensureDir(profileDir);
+  const current = loadProfileMeta(profileId);
+  const next = {
+    ...current,
+    ...patch,
+    updatedAt: Date.now(),
+  };
+  writeJson(getProfileMetaFile(profileId), next);
+  return next;
+}
+
+export function getProfileWindowSize(profileId) {
+  const meta = loadProfileMeta(profileId);
+  const width = Number(meta?.window?.width);
+  const height = Number(meta?.window?.height);
+  if (!Number.isFinite(width) || !Number.isFinite(height)) return null;
+  if (width < 320 || height < 240) return null;
+  return {
+    width: Math.floor(width),
+    height: Math.floor(height),
+    updatedAt: Number(meta?.window?.updatedAt) || Number(meta?.updatedAt) || null,
+  };
+}
+
+export function setProfileWindowSize(profileId, width, height) {
+  const parsedWidth = Number(width);
+  const parsedHeight = Number(height);
+  if (!Number.isFinite(parsedWidth) || !Number.isFinite(parsedHeight)) return null;
+  if (parsedWidth < 320 || parsedHeight < 240) return null;
+  const now = Date.now();
+  return saveProfileMeta(profileId, {
+    window: {
+      width: Math.floor(parsedWidth),
+      height: Math.floor(parsedHeight),
+      updatedAt: now,
+    },
+  });
+}
+
 const START_SCRIPT_REL = path.join('runtime', 'infra', 'utils', 'scripts', 'service', 'start-browser-service.mjs');
 
 export function hasStartScript(root) {

package/src/utils/help.mjs

@@ -24,7 +24,7 @@ CONFIG:
 
 BROWSER CONTROL:
   init                                      Ensure camoufox + ensure browser-service daemon
-  start [profileId] [--url <url>] [--headless]
+  start [profileId] [--url <url>] [--headless] [--width <w> --height <h>]
   stop [profileId]
   status [profileId]
   list                                      Alias of status
@@ -91,6 +91,7 @@ EXAMPLES:
   camo profile create myprofile
   camo profile default myprofile
   camo start --url https://example.com
+  camo start myprofile --width 1920 --height 1020
   camo goto https://www.xiaohongshu.com
   camo scroll --down --amount 500
   camo click "#search-input"