browser-use-sdk 1.2.0 → 2.0.1

package/dist/esm/wrapper/lib/parse.mjs

@@ -0,0 +1,203 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+var __await = (this && this.__await) || function (v) { return this instanceof __await ? (this.v = v, this) : new __await(v); }
+var __asyncGenerator = (this && this.__asyncGenerator) || function (thisArg, _arguments, generator) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var g = generator.apply(thisArg, _arguments || []), i, q = [];
+    return i = Object.create((typeof AsyncIterator === "function" ? AsyncIterator : Object).prototype), verb("next"), verb("throw"), verb("return", awaitReturn), i[Symbol.asyncIterator] = function () { return this; }, i;
+    function awaitReturn(f) { return function (v) { return Promise.resolve(v).then(f, reject); }; }
+    function verb(n, f) { if (g[n]) { i[n] = function (v) { return new Promise(function (a, b) { q.push([n, v, a, b]) > 1 || resume(n, v); }); }; if (f) i[n] = f(i[n]); } }
+    function resume(n, v) { try { step(g[n](v)); } catch (e) { settle(q[0][3], e); } }
+    function step(r) { r.value instanceof __await ? Promise.resolve(r.value.v).then(fulfill, reject) : settle(q[0][2], r); }
+    function fulfill(value) { resume("next", value); }
+    function reject(value) { resume("throw", value); }
+    function settle(f, v) { if (f(v), q.shift(), q.length) resume(q[0][0], q[0][1]); }
+};
+var __asyncValues = (this && this.__asyncValues) || function (o) {
+    if (!Symbol.asyncIterator) throw new TypeError("Symbol.asyncIterator is not defined.");
+    var m = o[Symbol.asyncIterator], i;
+    return m ? m.call(o) : (o = typeof __values === "function" ? __values(o) : o[Symbol.iterator](), i = {}, verb("next"), verb("throw"), verb("return"), i[Symbol.asyncIterator] = function () { return this; }, i);
+    function verb(n) { i[n] = o[n] && function (v) { return new Promise(function (resolve, reject) { v = o[n](v), settle(resolve, reject, v.done, v.value); }); }; }
+    function settle(resolve, reject, d, v) { Promise.resolve(v).then(function(v) { resolve({ value: v, done: d }); }, reject); }
+};
+import { createHash } from "crypto";
+import stringify from "fast-json-stable-stringify";
+import z from "zod";
+import { ExhaustiveSwitchCheck } from "./types.mjs";
+export function stringifyStructuredOutput(schema) {
+    return JSON.stringify(z.toJSONSchema(schema));
+}
+export function parseStructuredTaskOutput(res, schema) {
+    if (res.output == null) {
+        return Object.assign(Object.assign({}, res), { parsed: null });
+    }
+    try {
+        const parsed = JSON.parse(res.output);
+        const response = schema.safeParse(parsed);
+        if (!response.success) {
+            throw new Error(`Invalid structured output: ${response.error.message}`);
+        }
+        return Object.assign(Object.assign({}, res), { parsed: response.data });
+    }
+    catch (e) {
+        if (e instanceof SyntaxError) {
+            return Object.assign(Object.assign({}, res), { parsed: null });
+        }
+        throw e;
+    }
+}
+/**
+ * Hashes the task view to detect changes.
+ * Uses fast-json-stable-stringify for deterministic JSON, then SHA-256.
+ */
+export function getTaskViewHash(view) {
+    const dump = stringify(view);
+    const hash = createHash("sha256").update(dump).digest("hex");
+    return hash;
+}
+export function wrapCreateTaskResponse(client, response, schema) {
+    // NOTE: We create utility functions for streaming and watching internally in the function
+    //       to expose them as utility methods to the base object.
+    function _watch(taskId, config, options) {
+        return __asyncGenerator(this, arguments, function* _watch_1() {
+            var _a, _b;
+            const intervalMs = (_a = config === null || config === void 0 ? void 0 : config.interval) !== null && _a !== void 0 ? _a : 2000;
+            const hash = { current: null };
+            poll: do {
+                if ((_b = options === null || options === void 0 ? void 0 : options.signal) === null || _b === void 0 ? void 0 : _b.aborted) {
+                    break poll;
+                }
+                const res = yield __await(client.getTask(taskId));
+                const resHash = getTaskViewHash(res);
+                if (hash.current == null || resHash !== hash.current) {
+                    hash.current = resHash;
+                    yield yield __await({ event: "status", data: res });
+                }
+                switch (res.status) {
+                    case "finished":
+                    case "stopped":
+                    case "paused":
+                        break poll;
+                    case "started":
+                        yield __await(new Promise((resolve) => setTimeout(resolve, intervalMs)));
+                        break;
+                    default:
+                        throw new ExhaustiveSwitchCheck(res.status);
+                }
+            } while (true);
+        });
+    }
+    /**
+     * Streams the steps of the task and closes when the task is finished.
+     *
+     * @description Logs each step of the task exactly once. If you start the stream again, it will log the steps again.
+     */
+    function stream(config, options) {
+        return __asyncGenerator(this, arguments, function* stream_1() {
+            var _a, e_1, _b, _c;
+            const steps = { total: 0 };
+            try {
+                for (var _d = true, _e = __asyncValues(_watch(response.id, config, options)), _f; _f = yield __await(_e.next()), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const msg = _c;
+                    for (let i = steps.total; i < msg.data.steps.length; i++) {
+                        steps.total = i + 1;
+                        yield yield __await(msg.data.steps[i]);
+                    }
+                }
+            }
+            catch (e_1_1) { e_1 = { error: e_1_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield __await(_b.call(_e));
+                }
+                finally { if (e_1) throw e_1.error; }
+            }
+        });
+    }
+    function watch(schema, config, options) {
+        return __asyncGenerator(this, arguments, function* watch_1() {
+            var _a, e_2, _b, _c;
+            var _d;
+            try {
+                for (var _e = true, _f = __asyncValues(_watch(response.id, config, options)), _g; _g = yield __await(_f.next()), _a = _g.done, !_a; _e = true) {
+                    _c = _g.value;
+                    _e = false;
+                    const msg = _c;
+                    if ((_d = options === null || options === void 0 ? void 0 : options.signal) === null || _d === void 0 ? void 0 : _d.aborted) {
+                        break;
+                    }
+                    if (schema != null) {
+                        const parsed = parseStructuredTaskOutput(msg.data, schema);
+                        yield yield __await({ event: "status", data: parsed });
+                    }
+                    else {
+                        yield yield __await({ event: "status", data: msg.data });
+                    }
+                }
+            }
+            catch (e_2_1) { e_2 = { error: e_2_1 }; }
+            finally {
+                try {
+                    if (!_e && !_a && (_b = _f.return)) yield __await(_b.call(_f));
+                }
+                finally { if (e_2) throw e_2.error; }
+            }
+        });
+    }
+    function complete(schema, config, options) {
+        return __awaiter(this, void 0, void 0, function* () {
+            var _a, e_3, _b, _c;
+            try {
+                for (var _d = true, _e = __asyncValues(_watch(response.id, config, options)), _f; _f = yield _e.next(), _a = _f.done, !_a; _d = true) {
+                    _c = _f.value;
+                    _d = false;
+                    const msg = _c;
+                    switch (msg.data.status) {
+                        case "finished":
+                        case "stopped":
+                        case "paused": {
+                            if (schema != null) {
+                                const parsed = parseStructuredTaskOutput(msg.data, schema);
+                                return parsed;
+                            }
+                            else {
+                                const result = msg.data;
+                                return result;
+                            }
+                        }
+                        case "started":
+                            break;
+                        default:
+                            throw new ExhaustiveSwitchCheck(msg.data.status);
+                    }
+                }
+            }
+            catch (e_3_1) { e_3 = { error: e_3_1 }; }
+            finally {
+                try {
+                    if (!_d && !_a && (_b = _e.return)) yield _b.call(_e);
+                }
+                finally { if (e_3) throw e_3.error; }
+            }
+            throw new Error("Stream ended before the task finished!");
+        });
+    }
+    // NOTE: Finally, we return the wrapped task response.
+    if (schema == null) {
+        const wrapped = Object.assign(Object.assign({}, response), { stream: (config, options) => stream(config, options), watch: (config, options) => watch(null, config, options), complete: (config, options) => complete(null, config, options) });
+        return wrapped;
+    }
+    else {
+        const wrapped = Object.assign(Object.assign({}, response), { stream: (config, options) => stream(config, options), watch: (config, options) => watch(schema, config, options), complete: (config, options) => complete(schema, config, options) });
+        return wrapped;
+    }
+}

package/dist/esm/wrapper/lib/types.d.mts

@@ -0,0 +1,74 @@
+/**
+ * Distributive Pick - does not collapse unions into a "shared type" only to
+ * run Pick on it. Instead, it "picks" from each union item separately.
+ *
+ * See https://github.com/klimashkin/css-modules-theme/pull/8
+ *
+ * Example:
+ *      Pick<{ type: "pick" } | { type: "omit" }, "type">
+ *  produces { type: "pick" | "omit" }
+ *
+ * UnionPick<{ type: "pick" } | { type: "omit" }, "type">
+ *  produces { type: "pick" } | { type: "omit" }
+ */
+export type UnionPick<T, K extends keyof T> = T extends unknown ? Pick<T, K> : never;
+/**
+ * Like UnionPick, but for Omit
+ */
+export type UnionOmit<T, K extends keyof T> = T extends unknown ? Omit<T, K> : never;
+/**
+ * Utility type for properties that may be undefined until loaded.
+ */
+export type Loadable<T> = ({
+    loading: true;
+} & {
+    [K in keyof T]?: never;
+}) | ({
+    loading: false;
+} & T);
+/**
+ * Utility type that removes null fields from a type.
+ */
+export type DeepRequired<T> = {
+    [P in keyof T]: Exclude<T[P], null>;
+};
+/**
+ * Makes a type check that is only valid when all cases of a switch
+ * statement have been convered.
+ */
+export declare class ExhaustiveSwitchCheck extends Error {
+    constructor(val: never);
+}
+/**
+ * A utiliy type that lets you extract a union member by its `kind` property.
+ *
+ * @example
+ *
+ * type Shape =
+ *   | { kind: 'circle'; radius: number }
+ *   | { kind: 'square'; sideLength: number }
+ *   | { kind: 'rectangle'; width: number; height: number };
+ *
+ * type Circle = ExtractKind<Shape, 'circle'>; // { kind: 'circle'; radius: number }
+ */
+export type ExtractKind<T, K> = T extends {
+    kind: K;
+} ? T : never;
+/**
+ * A utiliy type that lets you extract a union member by its `ok` property.
+ *
+ * @example
+ *
+ * type Result = { ok: true; value: string } | { ok: false; error: string };
+ *
+ * type Ok = ExtractResult<Result, true>; // { ok: true; value: string }
+ */
+export type ExtractResult<T, K extends boolean> = T extends {
+    ok: K;
+} ? T : never;
+/**
+ * Creates a deep readonly object mutable.
+ */
+export type DeepMutable<T> = {
+    -readonly [P in keyof T]: T[P] extends object ? DeepMutable<T[P]> : T[P];
+};

package/dist/esm/wrapper/lib/types.mjs

@@ -0,0 +1,9 @@
+/**
+ * Makes a type check that is only valid when all cases of a switch
+ * statement have been convered.
+ */
+export class ExhaustiveSwitchCheck extends Error {
+    constructor(val) {
+        super(`Unreachable case: ${JSON.stringify(val)}`);
+    }
+}

package/dist/esm/wrapper/lib/webhooks.d.mts

@@ -0,0 +1,72 @@
+import { z } from "zod";
+export declare const zWebhookTimestamp: z.ZodISODateTime;
+export declare const zWebhookTestPayload: z.ZodObject<{
+    test: z.ZodLiteral<"ok">;
+}, z.core.$strip>;
+export type WebhookTestPayload = z.infer<typeof zWebhookTestPayload>;
+export declare const zWebhookTest: z.ZodObject<{
+    type: z.ZodLiteral<"test">;
+    timestamp: z.ZodISODateTime;
+    payload: z.ZodObject<{
+        test: z.ZodLiteral<"ok">;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const zWebhookAgentTaskStatusUpdatePayloadMetadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+export declare const zWebhookAgentTaskStatusUpdatePayloadStatus: z.ZodLiteral<"stopped" | "started" | "paused" | "finished" | "initializing">;
+export declare const zWebhookAgentTaskStatusUpdatePayload: z.ZodObject<{
+    session_id: z.ZodString;
+    task_id: z.ZodString;
+    status: z.ZodLiteral<"stopped" | "started" | "paused" | "finished" | "initializing">;
+    metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+}, z.core.$strip>;
+export type WebhookAgentTaskStatusUpdatePayload = z.infer<typeof zWebhookAgentTaskStatusUpdatePayload>;
+export declare const zWebhookAgentTaskStatusUpdate: z.ZodObject<{
+    type: z.ZodLiteral<"agent.task.status_update">;
+    timestamp: z.ZodISODateTime;
+    payload: z.ZodObject<{
+        session_id: z.ZodString;
+        task_id: z.ZodString;
+        status: z.ZodLiteral<"stopped" | "started" | "paused" | "finished" | "initializing">;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>;
+export declare const zWebhookSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"test">;
+    timestamp: z.ZodISODateTime;
+    payload: z.ZodObject<{
+        test: z.ZodLiteral<"ok">;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"agent.task.status_update">;
+    timestamp: z.ZodISODateTime;
+    payload: z.ZodObject<{
+        session_id: z.ZodString;
+        task_id: z.ZodString;
+        status: z.ZodLiteral<"stopped" | "started" | "paused" | "finished" | "initializing">;
+        metadata: z.ZodOptional<z.ZodRecord<z.ZodString, z.ZodUnknown>>;
+    }, z.core.$strip>;
+}, z.core.$strip>], "type">;
+export type Webhook = z.infer<typeof zWebhookSchema>;
+/**
+ * Utility function that validates the received Webhook event/
+ */
+export declare function verifyWebhookEventSignature(evt: {
+    body: string | object;
+    signature: string;
+    timestamp: string;
+}, cfg: {
+    secret: string;
+}): Promise<{
+    ok: true;
+    event: Webhook;
+} | {
+    ok: false;
+}>;
+/**
+ * Creates a webhook signature for the given payload, timestamp, and secret.
+ */
+export declare function createWebhookSignature({ payload, timestamp, secret, }: {
+    payload: unknown;
+    timestamp: string;
+    secret: string;
+}): string;

package/dist/esm/wrapper/lib/webhooks.mjs

@@ -0,0 +1,89 @@
+var __awaiter = (this && this.__awaiter) || function (thisArg, _arguments, P, generator) {
+    function adopt(value) { return value instanceof P ? value : new P(function (resolve) { resolve(value); }); }
+    return new (P || (P = Promise))(function (resolve, reject) {
+        function fulfilled(value) { try { step(generator.next(value)); } catch (e) { reject(e); } }
+        function rejected(value) { try { step(generator["throw"](value)); } catch (e) { reject(e); } }
+        function step(result) { result.done ? resolve(result.value) : adopt(result.value).then(fulfilled, rejected); }
+        step((generator = generator.apply(thisArg, _arguments || [])).next());
+    });
+};
+import { createHmac } from "crypto";
+import stringify from "fast-json-stable-stringify";
+import { z } from "zod";
+// https://docs.browser-use.com/cloud/webhooks
+//
+export const zWebhookTimestamp = z.iso.datetime({ offset: true, local: true });
+// test
+export const zWebhookTestPayload = z.object({
+    test: z.literal("ok"),
+});
+export const zWebhookTest = z.object({
+    type: z.literal("test"),
+    timestamp: zWebhookTimestamp,
+    payload: zWebhookTestPayload,
+});
+// agent.task.status_update
+export const zWebhookAgentTaskStatusUpdatePayloadMetadata = z.record(z.string(), z.unknown()).optional();
+export const zWebhookAgentTaskStatusUpdatePayloadStatus = z.literal([
+    "initializing",
+    "started",
+    "paused",
+    "stopped",
+    "finished",
+]);
+export const zWebhookAgentTaskStatusUpdatePayload = z.object({
+    session_id: z.string(),
+    task_id: z.string(),
+    status: zWebhookAgentTaskStatusUpdatePayloadStatus,
+    metadata: zWebhookAgentTaskStatusUpdatePayloadMetadata,
+});
+export const zWebhookAgentTaskStatusUpdate = z.object({
+    type: z.literal("agent.task.status_update"),
+    timestamp: zWebhookTimestamp,
+    payload: zWebhookAgentTaskStatusUpdatePayload,
+});
+//
+export const zWebhookSchema = z.discriminatedUnion("type", [
+    //
+    zWebhookTest,
+    zWebhookAgentTaskStatusUpdate,
+]);
+// Signature
+/**
+ * Utility function that validates the received Webhook event/
+ */
+export function verifyWebhookEventSignature(evt, cfg) {
+    return __awaiter(this, void 0, void 0, function* () {
+        try {
+            const json = typeof evt.body === "string" ? JSON.parse(evt.body) : evt.body;
+            const event = yield zWebhookSchema.safeParseAsync(json);
+            if (event.success === false) {
+                return { ok: false };
+            }
+            const signature = createWebhookSignature({
+                payload: event.data.payload,
+                timestamp: evt.timestamp,
+                secret: cfg.secret,
+            });
+            // Compare signatures using timing-safe comparison
+            if (evt.signature !== signature) {
+                return { ok: false };
+            }
+            return { ok: true, event: event.data };
+        }
+        catch (err) {
+            console.error(err);
+            return { ok: false };
+        }
+    });
+}
+/**
+ * Creates a webhook signature for the given payload, timestamp, and secret.
+ */
+export function createWebhookSignature({ payload, timestamp, secret, }) {
+    const dump = stringify(payload);
+    const message = `${timestamp}.${dump}`;
+    const hmac = createHmac("sha256", secret);
+    hmac.update(message);
+    return hmac.digest("hex");
+}