browser-use 0.6.1 → 0.7.0

package/dist/skill-cli/direct.js

@@ -6,7 +6,44 @@ import net from 'node:net';
 import { spawn } from 'node:child_process';
 import { BrowserSession, systemChrome } from '../browser/session.js';
 import { CloudBrowserClient } from '../browser/cloud/cloud.js';
-export const DIRECT_STATE_FILE = path.join(os.tmpdir(), 'browser-use-direct.json');
+const getSafeUserSegment = () => {
+    if (typeof process.getuid === 'function') {
+        return String(process.getuid());
+    }
+    try {
+        const username = os.userInfo().username;
+        return username.replace(/[^a-zA-Z0-9_.-]/g, '_') || 'user';
+    }
+    catch {
+        return 'user';
+    }
+};
+const getDefaultDirectStateDir = () => {
+    const runtimeDir = process.env.XDG_RUNTIME_DIR?.trim();
+    if (runtimeDir && path.isAbsolute(runtimeDir)) {
+        return path.join(runtimeDir, 'browser-use');
+    }
+    const homeDir = os.homedir();
+    if (homeDir) {
+        if (process.platform === 'darwin') {
+            return path.join(homeDir, 'Library', 'Application Support', 'browser-use');
+        }
+        if (process.platform === 'win32') {
+            const localAppData = process.env.LOCALAPPDATA?.trim();
+            const baseDir = localAppData && path.isAbsolute(localAppData)
+                ? localAppData
+                : path.join(homeDir, 'AppData', 'Local');
+            return path.join(baseDir, 'browser-use');
+        }
+        const stateHome = process.env.XDG_STATE_HOME?.trim();
+        const baseDir = stateHome && path.isAbsolute(stateHome)
+            ? stateHome
+            : path.join(homeDir, '.local', 'state');
+        return path.join(baseDir, 'browser-use');
+    }
+    return path.join(os.tmpdir(), `browser-use-${getSafeUserSegment()}`);
+};
+export const DIRECT_STATE_FILE = path.join(getDefaultDirectStateDir(), 'direct-state.json');
 const normalizeCookieDomain = (value) => String(value ?? '')
     .trim()
     .replace(/^\./, '')
@@ -23,6 +60,9 @@ const parseCookieHostname = (url) => {
         return '';
     }
 };
+const validateDirectPageAfterAction = async (session, page) => {
+    await session.validate_page_after_action?.(page);
+};
 const parseCookieUrl = (url) => {
     const value = String(url ?? '').trim();
     if (!value) {
@@ -54,9 +94,7 @@ const cookieMatchesUrl = (cookie, url) => {
     if (!hostname || !domain) {
         return false;
     }
-    if (!(hostname === domain ||
-        hostname.endsWith(`.${domain}`) ||
-        domain.endsWith(`.${hostname}`))) {
+    if (!(hostname === domain || hostname.endsWith(`.${domain}`))) {
         return false;
     }
     if (!cookiePathMatches(cookie.path, parsedUrl?.pathname || '/')) {
@@ -82,6 +120,33 @@ const normalizeSameSite = (value) => {
     }
     return undefined;
 };
+const getDirectCookieDenialReason = (session, cookie) => {
+    const checker = session._get_cookie_access_denial_reason;
+    if (typeof checker !== 'function') {
+        return null;
+    }
+    return checker.call(session, cookie);
+};
+const filterDirectAllowedCookies = (session, cookies) => cookies.filter((cookie) => !getDirectCookieDenialReason(session, cookie));
+const partitionDirectAllowedCookies = (session, cookies) => {
+    const allowedCookies = [];
+    const blockedCookies = [];
+    for (const cookie of cookies) {
+        if (getDirectCookieDenialReason(session, cookie)) {
+            blockedCookies.push(cookie);
+        }
+        else {
+            allowedCookies.push(cookie);
+        }
+    }
+    return { allowedCookies, blockedCookies };
+};
+const assertDirectCookieUrlAllowed = (session, url) => {
+    const denialReason = getDirectCookieDenialReason(session, { url });
+    if (denialReason) {
+        throw new Error(`Cookie URL blocked by domain policy: ${denialReason}`);
+    }
+};
 const DEFAULT_STDOUT = process.stdout;
 const DEFAULT_STDERR = process.stderr;
 const writeLine = (stream, message) => {
@@ -99,15 +164,55 @@ export const load_direct_state = (state_file = DIRECT_STATE_FILE) => {
     }
 };
 export const save_direct_state = (state, state_file = DIRECT_STATE_FILE) => {
-    fs.writeFileSync(state_file, JSON.stringify(state, null, 2));
+    fs.mkdirSync(path.dirname(state_file), { recursive: true, mode: 0o700 });
+    if (process.platform !== 'win32' &&
+        path.resolve(state_file) === path.resolve(DIRECT_STATE_FILE)) {
+        fs.chmodSync(path.dirname(state_file), 0o700);
+    }
+    fs.writeFileSync(state_file, JSON.stringify(state, null, 2), {
+        encoding: 'utf8',
+        mode: 0o600,
+    });
+    if (process.platform !== 'win32') {
+        fs.chmodSync(state_file, 0o600);
+    }
 };
 export const clear_direct_state = (state_file = DIRECT_STATE_FILE) => {
     fs.rmSync(state_file, { force: true });
 };
+const writePrivateFile = (filePath, contents) => {
+    fs.writeFileSync(filePath, contents, { encoding: 'utf8', mode: 0o600 });
+    if (process.platform !== 'win32') {
+        fs.chmodSync(filePath, 0o600);
+    }
+};
+const writePrivateBufferFile = (filePath, contents) => {
+    fs.writeFileSync(filePath, contents, { mode: 0o600 });
+    if (process.platform !== 'win32') {
+        fs.chmodSync(filePath, 0o600);
+    }
+};
+const isOwnedDirectUserDataDir = (userDataDir) => {
+    if (!userDataDir || !fs.existsSync(userDataDir)) {
+        return false;
+    }
+    try {
+        const resolvedDir = fs.realpathSync(userDataDir);
+        const resolvedTmp = fs.realpathSync(os.tmpdir());
+        return (path.dirname(resolvedDir) === resolvedTmp &&
+            path.basename(resolvedDir).startsWith('browser-use-direct-'));
+    }
+    catch {
+        return false;
+    }
+};
 const cleanupOwnedDirectUserDataDir = (state) => {
     if (!state.owns_user_data_dir || !state.user_data_dir) {
         return;
     }
+    if (!isOwnedDirectUserDataDir(state.user_data_dir)) {
+        return;
+    }
     try {
         fs.rmSync(state.user_data_dir, { recursive: true, force: true });
     }
@@ -301,40 +406,46 @@ const readDirectNodeData = async (session, node, kind) => {
     if (!page?.evaluate) {
         throw new Error('No active page available');
     }
-    return await page.evaluate(({ xpath, dataKind }) => {
-        const element = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
-        if (!element) {
+    await validateDirectPageAfterAction(session, page);
+    try {
+        return await page.evaluate(({ xpath, dataKind }) => {
+            const element = document.evaluate(xpath, document, null, XPathResult.FIRST_ORDERED_NODE_TYPE, null).singleNodeValue;
+            if (!element) {
+                return null;
+            }
+            if (dataKind === 'text') {
+                return element.textContent?.trim() ?? '';
+            }
+            if (dataKind === 'value') {
+                return 'value' in element
+                    ? String(element.value ?? '')
+                    : null;
+            }
+            if (dataKind === 'attributes') {
+                return Object.fromEntries(Array.from(element.attributes).map((attribute) => [
+                    attribute.name,
+                    attribute.value,
+                ]));
+            }
+            if (dataKind === 'bbox') {
+                const rect = element.getBoundingClientRect();
+                return {
+                    x: rect.x,
+                    y: rect.y,
+                    width: rect.width,
+                    height: rect.height,
+                    top: rect.top,
+                    right: rect.right,
+                    bottom: rect.bottom,
+                    left: rect.left,
+                };
+            }
             return null;
-        }
-        if (dataKind === 'text') {
-            return element.textContent?.trim() ?? '';
-        }
-        if (dataKind === 'value') {
-            return 'value' in element
-                ? String(element.value ?? '')
-                : null;
-        }
-        if (dataKind === 'attributes') {
-            return Object.fromEntries(Array.from(element.attributes).map((attribute) => [
-                attribute.name,
-                attribute.value,
-            ]));
-        }
-        if (dataKind === 'bbox') {
-            const rect = element.getBoundingClientRect();
-            return {
-                x: rect.x,
-                y: rect.y,
-                width: rect.width,
-                height: rect.height,
-                top: rect.top,
-                right: rect.right,
-                bottom: rect.bottom,
-                left: rect.left,
-            };
-        }
-        return null;
-    }, { xpath: node.xpath, dataKind: kind });
+        }, { xpath: node.xpath, dataKind: kind });
+    }
+    finally {
+        await validateDirectPageAfterAction(session, page);
+    }
 };
 const takeDirectOptionValue = (args, index, option) => {
     const next = args[index + 1]?.trim();
@@ -648,7 +759,7 @@ export const run_direct_command = async (argv, options = {}) => {
             }
             const bytes = Buffer.from(screenshot, 'base64');
             if (outputPath) {
-                fs.writeFileSync(outputPath, bytes);
+                writePrivateBufferFile(outputPath, bytes);
                 writeLine(environment.stdout, `Screenshot saved to ${outputPath} (${bytes.length} bytes)`);
             }
             else {
@@ -737,7 +848,12 @@ export const run_direct_command = async (argv, options = {}) => {
                 if (!page?.waitForFunction) {
                     throw new Error('No active page available for wait text');
                 }
-                await page.waitForFunction((needle) => document.body?.innerText?.includes(needle) ?? false, text, { timeout: 5000 });
+                try {
+                    await page.waitForFunction((needle) => document.body?.innerText?.includes(needle) ?? false, text, { timeout: 5000 });
+                }
+                finally {
+                    await validateDirectPageAfterAction(session, page);
+                }
                 writeLine(environment.stdout, `Waited for text "${text}"`);
             }
             else {
@@ -750,7 +866,13 @@ export const run_direct_command = async (argv, options = {}) => {
             if (!locator?.hover) {
                 throw new Error('Hover is not available for this element');
             }
-            await locator.hover({ timeout: 5000 });
+            const page = await session.get_current_page?.();
+            try {
+                await locator.hover({ timeout: 5000 });
+            }
+            finally {
+                await validateDirectPageAfterAction(session, page);
+            }
             writeLine(environment.stdout, `Hovered element [${index}]`);
         }
         else if (command === 'dblclick') {
@@ -759,7 +881,13 @@ export const run_direct_command = async (argv, options = {}) => {
             if (!locator?.dblclick) {
                 throw new Error('Double-click is not available for this element');
             }
-            await locator.dblclick({ timeout: 5000 });
+            const page = await session.get_current_page?.();
+            try {
+                await locator.dblclick({ timeout: 5000 });
+            }
+            finally {
+                await validateDirectPageAfterAction(session, page);
+            }
             writeLine(environment.stdout, `Double-clicked element [${index}]`);
         }
         else if (command === 'rightclick') {
@@ -768,7 +896,13 @@ export const run_direct_command = async (argv, options = {}) => {
             if (!locator?.click) {
                 throw new Error('Right-click is not available for this element');
             }
-            await locator.click({ button: 'right', timeout: 5000 });
+            const page = await session.get_current_page?.();
+            try {
+                await locator.click({ button: 'right', timeout: 5000 });
+            }
+            finally {
+                await validateDirectPageAfterAction(session, page);
+            }
             writeLine(environment.stdout, `Right-clicked element [${index}]`);
         }
         else if (command === 'cookies') {
@@ -776,10 +910,14 @@ export const run_direct_command = async (argv, options = {}) => {
             if (cookieCommand === 'get') {
                 const parsed = parseDirectCookieOptions(args.slice(2));
                 const url = parsed.url ?? parsed.positional[0] ?? null;
+                if (url) {
+                    assertDirectCookieUrlAllowed(session, url);
+                }
                 const allCookies = (await session.get_cookies?.()) ?? [];
+                const allowedCookies = filterDirectAllowedCookies(session, allCookies);
                 const cookies = url
-                    ? allCookies.filter((cookie) => cookieMatchesUrl(cookie, url))
-                    : allCookies;
+                    ? allowedCookies.filter((cookie) => cookieMatchesUrl(cookie, url))
+                    : allowedCookies;
                 writeLine(environment.stdout, JSON.stringify({ cookies, count: cookies.length }, null, 2));
             }
             else if (cookieCommand === 'set') {
@@ -815,6 +953,10 @@ export const run_direct_command = async (argv, options = {}) => {
                 else {
                     throw new Error('Provide cookie url/domain or open a page first');
                 }
+                const denialReason = getDirectCookieDenialReason(session, cookie);
+                if (denialReason) {
+                    throw new Error(`Cookie target blocked by domain policy: ${denialReason}`);
+                }
                 await session.browser_context.addCookies([cookie]);
                 writeLine(environment.stdout, `Set cookie ${name}`);
             }
@@ -825,16 +967,41 @@ export const run_direct_command = async (argv, options = {}) => {
                 const parsed = parseDirectCookieOptions(args.slice(2));
                 const url = parsed.url ?? parsed.positional[0] ?? null;
                 if (!url) {
-                    await session.browser_context.clearCookies();
-                    writeLine(environment.stdout, 'Cleared cookies');
+                    if (typeof session.get_cookies !== 'function') {
+                        await session.browser_context.clearCookies();
+                        writeLine(environment.stdout, 'Cleared cookies');
+                    }
+                    else {
+                        const allCookies = (await session.get_cookies?.({ include_blocked: true })) ?? [];
+                        const { allowedCookies, blockedCookies } = partitionDirectAllowedCookies(session, allCookies);
+                        if (allowedCookies.length === 0 && blockedCookies.length > 0) {
+                            writeLine(environment.stdout, 'Cleared 0 cookies');
+                        }
+                        else {
+                            const addCookies = session.browser_context.addCookies;
+                            if (blockedCookies.length > 0 && !addCookies) {
+                                throw new Error('Browser context does not support preserving blocked cookies');
+                            }
+                            await session.browser_context.clearCookies();
+                            if (blockedCookies.length > 0) {
+                                await addCookies(blockedCookies);
+                            }
+                            writeLine(environment.stdout, `Cleared ${allowedCookies.length} cookies`);
+                        }
+                    }
                 }
                 else {
-                    const allCookies = (await session.get_cookies?.()) ?? [];
+                    assertDirectCookieUrlAllowed(session, url);
+                    const allCookies = (await session.get_cookies?.({ include_blocked: true })) ?? [];
                     const remaining = allCookies.filter((cookie) => !cookieMatchesUrl(cookie, url));
                     const removedCount = allCookies.length - remaining.length;
+                    const addCookies = session.browser_context.addCookies;
+                    if (remaining.length > 0 && !addCookies) {
+                        throw new Error('Browser context does not support preserving non-matching cookies');
+                    }
                     await session.browser_context.clearCookies();
-                    if (remaining.length > 0 && session.browser_context.addCookies) {
-                        await session.browser_context.addCookies(remaining);
+                    if (remaining.length > 0) {
+                        await addCookies(remaining);
                     }
                     writeLine(environment.stdout, `Cleared ${removedCount} cookies matching ${url}`);
                 }
@@ -846,12 +1013,16 @@ export const run_direct_command = async (argv, options = {}) => {
                 }
                 const parsed = parseDirectCookieOptions(args.slice(3));
                 const url = parsed.url ?? parsed.positional[0] ?? null;
+                if (url) {
+                    assertDirectCookieUrlAllowed(session, url);
+                }
                 const allCookies = (await session.get_cookies?.()) ?? [];
+                const allowedCookies = filterDirectAllowedCookies(session, allCookies);
                 const cookies = url
-                    ? allCookies.filter((cookie) => cookieMatchesUrl(cookie, url))
-                    : allCookies;
+                    ? allowedCookies.filter((cookie) => cookieMatchesUrl(cookie, url))
+                    : allowedCookies;
                 const outputPath = path.resolve(file);
-                fs.writeFileSync(outputPath, JSON.stringify(cookies, null, 2), 'utf8');
+                writePrivateFile(outputPath, JSON.stringify(cookies, null, 2));
                 writeLine(environment.stdout, `Exported ${cookies.length} cookies to ${outputPath}`);
             }
             else if (cookieCommand === 'import') {
@@ -868,8 +1039,11 @@ export const run_direct_command = async (argv, options = {}) => {
                 if (!Array.isArray(cookies)) {
                     throw new Error('Cookie import file must contain a JSON array');
                 }
-                await session.browser_context.addCookies(cookies);
-                writeLine(environment.stdout, `Imported ${cookies.length} cookies from ${inputPath}`);
+                const allowedCookies = filterDirectAllowedCookies(session, cookies);
+                if (allowedCookies.length > 0) {
+                    await session.browser_context.addCookies(allowedCookies);
+                }
+                writeLine(environment.stdout, `Imported ${allowedCookies.length} cookies from ${inputPath}`);
             }
             else {
                 throw new Error('Usage: cookies get [url|--url <url>] | cookies set <name> <value> | cookies clear [--url <url>] | cookies export <file> [--url <url>] | cookies import <file>');
@@ -882,7 +1056,13 @@ export const run_direct_command = async (argv, options = {}) => {
                 if (!page?.title) {
                     throw new Error('No active page available for get title');
                 }
-                writeLine(environment.stdout, await page.title());
+                await validateDirectPageAfterAction(session, page);
+                try {
+                    writeLine(environment.stdout, await page.title());
+                }
+                finally {
+                    await validateDirectPageAfterAction(session, page);
+                }
             }
             else if (subcommand === 'html') {
                 const selector = args.slice(2).join(' ').trim();
@@ -894,10 +1074,18 @@ export const run_direct_command = async (argv, options = {}) => {
                     if (!page?.evaluate) {
                         throw new Error('No active page available for get html');
                     }
-                    const html = await page.evaluate((targetSelector) => {
-                        const element = document.querySelector(targetSelector);
-                        return element ? element.outerHTML : null;
-                    }, selector);
+                    await validateDirectPageAfterAction(session, page);
+                    const html = await (async () => {
+                        try {
+                            return await page.evaluate((targetSelector) => {
+                                const element = document.querySelector(targetSelector);
+                                return element ? element.outerHTML : null;
+                            }, selector);
+                        }
+                        finally {
+                            await validateDirectPageAfterAction(session, page);
+                        }
+                    })();
                     if (typeof html !== 'string' || html.length === 0) {
                         throw new Error(`No element found for selector: ${selector}`);
                     }
@@ -939,10 +1127,18 @@ export const run_direct_command = async (argv, options = {}) => {
                 if (!page?.evaluate) {
                     throw new Error('No active page available for html');
                 }
-                const html = await page.evaluate((targetSelector) => {
-                    const element = document.querySelector(targetSelector);
-                    return element ? element.outerHTML : null;
-                }, selector);
+                await validateDirectPageAfterAction(session, page);
+                const html = await (async () => {
+                    try {
+                        return await page.evaluate((targetSelector) => {
+                            const element = document.querySelector(targetSelector);
+                            return element ? element.outerHTML : null;
+                        }, selector);
+                    }
+                    finally {
+                        await validateDirectPageAfterAction(session, page);
+                    }
+                })();
                 if (typeof html !== 'string' || html.length === 0) {
                     throw new Error(`No element found for selector: ${selector}`);
                 }

package/dist/skill-cli/server.d.ts

@@ -7,6 +7,7 @@ export declare class SkillCliServer {
     readonly registry: SessionRegistry;
     constructor(options?: SkillCliServerOptions);
     private _require_node_by_index;
+    private _run_with_page_validation;
     private _read_node_data;
     private _handle_browser_action;
     handle_request(request: Request | string): Promise<Response>;