@giselles-ai/browser-tool 0.1.17 → 0.1.19

package/dist/mcp-server/index.js

@@ -113,6 +113,13 @@ function requiredEnv(name) {
 function trimTrailingSlash(input) {
   return input.replace(/\/+$/, "");
 }
+function safeJsonStringify(value) {
+  try {
+    return JSON.stringify(value);
+  } catch {
+    return String(value);
+  }
+}
 var RelayClient = class {
   url;
   sessionId;
@@ -194,7 +201,14 @@ var RelayClient = class {
     }
     const success = dispatchSuccessSchema.safeParse(body);
     if (!success.success) {
-      throw new Error("Relay dispatch returned an unexpected payload.");
+      throw new Error(
+        [
+          "Relay dispatch returned an unexpected payload.",
+          `status=${response.status}`,
+          `url=${this.url}`,
+          `body=${safeJsonStringify(body)}`
+        ].join(" ")
+      );
     }
     if (!response.ok) {
       throw new Error(`Relay dispatch failed with HTTP ${response.status}.`);

package/dist/relay/index.d.ts

@@ -1,4 +1,5 @@
 import Redis from 'ioredis';
+import { z } from 'zod';
 
 declare function createRelayHandler(): {
     GET: (request: Request) => Promise<Response>;
@@ -7,6 +8,79 @@ declare function createRelayHandler(): {
 };
 
 type RelayErrorCode = "UNAUTHORIZED" | "NO_BROWSER" | "TIMEOUT" | "INVALID_RESPONSE" | "NOT_FOUND" | "INTERNAL";
+declare const relayRequestSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"snapshot_request">;
+    requestId: z.ZodString;
+    instruction: z.ZodString;
+    document: z.ZodOptional<z.ZodString>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"execute_request">;
+    requestId: z.ZodString;
+    actions: z.ZodArray<z.ZodDiscriminatedUnion<[z.ZodObject<{
+        action: z.ZodLiteral<"fill">;
+        fieldId: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"click">;
+        fieldId: z.ZodString;
+    }, z.core.$strip>, z.ZodObject<{
+        action: z.ZodLiteral<"select">;
+        fieldId: z.ZodString;
+        value: z.ZodString;
+    }, z.core.$strip>], "action">>;
+    fields: z.ZodArray<z.ZodObject<{
+        fieldId: z.ZodString;
+        selector: z.ZodString;
+        kind: z.ZodEnum<{
+            text: "text";
+            textarea: "textarea";
+            select: "select";
+            checkbox: "checkbox";
+            radio: "radio";
+        }>;
+        label: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        placeholder: z.ZodOptional<z.ZodString>;
+        currentValue: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>], "type">;
+declare const relayResponseSchema: z.ZodDiscriminatedUnion<[z.ZodObject<{
+    type: z.ZodLiteral<"snapshot_response">;
+    requestId: z.ZodString;
+    fields: z.ZodArray<z.ZodObject<{
+        fieldId: z.ZodString;
+        selector: z.ZodString;
+        kind: z.ZodEnum<{
+            text: "text";
+            textarea: "textarea";
+            select: "select";
+            checkbox: "checkbox";
+            radio: "radio";
+        }>;
+        label: z.ZodString;
+        name: z.ZodOptional<z.ZodString>;
+        required: z.ZodBoolean;
+        placeholder: z.ZodOptional<z.ZodString>;
+        currentValue: z.ZodUnion<readonly [z.ZodString, z.ZodBoolean]>;
+        options: z.ZodOptional<z.ZodArray<z.ZodString>>;
+    }, z.core.$strip>>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"execute_response">;
+    requestId: z.ZodString;
+    report: z.ZodObject<{
+        applied: z.ZodNumber;
+        skipped: z.ZodNumber;
+        warnings: z.ZodArray<z.ZodString>;
+    }, z.core.$strip>;
+}, z.core.$strip>, z.ZodObject<{
+    type: z.ZodLiteral<"error_response">;
+    requestId: z.ZodString;
+    message: z.ZodString;
+}, z.core.$strip>], "type">;
+type RelayRequest = z.infer<typeof relayRequestSchema>;
+type RelayResponse = z.infer<typeof relayResponseSchema>;
 
 declare global {
     var __browserToolRelayRedis: Redis | undefined;
@@ -23,4 +97,18 @@ declare function createRelaySession(): Promise<{
 }>;
 declare function toRelayError(error: unknown): RelayStoreError;
 
-export { createRelayHandler, createRelaySession, toRelayError };
+type RelayRequestSubscription = {
+    nextRequest(): Promise<RelayRequest>;
+    close(): Promise<void>;
+};
+declare function createRelayRequestSubscription(input: {
+    sessionId: string;
+    token: string;
+}): Promise<RelayRequestSubscription>;
+declare function sendRelayResponse(input: {
+    sessionId: string;
+    token: string;
+    response: RelayResponse;
+}): Promise<void>;
+
+export { type RelayRequestSubscription, createRelayHandler, createRelayRequestSubscription, createRelaySession, sendRelayResponse, toRelayError };

package/dist/relay/index.js

@@ -581,6 +581,44 @@ var postBodySchema = z2.discriminatedUnion("type", [
   dispatchSchema,
   respondSchema
 ]);
+function summarizeRelayRequestForLog(request) {
+  if (request.type === "snapshot_request") {
+    return {
+      type: request.type,
+      requestId: request.requestId,
+      instruction: request.instruction
+    };
+  }
+  return {
+    type: request.type,
+    requestId: request.requestId,
+    actionCount: request.actions.length,
+    fieldCount: request.fields.length
+  };
+}
+function summarizeRelayResponseForLog(response) {
+  if (response.type === "snapshot_response") {
+    return {
+      type: response.type,
+      requestId: response.requestId,
+      fieldCount: response.fields.length
+    };
+  }
+  if (response.type === "execute_response") {
+    return {
+      type: response.type,
+      requestId: response.requestId,
+      applied: response.report.applied,
+      skipped: response.report.skipped,
+      warningCount: response.report.warnings.length
+    };
+  }
+  return {
+    type: response.type,
+    requestId: response.requestId,
+    message: response.message
+  };
+}
 function createRelayEventsRoute(request) {
   const cors = corsHeaders(request);
   const url = new URL(request.url);
@@ -751,6 +789,10 @@ async function createRelayPostRoute(request) {
     );
   }
   if (parsed.data.type === "relay.dispatch") {
+    console.info(`${LOG_PREFIX} post.dispatch`, {
+      sessionId: parsed.data.sessionId,
+      request: summarizeRelayRequestForLog(parsed.data.request)
+    });
     try {
       const response = await dispatchRelayRequest({
         sessionId: parsed.data.sessionId,
@@ -758,24 +800,46 @@ async function createRelayPostRoute(request) {
         request: parsed.data.request,
         timeoutMs: parsed.data.timeoutMs
       });
+      console.info(`${LOG_PREFIX} post.dispatch.ok`, {
+        sessionId: parsed.data.sessionId,
+        response: summarizeRelayResponseForLog(response)
+      });
       return Response.json({ ok: true, response }, { headers: cors });
     } catch (error) {
       const relayError = toRelayError(error);
+      console.error(`${LOG_PREFIX} post.dispatch.error`, {
+        sessionId: parsed.data.sessionId,
+        errorCode: relayError.code,
+        message: relayError.message
+      });
       return Response.json(
         { ok: false, errorCode: relayError.code, message: relayError.message },
         { status: relayError.status, headers: cors }
       );
     }
   }
+  console.info(`${LOG_PREFIX} post.respond`, {
+    sessionId: parsed.data.sessionId,
+    response: summarizeRelayResponseForLog(parsed.data.response)
+  });
   try {
     await resolveRelayResponse({
       sessionId: parsed.data.sessionId,
       token: parsed.data.token,
       response: parsed.data.response
     });
+    console.info(`${LOG_PREFIX} post.respond.ok`, {
+      sessionId: parsed.data.sessionId,
+      requestId: parsed.data.response.requestId
+    });
     return Response.json({ ok: true }, { headers: cors });
   } catch (error) {
     const relayError = toRelayError(error);
+    console.error(`${LOG_PREFIX} post.respond.error`, {
+      sessionId: parsed.data.sessionId,
+      errorCode: relayError.code,
+      message: relayError.message
+    });
     return Response.json(
       { ok: false, errorCode: relayError.code, message: relayError.message },
       { status: relayError.status, headers: cors }
@@ -789,8 +853,80 @@ function createRelayHandler() {
     OPTIONS: (request) => new Response(null, { status: 204, headers: corsHeaders(request) })
   };
 }
+
+// src/relay/request-subscription.ts
+async function createRelayRequestSubscription(input) {
+  await assertRelaySession(input.sessionId, input.token);
+  const subscriber = createRelaySubscriber();
+  const channel = relayRequestChannel(input.sessionId);
+  let keepaliveId = null;
+  try {
+    await subscriber.subscribe(channel);
+    await markBrowserConnected(input.sessionId, input.token);
+    keepaliveId = setInterval(() => {
+      void touchBrowserConnected(input.sessionId).catch(() => void 0);
+    }, RELAY_SSE_KEEPALIVE_INTERVAL_MS);
+  } catch (error) {
+    await subscriber.unsubscribe(channel).catch(() => void 0);
+    await subscriber.quit().catch(() => {
+      subscriber.disconnect();
+    });
+    throw error;
+  }
+  const nextRequest = () => {
+    return new Promise((resolve, reject) => {
+      const onMessage = (_channel, message) => {
+        if (_channel !== channel) {
+          return;
+        }
+        let parsed = null;
+        try {
+          const raw = JSON.parse(message);
+          const safe = relayRequestSchema.safeParse(raw);
+          if (!safe.success) {
+            return;
+          }
+          parsed = safe.data;
+        } catch {
+          return;
+        }
+        cleanup();
+        resolve(parsed);
+      };
+      const onError = (error) => {
+        cleanup();
+        reject(error);
+      };
+      const cleanup = () => {
+        subscriber.off("message", onMessage);
+        subscriber.off("error", onError);
+      };
+      subscriber.on("message", onMessage);
+      subscriber.on("error", onError);
+    });
+  };
+  const close = async () => {
+    if (keepaliveId) {
+      clearInterval(keepaliveId);
+      keepaliveId = null;
+    }
+    await subscriber.unsubscribe(channel).catch(() => void 0);
+    await subscriber.quit().catch(() => {
+      subscriber.disconnect();
+    });
+  };
+  return {
+    nextRequest,
+    close
+  };
+}
+async function sendRelayResponse(input) {
+  await resolveRelayResponse(input);
+}
 export {
   createRelayHandler,
+  createRelayRequestSubscription,
   createRelaySession,
+  sendRelayResponse,
   toRelayError
 };

package/package.json

@@ -1,6 +1,6 @@
 {
 	"name": "@giselles-ai/browser-tool",
-	"version": "0.1.17",
+	"version": "0.1.19",
 	"type": "module",
 	"sideEffects": false,
 	"license": "Apache-2.0",