@web-auto/camo 0.1.23 → 0.1.24

package/package.json

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

package/src/container/subscription-registry.mjs

@@ -1,6 +1,6 @@
 import fs from 'node:fs';
 import path from 'node:path';
-import { CONFIG_DIR } from '../utils/config.mjs';
+import { CONFIG_DIR, loadConfig } from '../utils/config.mjs';
 
 const CONTAINER_ROOT_ENV = process.env.CAMO_CONTAINER_ROOT;
 

package/src/services/browser-service/internal/BrowserSession.input.test.js

@@ -277,6 +277,39 @@ test('mouseWheel retries with refreshed active page after timeout', async () =>
         restoreTimeout();
     }
 });
+test('mouseWheel prefers interactive viewport metrics for anchor clamping', async () => {
+    const restoreTimeout = setEnv('CAMO_INPUT_ACTION_TIMEOUT_MS', '80');
+    const restoreAttempts = setEnv('CAMO_INPUT_ACTION_MAX_ATTEMPTS', '1');
+    const restoreDelay = setEnv('CAMO_INPUT_RECOVERY_DELAY_MS', '0');
+    const restoreBringToFrontTimeout = setEnv('CAMO_INPUT_RECOVERY_BRING_TO_FRONT_TIMEOUT_MS', '50');
+    const restoreReadySettle = setEnv('CAMO_INPUT_READY_SETTLE_MS', '0');
+    try {
+        const moves = [];
+        const page = {
+            isClosed: () => false,
+            viewportSize: () => ({ width: 1280, height: 720 }),
+            evaluate: async () => ({ innerWidth: 2560, innerHeight: 1440, visualWidth: 2560, visualHeight: 1440 }),
+            bringToFront: async () => { },
+            waitForTimeout: async () => { },
+            mouse: {
+                move: async (x, y) => {
+                    moves.push([x, y]);
+                },
+                wheel: async () => { },
+            },
+        };
+        const session = createSessionWithPage(page);
+        await session.mouseWheel({ deltaY: 360, anchorX: 2564, anchorY: 228 });
+        assert.deepEqual(moves, [[2559, 228]]);
+    }
+    finally {
+        restoreReadySettle();
+        restoreBringToFrontTimeout();
+        restoreDelay();
+        restoreAttempts();
+        restoreTimeout();
+    }
+});
 test('mouseWheel falls back to keyboard paging when wheel keeps timing out', async () => {
     const restoreTimeout = setEnv('CAMO_INPUT_ACTION_TIMEOUT_MS', '80');
     const restoreAttempts = setEnv('CAMO_INPUT_ACTION_MAX_ATTEMPTS', '1');

package/src/services/browser-service/internal/browser-session/input-ops.js

@@ -1,4 +1,30 @@
 import { isTimeoutLikeError } from './utils.js';
+
+async function readInteractiveViewport(page) {
+    const fallback = page.viewportSize?.() || null;
+    try {
+        const metrics = await page.evaluate(() => ({
+            innerWidth: Number(window.innerWidth || 0),
+            innerHeight: Number(window.innerHeight || 0),
+            visualWidth: Number(window.visualViewport?.width || 0),
+            visualHeight: Number(window.visualViewport?.height || 0),
+        }));
+        const width = Math.max(Number(metrics?.innerWidth || 0), Number(metrics?.visualWidth || 0), Number(fallback?.width || 0));
+        const height = Math.max(Number(metrics?.innerHeight || 0), Number(metrics?.visualHeight || 0), Number(fallback?.height || 0));
+        if (Number.isFinite(width) && width > 1 && Number.isFinite(height) && height > 1) {
+            return {
+                width: Math.round(width),
+                height: Math.round(height),
+            };
+        }
+    }
+    catch { }
+    return {
+        width: Math.max(1, Number(fallback?.width || 1280)),
+        height: Math.max(1, Number(fallback?.height || 720)),
+    };
+}
+
 export class BrowserSessionInputOps {
     ensurePrimaryPage;
     ensureInputReady;
@@ -89,7 +115,7 @@ export class BrowserSessionInputOps {
             }
             try {
                 await this.runInputAction(page, 'mouse:wheel', async (activePage) => {
-                    const viewport = activePage.viewportSize();
+                    const viewport = await readInteractiveViewport(activePage);
                     const moveX = Number.isFinite(normalizedAnchorX)
                         ? Math.max(1, Math.min(Math.max(1, Number(viewport?.width || 1280) - 1), Math.round(normalizedAnchorX)))
                         : Math.max(1, Math.floor(((viewport?.width || 1280) * 0.5)));

package/src/services/browser-service/internal/browser-session/page-management.js

@@ -6,6 +6,36 @@ export class BrowserSessionPageManagement {
     constructor(deps) {
         this.deps = deps;
     }
+    async openPageViaContext(ctx, beforeCount) {
+        try {
+            const page = await ctx.newPage();
+            await page.waitForLoadState('domcontentloaded', { timeout: 1500 }).catch(() => null);
+            const after = ctx.pages().filter((p) => !p.isClosed()).length;
+            if (after > beforeCount) {
+                return page;
+            }
+        }
+        catch {
+            // Fall through to shortcut-based creation below.
+        }
+        return null;
+    }
+    async openPageViaShortcut(ctx, opener, shortcut, beforeCount) {
+        for (let attempt = 1; attempt <= 3; attempt += 1) {
+            const waitPage = ctx.waitForEvent('page', { timeout: 1200 }).catch(() => null);
+            await opener.keyboard.press(shortcut).catch(() => null);
+            const page = await waitPage;
+            const pagesNow = ctx.pages().filter((p) => !p.isClosed());
+            const after = pagesNow.length;
+            if (page && after > beforeCount)
+                return page;
+            if (!page && after > beforeCount) {
+                return pagesNow[pagesNow.length - 1] || null;
+            }
+            await new Promise((r) => setTimeout(r, 250));
+        }
+        return null;
+    }
     tryOsNewTabShortcut() {
         if (this.deps.isHeadless())
             return false;
@@ -58,7 +88,14 @@ export class BrowserSessionPageManagement {
     }
     listPages() {
         const ctx = this.deps.ensureContext();
-        const pages = ctx.pages().filter((p) => !p.isClosed());
+        // Filter out closed pages AND pages that are effectively blank (about:newtab/about:blank)
+        const pages = ctx.pages().filter((p) => {
+            if (p.isClosed()) return false;
+            const url = p.url();
+            // Filter out blank placeholder pages
+            if (url === 'about:newtab' || url === 'about:blank') return false;
+            return true;
+        });
         const active = this.deps.getActivePage();
         return pages.map((p, index) => ({
             index,
@@ -78,23 +115,15 @@ export class BrowserSessionPageManagement {
             await opener.bringToFront().catch(() => null);
         }
         const before = ctx.pages().filter((p) => !p.isClosed()).length;
-        for (let attempt = 1; attempt <= 3; attempt += 1) {
-            const waitPage = ctx.waitForEvent('page', { timeout: 8000 }).catch(() => null);
-            await opener.keyboard.press(shortcut).catch(() => null);
-            page = await waitPage;
-            const pagesNow = ctx.pages().filter((p) => !p.isClosed());
-            const after = pagesNow.length;
-            if (page && after > before)
-                break;
-            if (!page && after > before) {
-                page = pagesNow[pagesNow.length - 1] || null;
-                break;
-            }
-            await new Promise((r) => setTimeout(r, 250));
+        if (!options?.strictShortcut) {
+            page = await this.openPageViaContext(ctx, before);
+        }
+        if (!page) {
+            page = await this.openPageViaShortcut(ctx, opener, shortcut, before);
         }
         let after = ctx.pages().filter((p) => !p.isClosed()).length;
         if (!page || after <= before) {
-            const waitPage = ctx.waitForEvent('page', { timeout: 8000 }).catch(() => null);
+            const waitPage = ctx.waitForEvent('page', { timeout: 1200 }).catch(() => null);
             const osShortcutOk = this.tryOsNewTabShortcut();
             if (osShortcutOk) {
                 page = await waitPage;
@@ -107,13 +136,7 @@ export class BrowserSessionPageManagement {
         }
         if (!page || after <= before) {
             if (!options?.strictShortcut) {
-                try {
-                    page = await ctx.newPage();
-                    await page.waitForLoadState('domcontentloaded', { timeout: 8000 }).catch(() => null);
-                }
-                catch {
-                    // ignore fallback errors
-                }
+                page = await this.openPageViaContext(ctx, before);
                 after = ctx.pages().filter((p) => !p.isClosed()).length;
                 if (!page && after > before) {
                     const pagesNow = ctx.pages().filter((p) => !p.isClosed());
@@ -194,8 +217,39 @@ export class BrowserSessionPageManagement {
             throw new Error(`invalid_page_index: ${index}`);
         }
         const page = pages[closedIndex];
-        await page.close().catch(() => { });
-        const remaining = ctx.pages().filter((p) => !p.isClosed());
+        const beforeUrl = page.url();
+        
+        // Try to close the page
+        try {
+            await page.close({ runBeforeUnload: false });
+        } catch (e) {
+            // Ignore close errors
+        }
+        
+        // Wait for close to take effect
+        await new Promise(r => setTimeout(r, 100));
+        
+        // Check if actually closed
+        let remaining = ctx.pages().filter((p) => !p.isClosed());
+        
+        // If still same count, the page might not have closed properly
+        // Try navigating to about:blank first then close
+        if (remaining.length === pages.length) {
+            try {
+                await page.goto('about:blank', { timeout: 500 }).catch(() => {});
+                await page.close({ runBeforeUnload: false }).catch(() => {});
+                await new Promise(r => setTimeout(r, 100));
+                remaining = ctx.pages().filter((p) => !p.isClosed());
+            } catch (e) {
+                // Ignore
+            }
+        }
+        
+        // Final check - filter out pages that look like closed tabs (about:newtab)
+        remaining = remaining.filter(p => {
+            const url = p.url();
+            return url !== 'about:newtab' && url !== 'about:blank';
+        });
         const nextIndex = remaining.length === 0 ? -1 : Math.min(Math.max(0, closedIndex - 1), remaining.length - 1);
         if (nextIndex >= 0) {
             const nextPage = remaining[nextIndex];

package/src/services/browser-service/internal/browser-session/page-management.test.js

@@ -0,0 +1,105 @@
+import test from 'node:test';
+import assert from 'node:assert/strict';
+import { BrowserSessionPageManagement } from './page-management.js';
+
+function createPage(label) {
+    const page = {
+        label,
+        closed: false,
+        bringToFrontCalls: 0,
+        gotoCalls: [],
+        waitCalls: [],
+        keyboard: {
+            presses: [],
+            press: async (shortcut) => {
+                page.keyboard.presses.push(shortcut);
+            },
+        },
+        url: () => `https://example.com/${label}`,
+        isClosed() {
+            return this.closed;
+        },
+        async bringToFront() {
+            this.bringToFrontCalls += 1;
+        },
+        async waitForLoadState(_state, opts) {
+            this.waitCalls.push(Number(opts?.timeout || 0));
+        },
+        async goto(url) {
+            this.gotoCalls.push(url);
+        },
+    };
+    return page;
+}
+
+function createManagement({ pages, activePage, ctxNewPage, waitForEvent }) {
+    let currentActive = activePage;
+    const ctx = {
+        pages: () => pages,
+        newPage: ctxNewPage,
+        waitForEvent: waitForEvent || (async () => null),
+    };
+    const management = new BrowserSessionPageManagement({
+        ensureContext: () => ctx,
+        getActivePage: () => currentActive,
+        getCurrentUrl: () => currentActive?.url?.() || null,
+        setActivePage: (page) => {
+            currentActive = page ?? null;
+        },
+        setupPageHooks: () => { },
+        ensurePageViewport: async () => { },
+        maybeCenterPage: async () => { },
+        recordLastKnownUrl: () => { },
+        isHeadless: () => false,
+    });
+    return { management, getActivePage: () => currentActive };
+}
+
+test('newPage prefers direct context creation before shortcut retries', async () => {
+    const opener = createPage('opener');
+    const created = createPage('created');
+    const pages = [opener];
+    let ctxNewPageCalls = 0;
+    const { management, getActivePage } = createManagement({
+        pages,
+        activePage: opener,
+        ctxNewPage: async () => {
+            ctxNewPageCalls += 1;
+            pages.push(created);
+            return created;
+        },
+        waitForEvent: async () => {
+            throw new Error('shortcut path should not run');
+        },
+    });
+    const result = await management.newPage();
+    assert.equal(ctxNewPageCalls, 1);
+    assert.equal(opener.keyboard.presses.length, 0);
+    assert.equal(result.index, 1);
+    assert.equal(result.url, 'https://example.com/created');
+    assert.equal(getActivePage(), created);
+});
+
+test('newPage falls back to shortcut path in strictShortcut mode', async () => {
+    const opener = createPage('opener');
+    const created = createPage('created');
+    const pages = [opener];
+    let ctxNewPageCalls = 0;
+    const { management, getActivePage } = createManagement({
+        pages,
+        activePage: opener,
+        ctxNewPage: async () => {
+            ctxNewPageCalls += 1;
+            return created;
+        },
+        waitForEvent: async () => {
+            pages.push(created);
+            return created;
+        },
+    });
+    const result = await management.newPage(undefined, { strictShortcut: true });
+    assert.equal(ctxNewPageCalls, 0);
+    assert.ok(opener.keyboard.presses.length >= 1);
+    assert.equal(result.index, 1);
+    assert.equal(getActivePage(), created);
+});

package/src/utils/config.mjs

@@ -69,7 +69,7 @@ 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.CAMO_BROWSER_URL
   || process.env.CAMO_BROWSER_HTTP_URL
-  || process.env.CAMO_BROWSER_HOST
+  || (process.env.CAMO_BROWSER_HOST ? `http://${process.env.CAMO_BROWSER_HOST}` : '')
   || 'http://127.0.0.1:7704';
 
 export function ensureDir(p) {