browser-use-sdk 1.2.0 → 2.0.1

package/src/lib/bin/auth.ts

@@ -1,63 +0,0 @@
-import * as dotenv from '@dotenvx/dotenvx';
-
-import { BrowserUse } from '../../';
-
-const API_KEY_ENV_VAR_KEY = 'BROWSER_USE_API_KEY';
-
-/**
- * Creates a new BrowserUse client with the API key from the environment variable.
- */
-export function createBrowserUseClient() {
-  let apiKey: string | null = null;
-
-  if (process.env[API_KEY_ENV_VAR_KEY]) {
-    apiKey = process.env[API_KEY_ENV_VAR_KEY];
-  }
-
-  if (apiKey == null) {
-    const env = dotenv.config({ path: '.env' });
-
-    const envApiKey = env.parsed?.[API_KEY_ENV_VAR_KEY];
-
-    if (envApiKey) {
-      apiKey = envApiKey;
-    }
-  }
-
-  if (apiKey == null) {
-    console.error(`Missing ${API_KEY_ENV_VAR_KEY} environment variable!`);
-    process.exit(1);
-  }
-
-  return new BrowserUse({ apiKey });
-}
-
-const SECRET_ENV_VAR_KEY = 'SECRET_KEY';
-
-/**
- * Loads the Browser Use webhook secret from the environment variable.
- */
-export function getBrowserUseWebhookSecret() {
-  let secret: string | null = null;
-
-  if (process.env[SECRET_ENV_VAR_KEY]) {
-    secret = process.env[SECRET_ENV_VAR_KEY];
-  }
-
-  if (secret == null) {
-    const env = dotenv.config({ path: '.env' });
-
-    const envSecret = env.parsed?.[SECRET_ENV_VAR_KEY];
-
-    if (envSecret) {
-      secret = envSecret;
-    }
-  }
-
-  if (secret == null) {
-    console.error(`Missing ${SECRET_ENV_VAR_KEY} environment variable!`);
-    process.exit(1);
-  }
-
-  return secret;
-}

package/src/lib/bin/cli.ts

@@ -1,11 +0,0 @@
-#!/usr/bin/env node
-
-import { program } from 'commander';
-import { listen } from './commands/listen';
-
-program
-  .name('browser-use')
-  .description('CLI to some JavaScript string utilities')
-  .version('0.8.0')
-  .addCommand(listen)
-  .parse(process.argv);

package/src/lib/bin/commands/listen.ts

@@ -1,183 +0,0 @@
-import { Command } from 'commander';
-
-import { APIUserAbortError, BrowserUse } from '../../../';
-import { createWebhookSignature, Webhook } from '../../webhooks';
-import { createBrowserUseClient, getBrowserUseWebhookSecret } from '../auth';
-
-// NOTE: We perform task list refresh to get all running tasks and then
-const tickRef: {
-  timeout: NodeJS.Timeout | null;
-  abort: AbortController | null;
-} = { timeout: null, abort: null };
-
-export const listen = new Command('listen')
-  .description(`Open a local webhook to receive Cloud API updates from the CLI on your local machine.`)
-  .argument('<endpoint>', 'The endpoint to forward updates to.')
-  .action(async (endpoint) => {
-    // Auth
-
-    const client = createBrowserUseClient();
-    const secret = getBrowserUseWebhookSecret();
-
-    // Proxy
-
-    const localTargetEndpoint = endpoint;
-
-    if (typeof localTargetEndpoint !== 'string') {
-      // NOTE: This should never happen because the command is validated by commander.
-      throw new Error(
-        'Something unexpected happened. Please report this issue. https://github.com/browser-use/browser-use-node/issues',
-      );
-    }
-
-    const localTargetURL = new URL(localTargetEndpoint);
-
-    //
-
-    const startTimeDate = new Date();
-    const queue: { current: Webhook[] } = { current: [] };
-    const runs: Map<string, BrowserUse.TaskStatus> = new Map();
-
-    tickRef.timeout = setInterval(async () => {
-      // NOTE: On next tick, we abort the current abort controller.
-      if (tickRef.abort != null) {
-        tickRef.abort.abort();
-      }
-
-      const controller = new AbortController();
-
-      tickRef.abort = controller;
-
-      console.log(`[polling] ${new Date().toISOString()} `.padEnd(100, '='));
-
-      const tasks: BrowserUse.Tasks.TaskItemView[] = await client.tasks
-        .list(
-          {
-            pageSize: 10,
-            // NOTE: There's a bug in the API where the datetime needs to be provided in naive format.cur
-            after: startTimeDate.toISOString().replace('Z', ''),
-          },
-          {
-            signal: tickRef.abort.signal,
-          },
-        )
-        .then((res) => res.items)
-        .catch((err) => {
-          if (err instanceof APIUserAbortError) {
-            return [];
-          }
-
-          console.log(`[polling] ${new Date().toISOString()} failed`);
-          console.error(err);
-
-          return [];
-        });
-
-      for (const task of tasks) {
-        const currentTaskStatus = runs.get(task.id);
-
-        const timestamp = task.finishedAt ? task.finishedAt : task.startedAt;
-
-        if (currentTaskStatus == null) {
-          // NOTE: The task is new and the CLI hasn't yet captured it in the current run.
-          queue.current.push({
-            type: 'agent.task.status_update',
-            timestamp,
-            payload: {
-              session_id: task.sessionId,
-              task_id: task.id,
-              status: task.status,
-              metadata: task.metadata,
-            },
-          });
-
-          runs.set(task.id, task.status);
-
-          continue;
-        } else {
-          // NOTE: CLI has registered the task in the registry and we need to compare.
-          if (task.status !== currentTaskStatus) {
-            queue.current.push({
-              type: 'agent.task.status_update',
-              timestamp,
-              payload: {
-                session_id: task.sessionId,
-                task_id: task.id,
-                status: task.status,
-                metadata: task.metadata,
-              },
-            });
-
-            runs.set(task.id, task.status);
-
-            continue;
-          }
-        }
-      }
-
-      // Send Events
-
-      const events: (Webhook & { internal?: true })[] = [
-        // NOTE: We push the ping request on every tick to ensure the webhook is alive.
-        {
-          type: 'test',
-          timestamp: new Date().toISOString(),
-          payload: { test: 'ok' },
-          internal: true,
-        },
-        ...queue.current,
-      ];
-
-      const promises = events.map(async (update) => {
-        const body = JSON.stringify(update);
-
-        const signature = createWebhookSignature({
-          payload: update.payload,
-          timestamp: update.timestamp,
-          secret,
-        });
-
-        try {
-          const res = await fetch(localTargetURL, {
-            method: 'POST',
-            body,
-            headers: {
-              'Content-Type': 'application/json',
-              // https://docs.browser-use.com/cloud/webhooks#implementing-webhook-verification
-              'X-Browser-Use-Timestamp': update.timestamp,
-              'X-Browser-Use-Signature': signature,
-            },
-
-            signal: controller.signal,
-          });
-
-          console.log(`[update] ${update.timestamp} ${update.type} ${res.status}`);
-
-          return { delivery: 'fulfilled', update, status: res.status };
-        } catch (err) {
-          console.log(`[update] ${update.timestamp} ${update.type} failed`);
-
-          return { delivery: 'rejected', update, error: err };
-        }
-      });
-
-      const delivery = await Promise.all(promises);
-
-      // NOTE: We preserve the rejected updates so we can retry them.
-      queue.current = delivery
-        .filter((d) => d.delivery === 'rejected' && d.update.internal !== true)
-        .map((d) => d.update);
-    }, 1_000);
-
-    console.log(`Forwarding updates to: ${localTargetEndpoint}!`);
-  });
-
-process.on('SIGINT', () => {
-  if (tickRef.abort != null) {
-    tickRef.abort.abort();
-  }
-
-  if (tickRef.timeout) {
-    clearInterval(tickRef.timeout);
-  }
-});

package/src/lib/nextjs/hooks/useBrowserUse.ts

@@ -1,37 +0,0 @@
-import { useEffect, useState } from 'react';
-import type { ZodType } from 'zod';
-
-import type { BrowserUseEvent } from '../server/utils';
-import { TaskViewWithSchema } from '../../parse';
-
-/**
- * A hook to stream Browser Use updates to the client.
- */
-export function useBrowserUse<T extends ZodType = ZodType>(route: string): TaskViewWithSchema<T> | null {
-  const [status, setStatus] = useState<TaskViewWithSchema<T> | null>(null);
-
-  useEffect(() => {
-    const es = new EventSource(route);
-
-    es.addEventListener('status', (e) => {
-      if (e instanceof MessageEvent) {
-        const msg = JSON.parse(e.data) as BrowserUseEvent<T>;
-
-        setStatus(msg.data);
-
-        if (msg.data.status === 'finished') {
-          es.close();
-        }
-      } else {
-        console.error('Event is not a MessageEvent', e);
-      }
-    });
-
-    es.addEventListener('end', () => es.close());
-    es.addEventListener('error', () => es.close());
-
-    return () => es.close();
-  }, [route]);
-
-  return status;
-}

package/src/lib/nextjs/server/utils.ts

@@ -1,69 +0,0 @@
-import { TaskViewWithSchema } from '../../parse';
-import { ZodType } from 'zod';
-
-export type BrowserUseEvent<T extends ZodType = ZodType> = {
-  event: 'status';
-  data: TaskViewWithSchema<T>;
-};
-
-/**
- * Convert an async generator to a stream.
- *
- * @param gen - The async generator to convert to a stream.
- * @returns A stream of the async generator.
- */
-export function gtos(
-  gen: AsyncGenerator<{
-    event: 'status';
-    data: TaskViewWithSchema<ZodType>;
-  }>,
-  opts?: {
-    /**
-     * Called when an event is emitted.
-     */
-    onEvent?: (event: TaskViewWithSchema<ZodType>) => void;
-
-    /**
-     * Called when the task is finished.
-     */
-    onFinished?: (event: TaskViewWithSchema<ZodType>) => void;
-  },
-): ReadableStream<Uint8Array<ArrayBufferLike>> {
-  const enc = new TextEncoder();
-
-  const stream = new ReadableStream<Uint8Array>({
-    async start(controller) {
-      // open the SSE stream quickly
-      controller.enqueue(enc.encode(': connected\n\n'));
-
-      try {
-        for await (const msg of gen) {
-          opts?.onEvent?.(msg.data);
-
-          const data: BrowserUseEvent = {
-            event: msg.event,
-            data: msg.data,
-          };
-
-          const encoded = JSON.stringify(data);
-
-          const payload = `event: ${msg.event}\ndata: ${encoded}\n\n`;
-
-          controller.enqueue(enc.encode(payload));
-
-          if (msg.data.status === 'finished') {
-            opts?.onFinished?.(msg.data);
-          }
-        }
-
-        controller.enqueue(enc.encode('event: end\ndata: {}\n\n'));
-      } catch (e) {
-        controller.enqueue(enc.encode(`event: error\ndata: ${JSON.stringify({ message: String(e) })}\n\n`));
-      } finally {
-        controller.close();
-      }
-    },
-  });
-
-  return stream;
-}

package/src/lib/parse.ts

@@ -1,46 +0,0 @@
-import z, { type ZodType } from 'zod';
-import type { TaskCreateParams, TaskView } from '../resources/tasks';
-
-// RUN
-
-export type TaskCreateParamsWithSchema<T extends ZodType> = Omit<TaskCreateParams, 'structuredOutputJson'> & {
-  schema: T;
-};
-
-export function stringifyStructuredOutput<T extends ZodType>(schema: T): string {
-  return JSON.stringify(z.toJSONSchema(schema));
-}
-
-// RETRIEVE
-
-export type TaskViewWithSchema<T extends ZodType> = TaskView & {
-  parsedOutput: z.output<T> | null;
-};
-
-export function parseStructuredTaskOutput<T extends ZodType>(
-  res: TaskView,
-  schema: T,
-): TaskViewWithSchema<T> {
-  if (res.doneOutput == null) {
-    return { ...res, parsedOutput: null };
-  }
-
-  try {
-    const parsed = JSON.parse(res.doneOutput);
-
-    const response = schema.safeParse(parsed);
-    if (!response.success) {
-      throw new Error(`Invalid structured output: ${response.error.message}`);
-    }
-
-    return { ...res, parsedOutput: response.data };
-  } catch (e) {
-    if (e instanceof SyntaxError) {
-      return {
-        ...res,
-        parsedOutput: null,
-      };
-    }
-    throw e;
-  }
-}

package/src/lib/stream.ts

@@ -1,14 +0,0 @@
-import { createHash } from 'crypto';
-import stringify from 'fast-json-stable-stringify';
-
-import type { TaskView } from '../resources';
-
-/**
- * Hashes the task view to detect changes.
- * Uses fast-json-stable-stringify for deterministic JSON, then SHA-256.
- */
-export function getTaskViewHash(view: TaskView): string {
-  const dump = stringify(view);
-  const hash = createHash('sha256').update(dump).digest('hex');
-  return hash;
-}

package/src/lib/types.ts

@@ -1,73 +0,0 @@
-/**
- * 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 class ExhaustiveSwitchCheck extends Error {
-  constructor(val: never) {
-    super(`Unreachable case: ${JSON.stringify(val)}`);
-  }
-}
-
-/**
- * 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/src/lib/webhooks.ts

@@ -1,119 +0,0 @@
-import { createHmac } from 'crypto';
-import { z } from 'zod';
-import stringify from 'fast-json-stable-stringify';
-
-// 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 type WebhookTestPayload = z.infer<typeof zWebhookTestPayload>;
-
-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 type WebhookAgentTaskStatusUpdatePayload = z.infer<typeof zWebhookAgentTaskStatusUpdatePayload>;
-
-export const zWebhookAgentTaskStatusUpdate = z.object({
-  type: z.literal('agent.task.status_update'),
-  timestamp: zWebhookTimestamp,
-  payload: zWebhookAgentTaskStatusUpdatePayload,
-});
-
-//
-
-export const zWebhookSchema = z.discriminatedUnion('type', [
-  //
-  zWebhookTest,
-  zWebhookAgentTaskStatusUpdate,
-]);
-
-export type Webhook = z.infer<typeof zWebhookSchema>;
-
-// Signature
-
-/**
- * Utility function that validates the received Webhook event/
- */
-export async function verifyWebhookEventSignature(
-  evt: {
-    body: string | object;
-    signature: string;
-    timestamp: string;
-  },
-  cfg: { secret: string },
-): Promise<{ ok: true; event: Webhook } | { ok: false }> {
-  try {
-    const json = typeof evt.body === 'string' ? JSON.parse(evt.body) : evt.body;
-    const event = await 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,
-}: {
-  payload: unknown;
-  timestamp: string;
-  secret: string;
-}): string {
-  const dump = stringify(payload);
-  const message = `${timestamp}.${dump}`;
-
-  const hmac = createHmac('sha256', secret);
-  hmac.update(message);
-  return hmac.digest('hex');
-}

package/src/resource.ts

@@ -1,2 +0,0 @@
-/** @deprecated Import from ./core/resource instead */
-export * from './core/resource';