@web-auto/webauto 0.1.18 → 0.1.19

package/bin/webauto.mjs

@@ -163,6 +163,7 @@ Core Commands:
   webauto schedule <list|get|add|update|delete|import|export|run|run-due|daemon> [options]
   webauto deps <check|auto|install|uninstall|reinstall> [options]
   webauto ui console [--build] [--install] [--check]
+  webauto ui restart [--build] [--install] [--timeout <ms>] [--reason <text>]
   webauto ui cli <action> [options]
   webauto xhs install [--download-browser] [--download-geoip] [--ensure-backend]
   webauto xhs unified [xhs options...]
@@ -193,6 +194,7 @@ Examples (standard):
   webauto ui console --check
   webauto ui console --build
   webauto ui console --install
+  webauto ui restart --build --reason "reload-after-pull"
   webauto ui cli start --build
   webauto ui cli tab --tab 配置
   webauto ui cli input --selector "#keyword-input" --value "seedance2.0"
@@ -214,6 +216,7 @@ function printUiConsoleHelp() {
 
 Usage:
   webauto ui console [--build] [--install] [--check] [--no-daemon]
+  webauto ui restart [--build] [--install] [--timeout <ms>] [--reason <text>]
   webauto ui cli <action> [options]
 
 Options:
@@ -224,6 +227,7 @@ Options:
 
 CLI Actions:
   start         启动 UI（可配合 --build/--install）
+  restart       广播重启消息，应用自停并自启（可配合 --reason）
   status        获取 UI 运行状态（含 runId/错误计数）
   snapshot      获取 UI 快照（含当前 tab 与关键控件值）
   tab           切换 tab（--tab config 或 --label 配置）
@@ -250,6 +254,7 @@ Examples:
   webauto ui console --check
   webauto ui console --build
   webauto ui console --install
+  webauto ui restart --reason "git pull"
   webauto ui cli start --build
   webauto ui cli status --json
   webauto ui cli tab --tab 配置
@@ -485,11 +490,14 @@ async function runInDir(dir, cmd, args) {
 }
 
 function checkDesktopConsoleDeps() {
-  const electronName = process.platform === 'win32' ? 'electron.exe' : 'electron';
-  const candidates = [
-    path.join(ROOT, 'node_modules', 'electron', 'dist', electronName),
-    path.join(ROOT, 'apps', 'desktop-console', 'node_modules', 'electron', 'dist', electronName),
+  const electronNames = process.platform === 'win32'
+    ? ['electron.exe']
+    : (process.platform === 'darwin' ? ['electron', path.join('Electron.app', 'Contents', 'MacOS', 'Electron')] : ['electron']);
+  const roots = [
+    path.join(ROOT, 'node_modules', 'electron', 'dist'),
+    path.join(ROOT, 'apps', 'desktop-console', 'node_modules', 'electron', 'dist'),
   ];
+  const candidates = roots.flatMap((base) => electronNames.map((name) => path.join(base, name)));
   return candidates.some((p) => exists(p));
 }
 
@@ -775,6 +783,16 @@ async function main() {
     return;
   }
 
+  if (cmd === 'ui' && sub === 'restart') {
+    await ensureUiRuntimeReady({
+      build: args.build === true,
+      install: args.install === true,
+    });
+    const script = path.join(ROOT, 'apps', 'desktop-console', 'entry', 'ui-cli.mjs');
+    await run(process.execPath, [script, 'restart', ...rawArgv.slice(2)]);
+    return;
+  }
+
   if (cmd === 'ui' && sub === 'cli') {
     await ensureUiRuntimeReady({
       build: args.build === true,

package/dist/modules/camo-backend/src/index.js

@@ -17,6 +17,12 @@ function readNumber(value) {
         return null;
     return parsed;
 }
+function readPositiveNumber(value) {
+    const parsed = Number(value);
+    if (!Number.isFinite(parsed) || parsed <= 0)
+        return null;
+    return parsed;
+}
 function getDisplayMetrics() {
     const envWidth = readNumber(process.env.WEBAUTO_SCREEN_WIDTH);
     const envHeight = readNumber(process.env.WEBAUTO_SCREEN_HEIGHT);
@@ -120,6 +126,31 @@ function getDisplayMetrics() {
         return null;
     }
 }
+function resolveStartViewport(args) {
+    const explicitWidth = readPositiveNumber(args?.width ?? args?.viewportWidth ?? args?.viewport?.width);
+    const explicitHeight = readPositiveNumber(args?.height ?? args?.viewportHeight ?? args?.viewport?.height);
+    if (explicitWidth && explicitHeight) {
+        return {
+            width: Math.floor(explicitWidth),
+            height: Math.floor(explicitHeight),
+        };
+    }
+    if (Boolean(args?.headless))
+        return null;
+    const display = getDisplayMetrics();
+    if (!display)
+        return null;
+    const reserveRaw = Number(process.env.WEBAUTO_WINDOW_VERTICAL_RESERVE ?? 0);
+    const reserve = Number.isFinite(reserveRaw) ? Math.max(0, Math.min(240, Math.floor(reserveRaw))) : 0;
+    const baseWidth = readPositiveNumber(display.workWidth) || readPositiveNumber(display.width);
+    const baseHeight = readPositiveNumber(display.workHeight) || readPositiveNumber(display.height);
+    if (!baseWidth || !baseHeight)
+        return null;
+    return {
+        width: Math.max(960, Math.floor(baseWidth)),
+        height: Math.max(700, Math.floor(baseHeight - reserve)),
+    };
+}
 export async function startBrowserService(opts = {}) {
     const { logEvent } = installServiceProcessLogger({ serviceName: 'browser-service' });
     const host = opts.host || '127.0.0.1';
@@ -260,6 +291,7 @@ async function handleCommand(payload, manager, wsServer, options = {}) {
     const args = payload.args ?? payload;
     switch (action) {
         case 'start': {
+            const startViewport = resolveStartViewport(args);
             const opts = {
                 profileId: args.profileId || 'default',
                 sessionName: args.profileId || 'default',
@@ -267,6 +299,7 @@ async function handleCommand(payload, manager, wsServer, options = {}) {
                 initialUrl: args.url,
                 engine: args.engine || 'camoufox',
                 fingerprintPlatform: args.fingerprintPlatform || null,
+                ...(startViewport ? { viewport: startViewport } : {}),
                 ...(args.ownerPid ? { ownerPid: args.ownerPid } : {}),
             };
             const res = await manager.createSession(opts);

package/dist/modules/camo-backend/src/internal/BrowserSession.js

@@ -10,6 +10,32 @@ import { loadOrGenerateFingerprint, applyFingerprint } from './fingerprint.js';
 import { launchEngineContext } from './engine-manager.js';
 import { resolveCookiesRoot, resolveProfilesRoot, resolveRecordsRoot } from './storage-paths.js';
 const stateBus = getStateBus();
+function resolveInputActionTimeoutMs() {
+    const raw = Number(process.env.CAMO_INPUT_ACTION_TIMEOUT_MS ?? process.env.CAMO_API_TIMEOUT_MS ?? 30000);
+    return Math.max(1000, Number.isFinite(raw) ? raw : 30000);
+}
+function resolveNavigationWaitUntil() {
+    const raw = String(process.env.CAMO_NAV_WAIT_UNTIL ?? 'commit').trim().toLowerCase();
+    if (raw === 'load')
+        return 'load';
+    if (raw === 'domcontentloaded' || raw === 'dom')
+        return 'domcontentloaded';
+    if (raw === 'networkidle')
+        return 'networkidle';
+    return 'commit';
+}
+function resolveInputActionMaxAttempts() {
+    const raw = Number(process.env.CAMO_INPUT_ACTION_MAX_ATTEMPTS ?? 2);
+    return Math.max(1, Math.min(3, Number.isFinite(raw) ? Math.floor(raw) : 2));
+}
+function resolveInputRecoveryDelayMs() {
+    const raw = Number(process.env.CAMO_INPUT_RECOVERY_DELAY_MS ?? 120);
+    return Math.max(0, Number.isFinite(raw) ? Math.floor(raw) : 120);
+}
+function resolveInputRecoveryBringToFrontTimeoutMs() {
+    const raw = Number(process.env.CAMO_INPUT_RECOVERY_BRING_TO_FRONT_TIMEOUT_MS ?? 800);
+    return Math.max(100, Number.isFinite(raw) ? Math.floor(raw) : 800);
+}
 export class BrowserSession {
     options;
     browser;
@@ -25,6 +51,8 @@ export class BrowserSession {
     bridgedPages = new WeakSet();
     recorderBridgePages = new WeakSet();
     lastViewport = null;
+    followWindowViewport = false;
+    inputActionTail = Promise.resolve();
     fingerprint = null;
     recordingStream = null;
     recording = {
@@ -86,14 +114,25 @@ export class BrowserSession {
             platform: fingerprint.platform,
             userAgent: fingerprint.userAgent?.substring(0, 50) + '...',
         });
-        const viewport = this.options.viewport || { width: 3840, height: 2046 };
+        const fallbackViewport = { width: 1440, height: 1100 };
+        const explicitViewport = this.options.viewport
+            && Number(this.options.viewport.width) > 0
+            && Number(this.options.viewport.height) > 0
+            ? {
+                width: Math.floor(Number(this.options.viewport.width)),
+                height: Math.floor(Number(this.options.viewport.height)),
+            }
+            : null;
+        const viewport = explicitViewport || fingerprint?.viewport || fallbackViewport;
+        const headless = !!this.options.headless;
+        this.followWindowViewport = !headless;
         const deviceScaleFactor = this.resolveDeviceScaleFactor();
         // 使用 EngineManager 启动上下文（Chromium 已移除，仅支持 Camoufox）
         this.context = await launchEngineContext({
             engine,
-            headless: !!this.options.headless,
+            headless,
             profileDir: this.profileDir,
-            viewport: fingerprint?.viewport || viewport,
+            viewport,
             userAgent: fingerprint?.userAgent,
             locale: 'zh-CN',
             timezoneId: fingerprint?.timezoneId || 'Asia/Shanghai',
@@ -101,7 +140,9 @@ export class BrowserSession {
         // 应用指纹到上下文（Playwright JS 注入）
         await applyFingerprint(this.context, fingerprint);
         // NOTE: deviceScaleFactor override was Chromium-only (CDP). Chromium removed.
-        this.lastViewport = { width: viewport.width, height: viewport.height };
+        this.lastViewport = this.followWindowViewport
+            ? null
+            : { width: viewport.width, height: viewport.height };
         this.browser = this.context.browser();
         this.browser.on('disconnected', () => this.notifyExit());
         this.context.on('close', () => this.notifyExit());
@@ -109,6 +150,9 @@ export class BrowserSession {
         this.page = existing.length ? existing[0] : await this.context.newPage();
         this.setupPageHooks(this.page);
         this.context.on('page', (p) => this.setupPageHooks(p));
+        if (this.followWindowViewport) {
+            await this.refreshViewportFromWindow(this.page).catch(() => { });
+        }
         if (initialUrl) {
             await this.goto(initialUrl);
         }
@@ -782,6 +826,10 @@ export class BrowserSession {
         }
     }
     async ensurePageViewport(page) {
+        if (this.followWindowViewport) {
+            await this.refreshViewportFromWindow(page).catch(() => { });
+            return;
+        }
         if (!this.lastViewport)
             return;
         const current = page.viewportSize();
@@ -795,6 +843,33 @@ export class BrowserSession {
         await this.syncWindowBounds(page, { ...this.lastViewport });
         await this.syncDeviceScaleFactor(page, { ...this.lastViewport });
     }
+    async readWindowInnerSize(page) {
+        try {
+            const metrics = await page.evaluate(() => ({
+                width: Math.floor(Number(window.innerWidth || 0)),
+                height: Math.floor(Number(window.innerHeight || 0)),
+            }));
+            const width = Number(metrics?.width);
+            const height = Number(metrics?.height);
+            if (!Number.isFinite(width) || !Number.isFinite(height))
+                return null;
+            if (width < 300 || height < 200)
+                return null;
+            return { width, height };
+        }
+        catch {
+            return null;
+        }
+    }
+    async refreshViewportFromWindow(page) {
+        const inner = await this.readWindowInnerSize(page);
+        if (!inner)
+            return;
+        this.lastViewport = {
+            width: Math.max(800, Math.floor(inner.width)),
+            height: Math.max(700, Math.floor(inner.height)),
+        };
+    }
     ensureContext() {
         if (!this.context) {
             throw new Error('browser context not ready');
@@ -805,6 +880,12 @@ export class BrowserSession {
         const ctx = this.ensureContext();
         const existing = this.getActivePage();
         if (existing) {
+            try {
+                await this.ensurePageViewport(existing);
+            }
+            catch {
+                /* ignore */
+            }
             return existing;
         }
         this.page = await ctx.newPage();
@@ -830,9 +911,10 @@ export class BrowserSession {
     }
     async goBack() {
         const page = await this.ensurePrimaryPage();
+        const waitUntil = resolveNavigationWaitUntil();
         try {
             const res = await page
-                .goBack({ waitUntil: 'domcontentloaded' })
+                .goBack({ waitUntil })
                 .catch(() => null);
             await ensurePageRuntime(page, true).catch(() => { });
             this.lastKnownUrl = page.url();
@@ -919,7 +1001,7 @@ export class BrowserSession {
             /* ignore */
         }
         if (url) {
-            await page.goto(url, { waitUntil: 'domcontentloaded' });
+            await page.goto(url, { waitUntil: resolveNavigationWaitUntil() });
             await ensurePageRuntime(page);
             this.lastKnownUrl = url;
         }
@@ -1063,7 +1145,7 @@ export class BrowserSession {
     }
     async goto(url) {
         const page = await this.ensurePrimaryPage();
-        await page.goto(url, { waitUntil: 'domcontentloaded' });
+        await page.goto(url, { waitUntil: resolveNavigationWaitUntil() });
         await ensurePageRuntime(page);
         this.lastKnownUrl = url;
     }
@@ -1071,19 +1153,9 @@ export class BrowserSession {
         const page = await this.ensurePrimaryPage();
         return page.screenshot({ fullPage });
     }
-    async click(selector) {
-        const page = await this.ensurePrimaryPage();
-        await page.click(selector, { timeout: 20000 });
-    }
-    async fill(selector, text) {
-        const page = await this.ensurePrimaryPage();
-        await page.fill(selector, text, { timeout: 20000 });
-    }
     async ensureInputReady(page) {
         if (this.options.headless)
             return;
-        if (os.platform() !== 'win32')
-            return;
         let needsFocus = false;
         try {
             const state = await page.evaluate(() => ({
@@ -1107,28 +1179,118 @@ export class BrowserSession {
             // Keep best-effort behavior and do not block input flow on platform quirks.
         }
     }
+    async withInputActionTimeout(label, run) {
+        const timeoutMs = resolveInputActionTimeoutMs();
+        let timer = null;
+        try {
+            return await Promise.race([
+                run(),
+                new Promise((_resolve, reject) => {
+                    timer = setTimeout(() => {
+                        reject(new Error(`${label} timed out after ${timeoutMs}ms`));
+                    }, timeoutMs);
+                }),
+            ]);
+        }
+        finally {
+            if (timer)
+                clearTimeout(timer);
+        }
+    }
+    async recoverInputPipeline(page) {
+        const bringToFrontTimeoutMs = resolveInputRecoveryBringToFrontTimeoutMs();
+        let bringToFrontTimer = null;
+        try {
+            await Promise.race([
+                page.bringToFront(),
+                new Promise((_resolve, reject) => {
+                    bringToFrontTimer = setTimeout(() => {
+                        reject(new Error(`input recovery bringToFront timed out after ${bringToFrontTimeoutMs}ms`));
+                    }, bringToFrontTimeoutMs);
+                }),
+            ]);
+        }
+        catch {
+            // Best-effort recovery only.
+        }
+        finally {
+            if (bringToFrontTimer)
+                clearTimeout(bringToFrontTimer);
+        }
+        const delayMs = resolveInputRecoveryDelayMs();
+        if (delayMs > 0) {
+            try {
+                await page.waitForTimeout(delayMs);
+            }
+            catch {
+                // Best-effort recovery only.
+            }
+        }
+        return page;
+    }
+    async runInputAction(page, label, run) {
+        const maxAttempts = resolveInputActionMaxAttempts();
+        let lastError = null;
+        let activePage = page;
+        for (let attempt = 1; attempt <= maxAttempts; attempt += 1) {
+            try {
+                return await this.withInputActionTimeout(`${label} (attempt ${attempt}/${maxAttempts})`, () => run(activePage));
+            }
+            catch (error) {
+                lastError = error;
+                if (attempt >= maxAttempts)
+                    break;
+                activePage = await this.recoverInputPipeline(activePage);
+            }
+        }
+        if (lastError instanceof Error)
+            throw lastError;
+        throw new Error(`${label} failed`);
+    }
+    async withInputActionLock(run) {
+        const previous = this.inputActionTail;
+        let release = null;
+        this.inputActionTail = new Promise((resolve) => {
+            release = resolve;
+        });
+        await previous.catch(() => { });
+        try {
+            return await run();
+        }
+        finally {
+            if (release)
+                release();
+        }
+    }
     /**
      * 基于屏幕坐标的系统级鼠标点击（Playwright 原生）
      * @param opts 屏幕坐标及点击选项
      */
     async mouseClick(opts) {
         const page = await this.ensurePrimaryPage();
-        await this.ensureInputReady(page);
-        const { x, y, button = 'left', clicks = 1, delay = 50 } = opts;
-        // 移动鼠标到目标位置（模拟轨迹）
-        await page.mouse.move(x, y, { steps: 3 });
-        // 执行点击（支持多次、间隔随机抖动）
-        for (let i = 0; i < clicks; i++) {
-            if (i > 0) {
-                // 多次点击间隔 100-200ms
-                await new Promise(r => setTimeout(r, 100 + Math.random() * 100));
+        await this.withInputActionLock(async () => {
+            await this.runInputAction(page, 'input:ready', (activePage) => this.ensureInputReady(activePage));
+            const { x, y, button = 'left', clicks = 1, delay = 50 } = opts;
+            // Avoid page.mouse.click() composite hangs by using explicit down/up sequence.
+            for (let i = 0; i < clicks; i++) {
+                if (i > 0) {
+                    // 多次点击间隔 100-200ms
+                    await new Promise(r => setTimeout(r, 100 + Math.random() * 100));
+                }
+                await this.runInputAction(page, 'mouse:move(pre-click)', (activePage) => activePage.mouse.move(x, y, { steps: 1 }));
+                await this.runInputAction(page, 'mouse:down', (activePage) => activePage.mouse.down({
+                    button,
+                    clickCount: 1,
+                }));
+                if (delay > 0) {
+                    await page.waitForTimeout(delay);
+                }
+                await this.runInputAction(page, 'mouse:up', (activePage) => activePage.mouse.up({
+                    button,
+                    clickCount: 1,
+                }));
             }
-            await page.mouse.click(x, y, {
-                button,
-                clickCount: 1,
-                delay // 按键间隔
-            });
-        }
+        });
     }
     /**
      * 基于屏幕坐标的鼠标移动（Playwright 原生）
@@ -1136,29 +1298,35 @@ export class BrowserSession {
      */
     async mouseMove(opts) {
         const page = await this.ensurePrimaryPage();
-        await this.ensureInputReady(page);
-        const { x, y, steps = 3 } = opts;
-        await page.mouse.move(x, y, { steps });
+        await this.withInputActionLock(async () => {
+            await this.runInputAction(page, 'input:ready', (activePage) => this.ensureInputReady(activePage));
+            const { x, y, steps = 3 } = opts;
+            await this.runInputAction(page, 'mouse:move', (activePage) => activePage.mouse.move(x, y, { steps }));
+        });
     }
     /**
      * 基于键盘的系统输入（Playwright keyboard）
      */
     async keyboardType(opts) {
         const page = await this.ensurePrimaryPage();
-        await this.ensureInputReady(page);
-        const { text, delay = 80, submit } = opts;
-        if (text && text.length > 0) {
-            await page.keyboard.type(text, { delay });
-        }
-        if (submit) {
-            await page.keyboard.press('Enter');
-        }
+        await this.withInputActionLock(async () => {
+            await this.runInputAction(page, 'input:ready', (activePage) => this.ensureInputReady(activePage));
+            const { text, delay = 80, submit } = opts;
+            if (text && text.length > 0) {
+                await this.runInputAction(page, 'keyboard:type', (activePage) => activePage.keyboard.type(text, { delay }));
+            }
+            if (submit) {
+                await this.runInputAction(page, 'keyboard:press', (activePage) => activePage.keyboard.press('Enter'));
+            }
+        });
     }
     async keyboardPress(opts) {
         const page = await this.ensurePrimaryPage();
-        await this.ensureInputReady(page);
-        const { key, delay } = opts;
-        await page.keyboard.press(key, typeof delay === 'number' ? { delay } : undefined);
+        await this.withInputActionLock(async () => {
+            await this.runInputAction(page, 'input:ready', (activePage) => this.ensureInputReady(activePage));
+            const { key, delay } = opts;
+            await this.runInputAction(page, 'keyboard:press', (activePage) => activePage.keyboard.press(key, typeof delay === 'number' ? { delay } : undefined));
+        });
     }
     /**
      * 基于鼠标滚轮的系统滚动（Playwright mouse.wheel）
@@ -1166,9 +1334,11 @@ export class BrowserSession {
      */
     async mouseWheel(opts) {
         const page = await this.ensurePrimaryPage();
-        await this.ensureInputReady(page);
-        const { deltaX = 0, deltaY } = opts;
-        await page.mouse.wheel(Number(deltaX) || 0, Number(deltaY) || 0);
+        await this.withInputActionLock(async () => {
+            await this.runInputAction(page, 'input:ready', (activePage) => this.ensureInputReady(activePage));
+            const { deltaX = 0, deltaY } = opts;
+            await this.runInputAction(page, 'mouse:wheel', (activePage) => activePage.mouse.wheel(Number(deltaX) || 0, Number(deltaY) || 0));
+        });
     }
     async syncWindowBounds(page, viewport) {
         const engine = String(this.options.engine ?? 'camoufox');
@@ -1286,6 +1456,19 @@ export class BrowserSession {
         if (!width || !height) {
             throw new Error('invalid_viewport_size');
         }
+        if (this.followWindowViewport && !this.options.headless) {
+            await page.evaluate(({ w, h }) => {
+                try {
+                    window.resizeTo(w, h);
+                }
+                catch { }
+            }, { w: width, h: height });
+            await page.waitForTimeout(150);
+            await this.refreshViewportFromWindow(page).catch(() => { });
+            const next = this.lastViewport || { width, height };
+            await this.maybeCenterWindow(page, next).catch(() => { });
+            return next;
+        }
         await page.setViewportSize({ width, height });
         await this.syncWindowBounds(page, { width, height });
         await this.syncDeviceScaleFactor(page, { width, height });

package/dist/modules/camo-backend/src/internal/engine-manager.js

@@ -158,15 +158,13 @@ export async function launchEngineContext(opts) {
         const physicalH = Number(dm?.height || 2304);
         const workW = Number(dm?.workWidth || physicalW || 4096);
         const workH = Number(dm?.workHeight || physicalH || 2190);
-        // Use provided viewport as MAXIMUM (e.g., from fingerprint or explicit opt), default to full work area
-        const maxViewportW = Number(opts.viewport?.width || workW);
-        const maxViewportH = Number(opts.viewport?.height || workH);
-        // Target: fill work area, but don't exceed explicit viewport caps if provided
-        const targetW = maxViewportW > 0 ? Math.min(maxViewportW, workW) : workW;
-        const targetH = maxViewportH > 0 ? Math.min(maxViewportH, workH) : workH;
-        // Use targetW/targetH as viewport (even in headless) to match headful size
-        const viewportW = Math.max(1440, Math.floor(Number(targetW) || 4096));
-        const viewportH = Math.max(900, Math.floor(Number(targetH) || 2190));
+        // Base viewport target:
+        // - prefer explicit/fingerprint viewport if provided
+        // - otherwise use a deterministic default for stable first-run UX
+        const requestedW = Number(opts.viewport?.width || process.env.WEBAUTO_VIEWPORT_WIDTH || 1440);
+        const requestedH = Number(opts.viewport?.height || process.env.WEBAUTO_VIEWPORT_HEIGHT || 1100);
+        const viewportW = Math.max(900, Math.floor(Number(requestedW) || 1440));
+        const viewportH = Math.max(700, Math.floor(Number(requestedH) || 1100));
         const envHeadlessW = Number(process.env.WEBAUTO_HEADLESS_WIDTH || 0);
         const envHeadlessH = Number(process.env.WEBAUTO_HEADLESS_HEIGHT || 0);
         const headlessW = envHeadlessW > 0 ? envHeadlessW : viewportW;
@@ -175,9 +173,12 @@ export async function launchEngineContext(opts) {
             throw new Error('headless viewport invalid');
         }
         const headless = Boolean(opts.headless);
-        // Final window size: maximize to fill work area (leave small margin for chrome/window decorations)
-        const winW = headless ? headlessW : Math.max(1440, Math.floor(workW * 0.95));
-        const winH = headless ? headlessH : Math.max(900, Math.floor(workH - 80));
+        // Final headful window size:
+        // align window with viewport by default and keep it inside available work area.
+        const maxHeadfulW = workW > 0 ? Math.max(900, workW - 40) : 1920;
+        const maxHeadfulH = workH > 0 ? Math.max(700, workH - 80) : 1200;
+        const winW = headless ? headlessW : Math.min(viewportW, maxHeadfulW);
+        const winH = headless ? headlessH : Math.min(viewportH, maxHeadfulH);
         // Ensure integer types for Camoufox
         const screenW = Math.floor(physicalW) | 0;
         const screenH = Math.floor(physicalH) | 0;
@@ -219,7 +220,7 @@ export async function launchEngineContext(opts) {
             headless,
             os: targetOS,
             window: [intWinW, intWinH],
-            viewport: { width: headless ? headlessW : viewportW, height: headless ? headlessH : viewportH },
+            viewport: headless ? { width: headlessW, height: headlessH } : null,
             firefox_user_prefs,
             config,
             data_dir: opts.profileDir,

package/dist/modules/camo-backend/src/internal/ws-server.js

@@ -25,6 +25,18 @@ function appendLog(target, event, payload = {}) {
 }
 const appendDomPickerLog = (event, payload = {}) => appendLog(domPickerLogPath, event, payload);
 const appendHighlightLog = (event, payload = {}) => appendLog(highlightLogPath, event, payload);
+function legacySelectorActionDisabled(source, action) {
+    return {
+        success: false,
+        code: 'LEGACY_ACTION_DISABLED',
+        error: `[${source}] legacy selector action "${action}" is disabled; use mouse:* and keyboard:* protocol actions instead`,
+        data: {
+            source,
+            action,
+            replacements: ['mouse:move', 'mouse:click', 'mouse:wheel', 'keyboard:press', 'keyboard:type'],
+        },
+    };
+}
 export class BrowserWsServer {
     options;
     wss;
@@ -607,10 +619,10 @@ export class BrowserWsServer {
         if (!op)
             throw new Error('operation_type required');
         if (op === 'click') {
-            return this.handleNodeExecute(sessionId, { command_type: 'node_execute', node_type: 'click', parameters: parameters.target || parameters });
+            return legacySelectorActionDisabled('user_action.operation', 'click');
         }
         if (op === 'type') {
-            return this.handleNodeExecute(sessionId, { command_type: 'node_execute', node_type: 'type', parameters: parameters.target || parameters });
+            return legacySelectorActionDisabled('user_action.operation', 'type');
         }
         if (op === 'scroll') {
             const session = this.options.sessionManager.getSession(sessionId);
@@ -902,25 +914,10 @@ export class BrowserWsServer {
                 };
             }
             case 'click': {
-                const selector = parameters.selector;
-                if (!selector)
-                    throw new Error('Click node requires selector');
-                await session.click(selector);
-                return {
-                    success: true,
-                    data: { action: 'clicked', selector },
-                };
+                return legacySelectorActionDisabled('node_execute', 'click');
             }
             case 'type': {
-                const selector = parameters.selector;
-                if (!selector)
-                    throw new Error('Type node requires selector');
-                const text = parameters.text ?? parameters.value ?? '';
-                await session.fill(selector, String(text));
-                return {
-                    success: true,
-                    data: { action: 'typed', selector, text },
-                };
+                return legacySelectorActionDisabled('node_execute', 'type');
             }
             case 'screenshot': {
                 const filename = parameters.filename || `screenshot_${Date.now()}.png`;