browser-use 0.0.1 → 0.1.0

package/dist/controller/views.d.ts

@@ -0,0 +1,241 @@
+import { z } from 'zod';
+export declare const SearchGoogleActionSchema: z.ZodObject<{
+    query: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+}, {
+    query: string;
+}>;
+export type SearchGoogleAction = z.infer<typeof SearchGoogleActionSchema>;
+export declare const GoToUrlActionSchema: z.ZodObject<{
+    url: z.ZodString;
+    new_tab: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    url: string;
+    new_tab: boolean;
+}, {
+    url: string;
+    new_tab?: boolean | undefined;
+}>;
+export type GoToUrlAction = z.infer<typeof GoToUrlActionSchema>;
+export declare const WaitActionSchema: z.ZodObject<{
+    seconds: z.ZodDefault<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    seconds: number;
+}, {
+    seconds?: number | undefined;
+}>;
+export type WaitAction = z.infer<typeof WaitActionSchema>;
+export declare const ClickElementActionSchema: z.ZodObject<{
+    index: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    index: number;
+}, {
+    index: number;
+}>;
+export type ClickElementAction = z.infer<typeof ClickElementActionSchema>;
+export declare const InputTextActionSchema: z.ZodObject<{
+    index: z.ZodNumber;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    index: number;
+    text: string;
+}, {
+    index: number;
+    text: string;
+}>;
+export type InputTextAction = z.infer<typeof InputTextActionSchema>;
+export declare const DoneActionSchema: z.ZodObject<{
+    text: z.ZodString;
+    success: z.ZodBoolean;
+    files_to_display: z.ZodDefault<z.ZodArray<z.ZodString, "many">>;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+    success: boolean;
+    files_to_display: string[];
+}, {
+    text: string;
+    success: boolean;
+    files_to_display?: string[] | undefined;
+}>;
+export type DoneAction = z.infer<typeof DoneActionSchema>;
+export declare const StructuredOutputActionSchema: <T extends z.ZodTypeAny>(dataSchema: T) => z.ZodObject<{
+    success: z.ZodDefault<z.ZodBoolean>;
+    data: T;
+}, "strip", z.ZodTypeAny, z.objectUtil.addQuestionMarks<z.baseObjectOutputType<{
+    success: z.ZodDefault<z.ZodBoolean>;
+    data: T;
+}>, any> extends infer T_1 ? { [k in keyof T_1]: T_1[k]; } : never, z.baseObjectInputType<{
+    success: z.ZodDefault<z.ZodBoolean>;
+    data: T;
+}> extends infer T_2 ? { [k_1 in keyof T_2]: T_2[k_1]; } : never>;
+export type StructuredOutputAction<T> = {
+    success: boolean;
+    data: T;
+};
+export declare const SwitchTabActionSchema: z.ZodObject<{
+    page_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    page_id: number;
+}, {
+    page_id: number;
+}>;
+export type SwitchTabAction = z.infer<typeof SwitchTabActionSchema>;
+export declare const CloseTabActionSchema: z.ZodObject<{
+    page_id: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    page_id: number;
+}, {
+    page_id: number;
+}>;
+export type CloseTabAction = z.infer<typeof CloseTabActionSchema>;
+export declare const ScrollActionSchema: z.ZodObject<{
+    down: z.ZodDefault<z.ZodBoolean>;
+    num_pages: z.ZodDefault<z.ZodNumber>;
+    index: z.ZodOptional<z.ZodNumber>;
+}, "strip", z.ZodTypeAny, {
+    down: boolean;
+    num_pages: number;
+    index?: number | undefined;
+}, {
+    index?: number | undefined;
+    down?: boolean | undefined;
+    num_pages?: number | undefined;
+}>;
+export type ScrollAction = z.infer<typeof ScrollActionSchema>;
+export declare const SendKeysActionSchema: z.ZodObject<{
+    keys: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    keys: string;
+}, {
+    keys: string;
+}>;
+export type SendKeysAction = z.infer<typeof SendKeysActionSchema>;
+export declare const UploadFileActionSchema: z.ZodObject<{
+    index: z.ZodNumber;
+    path: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    index: number;
+    path: string;
+}, {
+    index: number;
+    path: string;
+}>;
+export type UploadFileAction = z.infer<typeof UploadFileActionSchema>;
+export declare const ExtractPageContentActionSchema: z.ZodObject<{
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+}, {
+    value: string;
+}>;
+export type ExtractPageContentAction = z.infer<typeof ExtractPageContentActionSchema>;
+export declare const ExtractStructuredDataActionSchema: z.ZodObject<{
+    query: z.ZodString;
+    extract_links: z.ZodDefault<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    query: string;
+    extract_links: boolean;
+}, {
+    query: string;
+    extract_links?: boolean | undefined;
+}>;
+export type ExtractStructuredDataAction = z.infer<typeof ExtractStructuredDataActionSchema>;
+export declare const ReadFileActionSchema: z.ZodObject<{
+    file_name: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    file_name: string;
+}, {
+    file_name: string;
+}>;
+export type ReadFileAction = z.infer<typeof ReadFileActionSchema>;
+export declare const WriteFileActionSchema: z.ZodObject<{
+    file_name: z.ZodString;
+    content: z.ZodString;
+    append: z.ZodOptional<z.ZodBoolean>;
+    trailing_newline: z.ZodOptional<z.ZodBoolean>;
+    leading_newline: z.ZodOptional<z.ZodBoolean>;
+}, "strip", z.ZodTypeAny, {
+    file_name: string;
+    content: string;
+    append?: boolean | undefined;
+    trailing_newline?: boolean | undefined;
+    leading_newline?: boolean | undefined;
+}, {
+    file_name: string;
+    content: string;
+    append?: boolean | undefined;
+    trailing_newline?: boolean | undefined;
+    leading_newline?: boolean | undefined;
+}>;
+export type WriteFileAction = z.infer<typeof WriteFileActionSchema>;
+export declare const ReplaceFileStrActionSchema: z.ZodObject<{
+    file_name: z.ZodString;
+    old_str: z.ZodString;
+    new_str: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    file_name: string;
+    old_str: string;
+    new_str: string;
+}, {
+    file_name: string;
+    old_str: string;
+    new_str: string;
+}>;
+export type ReplaceFileStrAction = z.infer<typeof ReplaceFileStrActionSchema>;
+export declare const ScrollToTextActionSchema: z.ZodObject<{
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+}, {
+    text: string;
+}>;
+export type ScrollToTextAction = z.infer<typeof ScrollToTextActionSchema>;
+export declare const DropdownOptionsActionSchema: z.ZodObject<{
+    index: z.ZodNumber;
+}, "strip", z.ZodTypeAny, {
+    index: number;
+}, {
+    index: number;
+}>;
+export type DropdownOptionsAction = z.infer<typeof DropdownOptionsActionSchema>;
+export declare const SelectDropdownActionSchema: z.ZodObject<{
+    index: z.ZodNumber;
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    index: number;
+    text: string;
+}, {
+    index: number;
+    text: string;
+}>;
+export type SelectDropdownAction = z.infer<typeof SelectDropdownActionSchema>;
+export declare const SheetsRangeActionSchema: z.ZodObject<{
+    cell_or_range: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    cell_or_range: string;
+}, {
+    cell_or_range: string;
+}>;
+export type SheetsRangeAction = z.infer<typeof SheetsRangeActionSchema>;
+export declare const SheetsUpdateActionSchema: z.ZodObject<{
+    cell_or_range: z.ZodString;
+    value: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    value: string;
+    cell_or_range: string;
+}, {
+    value: string;
+    cell_or_range: string;
+}>;
+export type SheetsUpdateAction = z.infer<typeof SheetsUpdateActionSchema>;
+export declare const SheetsInputActionSchema: z.ZodObject<{
+    text: z.ZodString;
+}, "strip", z.ZodTypeAny, {
+    text: string;
+}, {
+    text: string;
+}>;
+export type SheetsInputAction = z.infer<typeof SheetsInputActionSchema>;
+export declare const NoParamsActionSchema: z.ZodObject<{}, "passthrough", z.ZodTypeAny, z.objectOutputType<{}, z.ZodTypeAny, "passthrough">, z.objectInputType<{}, z.ZodTypeAny, "passthrough">>;
+export type NoParamsAction = z.infer<typeof NoParamsActionSchema>;

package/dist/controller/views.js

@@ -0,0 +1,88 @@
+import { z } from 'zod';
+export const SearchGoogleActionSchema = z.object({
+    query: z.string(),
+});
+export const GoToUrlActionSchema = z.object({
+    url: z.string(),
+    new_tab: z.boolean().default(false),
+});
+export const WaitActionSchema = z.object({
+    seconds: z.number().default(3),
+});
+export const ClickElementActionSchema = z.object({
+    index: z.number().int(),
+});
+export const InputTextActionSchema = z.object({
+    index: z.number().int(),
+    text: z.string(),
+});
+export const DoneActionSchema = z.object({
+    text: z.string(),
+    success: z.boolean(),
+    files_to_display: z.array(z.string()).default([]),
+});
+export const StructuredOutputActionSchema = (dataSchema) => z.object({
+    success: z.boolean().default(true),
+    data: dataSchema,
+});
+export const SwitchTabActionSchema = z.object({
+    page_id: z.number().int(),
+});
+export const CloseTabActionSchema = z.object({
+    page_id: z.number().int(),
+});
+export const ScrollActionSchema = z.object({
+    down: z.boolean().default(true), // Default to scroll down
+    num_pages: z.number().default(1), // Default to 1 page
+    index: z.number().int().optional(),
+});
+export const SendKeysActionSchema = z.object({
+    keys: z.string(),
+});
+export const UploadFileActionSchema = z.object({
+    index: z.number().int(),
+    path: z.string(),
+});
+export const ExtractPageContentActionSchema = z.object({
+    value: z.string(),
+});
+export const ExtractStructuredDataActionSchema = z.object({
+    query: z.string(),
+    extract_links: z.boolean().default(false),
+});
+export const ReadFileActionSchema = z.object({
+    file_name: z.string(),
+});
+export const WriteFileActionSchema = z.object({
+    file_name: z.string(),
+    content: z.string(),
+    append: z.boolean().optional(),
+    trailing_newline: z.boolean().optional(),
+    leading_newline: z.boolean().optional(),
+});
+export const ReplaceFileStrActionSchema = z.object({
+    file_name: z.string(),
+    old_str: z.string(),
+    new_str: z.string(),
+});
+export const ScrollToTextActionSchema = z.object({
+    text: z.string(),
+});
+export const DropdownOptionsActionSchema = z.object({
+    index: z.number().int(),
+});
+export const SelectDropdownActionSchema = z.object({
+    index: z.number().int(),
+    text: z.string(),
+});
+export const SheetsRangeActionSchema = z.object({
+    cell_or_range: z.string(),
+});
+export const SheetsUpdateActionSchema = z.object({
+    cell_or_range: z.string(),
+    value: z.string(),
+});
+export const SheetsInputActionSchema = z.object({
+    text: z.string(),
+});
+export const NoParamsActionSchema = z.object({}).passthrough();

package/dist/dom/clickable-element-processor/service.d.ts

@@ -0,0 +1,11 @@
+import { DOMElementNode } from '../views.js';
+export declare class ClickableElementProcessor {
+    static get_clickable_elements_hashes(dom_element: DOMElementNode): Set<string>;
+    static get_clickable_elements(dom_element: DOMElementNode): DOMElementNode[];
+    static hash_dom_element(dom_element: DOMElementNode): string;
+    private static _get_parent_branch_path;
+    private static _parent_branch_path_hash;
+    private static _attributes_hash;
+    private static _xpath_hash;
+    private static _hash_string;
+}

package/dist/dom/clickable-element-processor/service.js

@@ -0,0 +1,60 @@
+import crypto from 'node:crypto';
+import { DOMElementNode } from '../views.js';
+const sha256 = (value) => crypto.createHash('sha256').update(value).digest('hex');
+export class ClickableElementProcessor {
+    static get_clickable_elements_hashes(dom_element) {
+        const hashes = new Set();
+        for (const element of this.get_clickable_elements(dom_element)) {
+            hashes.add(this.hash_dom_element(element));
+        }
+        return hashes;
+    }
+    static get_clickable_elements(dom_element) {
+        const elements = [];
+        const traverse = (node) => {
+            for (const child of node.children) {
+                if (child instanceof DOMElementNode) {
+                    if (child.highlight_index !== null &&
+                        child.highlight_index !== undefined) {
+                        elements.push(child);
+                    }
+                    traverse(child);
+                }
+            }
+        };
+        traverse(dom_element);
+        return elements;
+    }
+    static hash_dom_element(dom_element) {
+        const parent_branch_path = this._get_parent_branch_path(dom_element);
+        const branch_path_hash = this._parent_branch_path_hash(parent_branch_path);
+        const attributes_hash = this._attributes_hash(dom_element.attributes);
+        const xpath_hash = this._xpath_hash(dom_element.xpath);
+        return this._hash_string(`${branch_path_hash}-${attributes_hash}-${xpath_hash}`);
+    }
+    static _get_parent_branch_path(dom_element) {
+        const parents = [];
+        let current = dom_element;
+        while (current && current.parent) {
+            parents.push(current);
+            current = current.parent;
+        }
+        parents.reverse();
+        return parents.map((parent) => parent.tag_name);
+    }
+    static _parent_branch_path_hash(parent_branch_path) {
+        return sha256(parent_branch_path.join('/'));
+    }
+    static _attributes_hash(attributes) {
+        const attributes_string = Object.entries(attributes)
+            .map(([key, value]) => `${key}=${value}`)
+            .join('');
+        return this._hash_string(attributes_string);
+    }
+    static _xpath_hash(xpath) {
+        return this._hash_string(xpath);
+    }
+    static _hash_string(value) {
+        return sha256(value);
+    }
+}