@weavetab/mcp 2.5.0-beta.0

package/dist/tools/type_secret.d.ts

@@ -0,0 +1,23 @@
+/**
+ * Weavetab — tools/type_secret.ts
+ * browser_type_secret: Securely injects a stored credential into a page input.
+ *
+ * Security model:
+ *   - Secret value is resolved from JsonSecretStore (never process.env).
+ *   - Domain enforcement: hard-fails if the current tab's hostname is not in the
+ *     key's allowed domain list. This is the primary prompt-injection defense.
+ *   - Value travels in-process only: secretStore → CDP Input.insertText.
+ *     It is never returned in any tool_result, never logged, never trailed.
+ *   - The DOM node is marked data-wt-secret so all subsequent read tools
+ *     (browser_map, browser_scrape, browser_snapshot, delta) redact it.
+ *   - Trail log records: key name + domain only, never value.
+ *
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export declare function weaveTypeSecret(session: CDP.Client, args: {
+    id?: string;
+    target?: string;
+    envKey: string;
+}, config: Config): Promise<any>;

package/dist/tools/type_secret.js

@@ -0,0 +1,229 @@
+import { buildActionMap, findAllMatches } from "../cdp/walker.js";
+import { logAction } from "../audit/logger.js";
+import { recordAction } from "../intelligence/trail.js";
+import { SessionSecretTracker, secretStore } from "../security/secrets.js";
+import { sessionRegistry } from "../state/session.js";
+import { getConfigAgentId } from "../config/loader.js";
+import { sendToExtension } from "../cdp/helpers.js";
+import { cacheActionMap, getCachedActionMap } from "../state/cache.js";
+export async function weaveTypeSecret(session, args, config) {
+    const startTime = Date.now();
+    let targetId = "default";
+    const active = sessionRegistry.getActive(getConfigAgentId(config));
+    if (active)
+        targetId = active.targetId;
+    // ── Step 1: Resolve current tab domain ───────────────────────────────────
+    const { Page } = session;
+    const { frameTree } = await Page.getFrameTree();
+    const url = frameTree.frame.url;
+    let currentHostname;
+    try {
+        currentHostname = new URL(url).hostname;
+    }
+    catch {
+        return {
+            success: false,
+            error_code: "INVALID_URL",
+            message: `[!] Cannot determine current tab domain from URL: "${url}"`,
+        };
+    }
+    // ── Step 2: Domain enforcement (prompt-injection defense) ─────────────────
+    // This check is done BEFORE resolving the secret value.
+    const allowedDomains = secretStore.getDomains(args.envKey);
+    if (allowedDomains === null) {
+        return {
+            success: false,
+            error_code: "SECRET_NOT_FOUND",
+            message: `[!] Secret not found for key: "${args.envKey}". Run: Weavetab secrets set ${args.envKey}`,
+        };
+    }
+    const domainAllowed = secretStore.checkDomain(args.envKey, currentHostname);
+    if (!domainAllowed) {
+        // Fail BEFORE touching the secret value — the value is never loaded.
+        return {
+            success: false,
+            error_code: "DOMAIN_NOT_ALLOWED",
+            message: `[!] Secret "${args.envKey}" is not scoped for domain "${currentHostname}". ` +
+                (allowedDomains.length > 0
+                    ? `Allowed: [${allowedDomains.join(", ")}]. ` +
+                        `To add this domain: Weavetab secrets set ${args.envKey}`
+                    : `The allowed domain list is empty — add domains with: Weavetab secrets set ${args.envKey}`),
+        };
+    }
+    // ── Step 3: Resolve secret value (in-process only from here) ──────────────
+    const secretValue = await secretStore.getSecret(args.envKey);
+    if (secretValue === undefined) {
+        return {
+            success: false,
+            error_code: "SECRET_NOT_FOUND",
+            message: `[!] Secret not found for key: "${args.envKey}"`,
+        };
+    }
+    // ── Step 4: Build / cache action map ──────────────────────────────────────
+    // Use cached map to prevent stale w: refs if the DOM hasn't changed.
+    // The pruner's data-wt-secret guard fires on the element attribute, NOT the
+    // id, so secret fields survive any preceding browser_map({ prune: true }) call.
+    let map = getCachedActionMap(targetId, url);
+    if (!map) {
+        map = await buildActionMap(session, { lite: true }, targetId);
+        cacheActionMap(targetId, map);
+    }
+    const query = args.id || args.target;
+    if (!query) {
+        return { success: false, error_code: "INVALID_ARGS", message: "[!] Must provide id or target" };
+    }
+    let target = map.elements.find(el => el.id === query || el.id.endsWith(query.startsWith("w:") ? query.slice(2) : query));
+    if (!target) {
+        const matches = findAllMatches(map.elements, query);
+        if (matches.length === 0) {
+            return {
+                success: false,
+                error_code: "ELEMENT_NOT_FOUND",
+                message: `[!] Could not find input matching "${query}"`,
+            };
+        }
+        if (matches.length > 1) {
+            return {
+                success: false,
+                error_code: "MULTIPLE_ELEMENTS_FOUND",
+                message: `[!] Refusing to guess: found ${matches.length} matches for "${query}". Please use a more specific selector.`,
+            };
+        }
+        target = matches[0];
+    }
+    const selector = target.selector || `[data-wt-id="${target.id}"]`;
+    await sendToExtension(session, { type: 'Weavetab_STATE', hud: { action: `injecting [REDACTED]...` } });
+    // ── Step 5: Resolve DOM node, mark as secret, focus ───────────────────────
+    const nodeInfo = await session.Runtime.evaluate({
+        expression: `(function(sel) {
+      const el = document.querySelector(sel) || (window.__Weavetab_shadowQuery ? window.__Weavetab_shadowQuery(sel) : null);
+      if (!el) throw new Error('NOT_FOUND');
+      
+      const tag = el.tagName.toLowerCase();
+      const isEditable = tag === 'input' || tag === 'textarea' || el.isContentEditable;
+      if (!isEditable) throw new Error('NOT_EDITABLE');
+
+      // Mark as secret so all subsequent read tools redact this element
+      el.setAttribute('data-wt-secret', 'true');
+      if (typeof el.select === 'function') { el.select(); }
+      else if (el.isContentEditable) { el.textContent = ''; el.dispatchEvent(new Event('input',{bubbles:true})); }
+      else { el.value = ''; el.dispatchEvent(new Event('input',{bubbles:true})); }
+      
+      return el;
+    })(${JSON.stringify(selector)})`,
+        returnByValue: false
+    });
+    if (nodeInfo.exceptionDetails) {
+        const errMsg = nodeInfo.exceptionDetails.exception?.description || "";
+        if (errMsg.includes('NOT_EDITABLE')) {
+            return { success: false, error_code: "NOT_EDITABLE", message: `[!] Target ${selector} is not an editable field.` };
+        }
+        if (errMsg.includes('NOT_FOUND')) {
+            return { success: false, error_code: "ELEMENT_NOT_FOUND", message: `[!] Could not find element ${selector}.` };
+        }
+        return { success: false, error_code: "DOM_EVAL_FAILED", message: `[!] Evaluation failed while resolving target.` };
+    }
+    if (!nodeInfo.result?.objectId) {
+        return { success: false, error_code: "DOM_RESOLUTION_FAILED", message: `[!] Failed to resolve DOM node for ${selector}` };
+    }
+    // Request node to get backendNodeId for SessionSecretTracker
+    const nodeDetails = await session.DOM.requestNode({ objectId: nodeInfo.result.objectId });
+    if (nodeDetails.nodeId) {
+        const desc = await session.DOM.describeNode({ nodeId: nodeDetails.nodeId });
+        if (desc.node.backendNodeId) {
+            SessionSecretTracker.markNodeAsSecret(targetId, desc.node.backendNodeId);
+        }
+    }
+    // ── Step 6: Focus element ─────────────────────────────────────────────────
+    await session.Runtime.callFunctionOn({
+        functionDeclaration: `function() {
+      if (this.scrollIntoViewIfNeeded) this.scrollIntoViewIfNeeded();
+      else this.scrollIntoView({behavior:'smooth',block:'center'});
+      this.focus();
+      this.click();
+    }`,
+        objectId: nodeInfo.result.objectId,
+        silent: true
+    });
+    // ── Step 7: Inject secret via CDP insertText ───────────────────────────────
+    // This is the ONLY point where secretValue is used.
+    // It goes directly to CDP — never into any variable that could be returned.
+    SessionSecretTracker.registerSecretValue(targetId, secretValue);
+    await session.Input.insertText({ text: secretValue });
+    // ── Step 7.5: Hardened Proxy & Shadow DOM Isolation ───────────────────────
+    await session.Runtime.callFunctionOn({
+        functionDeclaration: `function() {
+      try {
+        const el = this;
+        // 1. Redact direct .value access
+        const proto = Object.getPrototypeOf(el);
+        const origDesc = Object.getOwnPropertyDescriptor(proto, 'value');
+        if (origDesc) {
+          Object.defineProperty(el, 'value', {
+            get: function() { return '[REDACTED]'; },
+            set: origDesc.set,
+            configurable: false,
+            enumerable: true
+          });
+        }
+        
+        // 2. Defeat array spread, iteration, and coercion
+        Object.defineProperty(el, Symbol.iterator, {
+          value: function* () { yield '[REDACTED]'; },
+          configurable: false
+        });
+        Object.defineProperty(el, Symbol.toPrimitive, {
+          value: function() { return '[REDACTED]'; },
+          configurable: false
+        });
+        // 2b. Defeat JSON.stringify and structuredClone data leaks
+        Object.defineProperty(el, 'toJSON', {
+          value: function() { return '[REDACTED]'; },
+          configurable: false
+        });
+        
+        // 3. Isolate in closed shadow DOM to prevent outer-world DOM traversal
+        if (el.parentNode && !el.parentNode.shadowRoot) {
+          const wrapper = document.createElement('div');
+          wrapper.className = '__wt_secret_vault';
+          // copy styles so layout doesn't break
+          const compStyle = window.getComputedStyle(el);
+          wrapper.style.display = compStyle.display === 'inline' ? 'inline-block' : compStyle.display;
+          wrapper.style.width = compStyle.width;
+          wrapper.style.height = compStyle.height;
+          
+          el.parentNode.insertBefore(wrapper, el);
+          const shadow = wrapper.attachShadow({ mode: 'closed' });
+          shadow.appendChild(el);
+        }
+      } catch (e) {
+        // fail silently so as not to disrupt the page execution
+      }
+    }`,
+        objectId: nodeInfo.result.objectId,
+        silent: true
+    });
+    // Immediately zero out the local binding after use
+    // (TypeScript doesn't guarantee this but it signals intent to reviewers)
+    // secretValue = undefined; // can't reassign const — variable goes out of scope here
+    const executionMs = Date.now() - startTime;
+    // ── Step 8: Trail — key name + domain only, NEVER value ──────────────────
+    const finalRef = target.id.startsWith('w:') ? target.id : `w:${target.id}`;
+    logAction("browser_type_secret", finalRef, `[secret injected: ${args.envKey}@${currentHostname}] into ${target.label} (exec: ${executionMs}ms)`);
+    recordAction({
+        timestamp: new Date().toISOString(),
+        tool: "browser_type_secret",
+        // input contains key name and domain ONLY — value is excluded intentionally
+        input: { ref: finalRef, label: target.label, envKey: args.envKey, domain: currentHostname },
+        result: { success: true },
+    });
+    // ── Step 9: Return — no secret value in result ────────────────────────────
+    return {
+        success: true,
+        typed_into: target.label,
+        ref: finalRef,
+        key: args.envKey,
+        domain: currentHostname,
+        execution_ms: executionMs,
+    };
+}

package/dist/tools/upload.d.ts

@@ -0,0 +1,19 @@
+/**
+ * Weavetab — tools/upload.ts
+ * browser_upload: inject file paths into <input type="file"> elements without OS dialog.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface UploadOptions {
+    nodeId?: number;
+    ref?: string;
+    selector?: string;
+    label?: string;
+    filePaths: string[];
+}
+export declare function browserUpload(session: CDP.Client, options: UploadOptions, config: Config): Promise<{
+    success: boolean;
+    message: string;
+    file: string;
+}>;

package/dist/tools/upload.js

@@ -0,0 +1,103 @@
+import { getConfigAgentId } from "../config/loader.js";
+import * as fs from "node:fs";
+import path from "node:path";
+export async function browserUpload(session, options, config) {
+    const { nodeId, ref, selector, label, filePaths } = options;
+    if (!filePaths || filePaths.length === 0) {
+        throw new Error("browser_upload requires an array of filePaths");
+    }
+    // Verify files exist locally
+    for (const p of filePaths) {
+        if (!fs.existsSync(p)) {
+            return { success: false, message: `File not found: ${p}`, file: p };
+        }
+    }
+    let targetNodeId = nodeId;
+    let finalSelector = selector;
+    // Add ref resolution (e.g. "w:42") — works like other tools
+    const resolveRef = ref || selector || label;
+    let fallbackObjectId;
+    if (!targetNodeId && resolveRef) {
+        const { buildActionMap } = await import("../cdp/walker.js");
+        const { sessionRegistry } = await import("../state/session.js");
+        const targetId = sessionRegistry.getActive(getConfigAgentId(config))?.targetId ?? "default";
+        const map = await buildActionMap(session, { lite: true }, targetId);
+        const element = ref
+            ? map.elements.find(el => el.id === ref || el.id.endsWith(ref.startsWith('w:') ? ref.slice(2) : ref))
+            : selector
+                ? map.elements.find(el => el.id === selector || el.selector === selector)
+                : map.elements.find(el => el.label === label);
+        if (!element) {
+            // ENTERPRISE FIX #7: Fallback to full DOM query for hidden file inputs pruned by lite: true
+            try {
+                const query = selector
+                    ? `(document.querySelector(${JSON.stringify(selector)}) || (window.__Weavetab_shadowQuery ? window.__Weavetab_shadowQuery(${JSON.stringify(selector)}) : null))`
+                    : `(document.querySelector('input[type="file"]') || (window.__Weavetab_shadowQuery ? window.__Weavetab_shadowQuery('input[type="file"]') : document.querySelectorAll('input[type="file"]')[0]))`;
+                const res = await session.Runtime.evaluate({
+                    expression: query,
+                    returnByValue: false
+                });
+                if (res.result && res.result.objectId && res.result.subtype === 'node') {
+                    fallbackObjectId = res.result.objectId;
+                    finalSelector = selector || 'input[type="file"]';
+                }
+            }
+            catch (e) {
+                // ignore fallback errors
+            }
+            if (!fallbackObjectId) {
+                throw new Error(`Upload input not found matching "${resolveRef}" — use browser_map to see available elements with their ref IDs, or provide a CSS selector`);
+            }
+        }
+        else {
+            targetNodeId = element.backendNodeId;
+            finalSelector = element.selector;
+        }
+    }
+    if (!targetNodeId && !fallbackObjectId) {
+        throw new Error("browser_upload requires ref, selector, or label (nodeId is also accepted but prefer ref from browser_map)");
+    }
+    try {
+        if (fallbackObjectId) {
+            await session.DOM.setFileInputFiles({
+                objectId: fallbackObjectId,
+                files: filePaths
+            });
+        }
+        else if (targetNodeId) {
+            const { nodeIds } = await session.DOM.pushNodesByBackendIdsToFrontend({ backendNodeIds: [targetNodeId] });
+            if (!nodeIds[0])
+                throw new Error("Node not found in DOM");
+            await session.DOM.setFileInputFiles({
+                nodeId: nodeIds[0],
+                files: filePaths
+            });
+        }
+        else {
+            throw new Error("No target resolved for upload");
+        }
+        // Verify upload registered via JS
+        let uploaded = false;
+        if (finalSelector) {
+            const res = await session.Runtime.evaluate({
+                expression: `(function(sel) {
+          const el = document.querySelector(sel) || (window.__Weavetab_shadowQuery ? window.__Weavetab_shadowQuery(sel) : null);
+          return el?.files?.length > 0;
+        })(${JSON.stringify(finalSelector)})`,
+                returnByValue: true
+            }).catch(() => null);
+            uploaded = res?.result?.value === true;
+        }
+        else {
+            uploaded = true; // Cannot verify without selector
+        }
+        return {
+            success: uploaded,
+            message: `Successfully attached ${filePaths.length} file(s)`,
+            file: path.basename(filePaths[0])
+        };
+    }
+    catch (error) {
+        throw new Error(`Failed to upload: ${error}`);
+    }
+}

package/dist/tools/video_compiler.d.ts

@@ -0,0 +1,24 @@
+export interface CompileVideoOptions {
+    recordingDir: string;
+    fps: number;
+    format?: "webp" | "gif" | "webm" | "mp4" | "frames";
+    keepFrames?: boolean;
+}
+export interface CompileVideoResult {
+    success: boolean;
+    videoPath?: string;
+    format?: string;
+    durationSeconds?: number;
+    fileSizeBytes?: number;
+    cleanedFrames?: boolean;
+    error?: string;
+    compilerUsed?: string;
+}
+/**
+ * Checks if ffmpeg is available on the system PATH.
+ */
+export declare function isFFmpegAvailable(): boolean;
+/**
+ * Compiles JPEG frames in a directory into a video/animation file.
+ */
+export declare function compileVideo(options: CompileVideoOptions): Promise<CompileVideoResult>;

package/dist/tools/video_compiler.js

@@ -0,0 +1,199 @@
+/**
+ * Weavetab — tools/video_compiler.ts
+ * Assembles screencast JPEG frames into video/animation files (.webp, .gif, .webm, .mp4).
+ * Uses native sharp (built-in Node dependency) for WebP/GIF animations without external setup.
+ * Falls back to ffmpeg if installed for .mp4/.webm video encoding.
+ * Weavetab by fy2ne
+ */
+import { exec, execSync } from "node:child_process";
+import * as fs from "node:fs";
+import * as path from "node:path";
+/**
+ * Checks if ffmpeg is available on the system PATH.
+ */
+export function isFFmpegAvailable() {
+    try {
+        const cmd = process.platform === "win32" ? "where ffmpeg" : "which ffmpeg";
+        execSync(cmd, { stdio: "ignore" });
+        return true;
+    }
+    catch {
+        return false;
+    }
+}
+/**
+ * Compiles JPEG frames in a directory into a video/animation file.
+ */
+export async function compileVideo(options) {
+    const { recordingDir, fps = 3, format = "webp", keepFrames = false } = options;
+    if (format === "frames") {
+        return {
+            success: true,
+            cleanedFrames: false,
+            compilerUsed: "raw_frames",
+        };
+    }
+    if (!fs.existsSync(recordingDir)) {
+        return { success: false, error: `Recording directory not found: ${recordingDir}` };
+    }
+    const files = fs.readdirSync(recordingDir).filter(f => f.startsWith("frame-") && f.endsWith(".jpg")).sort();
+    if (files.length === 0) {
+        return { success: false, error: "No image frames found in recording directory" };
+    }
+    const durationSeconds = Math.round((files.length / fps) * 10) / 10;
+    const delayMs = Math.round(1000 / Math.max(1, fps));
+    // Try pure JS sharp compilation first for webp / gif (zero system dependencies required)
+    if (format === "webp" || format === "gif") {
+        try {
+            const sharp = (await import("sharp")).default;
+            // Load first frame metadata to determine dimensions
+            const firstFramePath = path.join(recordingDir, files[0]);
+            const meta = await sharp(firstFramePath).metadata();
+            const width = meta.width || 1280;
+            const height = meta.height || 720;
+            // Limit batch size if too large to prevent out-of-memory
+            const batchFiles = files.slice(0, 300);
+            // Create composite list vertically stacked
+            const compositeList = await Promise.all(batchFiles.map(async (filename, index) => ({
+                input: path.join(recordingDir, filename),
+                top: index * height,
+                left: 0,
+            })));
+            const canvasBuffer = await sharp({
+                create: {
+                    width,
+                    height: height * batchFiles.length,
+                    channels: 3,
+                    background: { r: 0, g: 0, b: 0 },
+                },
+            })
+                .composite(compositeList)
+                .png()
+                .toBuffer();
+            const outputFileName = `recording.${format}`;
+            const videoPath = path.join(recordingDir, outputFileName);
+            let videoBuffer;
+            if (format === "gif") {
+                videoBuffer = await sharp(canvasBuffer, { pageHeight: height })
+                    .gif({ delay: delayMs })
+                    .toBuffer();
+            }
+            else {
+                videoBuffer = await sharp(canvasBuffer, { pageHeight: height })
+                    .webp({ loop: 0, delay: delayMs, quality: 80 })
+                    .toBuffer();
+            }
+            fs.writeFileSync(videoPath, videoBuffer);
+            const fileSizeBytes = videoBuffer.length;
+            // Clean up raw frames if keepFrames is false
+            let cleaned = false;
+            if (!keepFrames) {
+                for (const f of files) {
+                    try {
+                        fs.unlinkSync(path.join(recordingDir, f));
+                    }
+                    catch { }
+                }
+                cleaned = true;
+            }
+            return {
+                success: true,
+                videoPath,
+                format,
+                durationSeconds,
+                fileSizeBytes,
+                cleanedFrames: cleaned,
+                compilerUsed: "sharp_pure_node",
+            };
+        }
+        catch (sharpErr) {
+            // Fall through to ffmpeg or manifest fallback if sharp fails
+        }
+    }
+    // Check if FFmpeg is available for webm / mp4 or fallback
+    const ffmpegPresent = isFFmpegAvailable();
+    if (ffmpegPresent) {
+        try {
+            const outputFileName = `recording.${format === "webp" || format === "gif" ? format : format}`;
+            const videoPath = path.join(recordingDir, outputFileName);
+            await new Promise((resolve, reject) => {
+                const concatFilePath = path.join(recordingDir, "concat.txt");
+                const concatContent = files.map(f => `file '${f.replace(/'/g, "'\\''")}'\nduration ${1 / fps}`).join("\n");
+                fs.writeFileSync(concatFilePath, concatContent);
+                let codecFlags = "";
+                if (format === "webm") {
+                    codecFlags = "-c:v libvpx-vp9 -pix_fmt yuv420p -b:v 1M";
+                }
+                else if (format === "mp4") {
+                    codecFlags = "-c:v libx264 -pix_fmt yuv420p -vf \"trunc(iw/2)*2:trunc(ih/2)*2\"";
+                }
+                else if (format === "gif") {
+                    codecFlags = `-vf "fps=${fps},scale=640:-1:flags=lanczos"`;
+                }
+                else {
+                    codecFlags = "-c:v libvpx-vp9 -pix_fmt yuv420p -b:v 1M";
+                }
+                const cmd = `ffmpeg -y -f concat -safe 0 -i "${concatFilePath}" ${codecFlags} "${videoPath}"`;
+                exec(cmd, { cwd: recordingDir }, (error) => {
+                    try {
+                        fs.unlinkSync(concatFilePath);
+                    }
+                    catch { }
+                    if (error)
+                        reject(error);
+                    else
+                        resolve();
+                });
+            });
+            let fileSizeBytes = 0;
+            if (fs.existsSync(videoPath)) {
+                fileSizeBytes = fs.statSync(videoPath).size;
+            }
+            let cleaned = false;
+            if (!keepFrames) {
+                for (const f of files) {
+                    try {
+                        fs.unlinkSync(path.join(recordingDir, f));
+                    }
+                    catch { }
+                }
+                cleaned = true;
+            }
+            return {
+                success: true,
+                videoPath,
+                format,
+                durationSeconds,
+                fileSizeBytes,
+                cleanedFrames: cleaned,
+                compilerUsed: "ffmpeg_system",
+            };
+        }
+        catch (err) {
+            return {
+                success: false,
+                error: `FFmpeg compilation failed: ${err.message}`,
+                compilerUsed: "ffmpeg_system",
+            };
+        }
+    }
+    // Final fallback: recording manifest
+    const manifestPath = path.join(recordingDir, "recording_manifest.json");
+    const manifestData = {
+        fps,
+        frameCount: files.length,
+        durationSeconds,
+        formatRequested: format,
+        frames: files,
+        createdAt: new Date().toISOString(),
+    };
+    fs.writeFileSync(manifestPath, JSON.stringify(manifestData, null, 2));
+    return {
+        success: true,
+        videoPath: manifestPath,
+        format: "manifest",
+        durationSeconds,
+        cleanedFrames: false,
+        compilerUsed: "manifest_fallback",
+    };
+}

package/dist/tools/viewport.d.ts

@@ -0,0 +1,44 @@
+/**
+ * Weavetab — tools/viewport.ts
+ * browser_viewport: Enhanced viewport emulation with device presets, mobile support,
+ * geolocation, locale, timezone, and advanced features to surpass Playwright.
+ * Weavetab by fy2ne
+ */
+import CDP from "chrome-remote-interface";
+import type { Config } from "../config/loader.js";
+export interface ViewportOptions {
+    width?: number;
+    height?: number;
+    deviceScaleFactor?: number;
+    mobile?: boolean;
+    action: "set" | "clear" | "list" | "preset";
+    devicePreset?: string;
+    userAgent?: string;
+    geolocation?: {
+        latitude: number;
+        longitude: number;
+        accuracy?: number;
+    };
+    locale?: string;
+    timezoneId?: string;
+    colorScheme?: 'light' | 'dark' | 'no-preference';
+    hasTouch?: boolean;
+    screenOrientation?: 'portrait' | 'landscape' | 'none';
+}
+export interface DevicePreset {
+    userAgent: string;
+    viewport: {
+        width: number;
+        height: number;
+    };
+    deviceScaleFactor: number;
+    mobile: boolean;
+    hasTouch: boolean;
+    screenOrientation?: 'portrait' | 'landscape';
+}
+export declare const DEVICE_PRESETS: Record<string, DevicePreset>;
+export declare function browserViewport(session: CDP.Client, options: ViewportOptions, _config: Config): Promise<{
+    success: boolean;
+    message: string;
+    data?: any;
+}>;