@giselles-ai/browser-tool 0.1.18 → 0.1.20

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.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 }
@@ -795,7 +859,20 @@ async function createRelayRequestSubscription(input) {
   await assertRelaySession(input.sessionId, input.token);
   const subscriber = createRelaySubscriber();
   const channel = relayRequestChannel(input.sessionId);
-  await subscriber.subscribe(channel);
+  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) => {
@@ -829,6 +906,10 @@ async function createRelayRequestSubscription(input) {
     });
   };
   const close = async () => {
+    if (keepaliveId) {
+      clearInterval(keepaliveId);
+      keepaliveId = null;
+    }
     await subscriber.unsubscribe(channel).catch(() => void 0);
     await subscriber.quit().catch(() => {
       subscriber.disconnect();

package/package.json

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