@hyperbrowser/sdk 0.89.2 → 0.89.3

package/dist/sandbox/base.d.ts

@@ -23,6 +23,6 @@ export declare class RuntimeTransport {
     private fetchForConnection;
     private assertResponse;
     private buildHeaders;
-    private normalizeBaseUrl;
+    private buildRequestPath;
 }
 export {};

package/dist/sandbox/base.js

@@ -149,15 +149,7 @@ class RuntimeTransport {
         return this.assertResponse(response);
     }
     async fetchForConnection(connection, path, init, params) {
-        const url = new URL(path, this.normalizeBaseUrl(connection.baseUrl));
-        if (params) {
-            for (const [key, value] of Object.entries(params)) {
-                if (value !== undefined) {
-                    url.searchParams.append(key, String(value));
-                }
-            }
-        }
-        const target = (0, ws_1.resolveRuntimeTransportTarget)(connection.baseUrl, `${url.pathname}${url.search}`, this.runtimeProxyOverride);
+        const target = (0, ws_1.resolveRuntimeTransportTarget)(connection.baseUrl, this.buildRequestPath(path, params), this.runtimeProxyOverride);
         const headers = this.buildHeaders(connection, init?.headers, target.hostHeader);
         const controller = new AbortController();
         const timeoutId = setTimeout(() => controller.abort(), this.timeout);
@@ -235,8 +227,19 @@ class RuntimeTransport {
         }
         return headers;
     }
-    normalizeBaseUrl(baseUrl) {
-        return baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`;
+    buildRequestPath(path, params) {
+        const trimmed = path.trim();
+        const [rawPath, rawQuery = ""] = trimmed.split("?", 2);
+        const queryParams = new URLSearchParams(rawQuery);
+        if (params) {
+            for (const [key, value] of Object.entries(params)) {
+                if (value !== undefined) {
+                    queryParams.append(key, String(value));
+                }
+            }
+        }
+        const query = queryParams.toString();
+        return query ? `${rawPath}?${query}` : rawPath;
     }
 }
 exports.RuntimeTransport = RuntimeTransport;

package/dist/sandbox/runtime-path.d.ts

@@ -0,0 +1,2 @@
+export declare const runtimeSessionIdFromPath: (rawPath: string) => string | null;
+export declare const runtimeBaseUrlSessionId: (runtimeBaseUrl: string) => string | null;

package/dist/sandbox/runtime-path.js

@@ -0,0 +1,19 @@
+"use strict";
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.runtimeBaseUrlSessionId = exports.runtimeSessionIdFromPath = void 0;
+const runtimeSessionIdFromPath = (rawPath) => {
+    const segments = rawPath
+        .trim()
+        .replace(/^\/+|\/+$/g, "")
+        .split("/")
+        .filter(Boolean);
+    if (segments.length < 2 || segments[0] !== "sandbox" || !segments[1]?.trim()) {
+        return null;
+    }
+    return segments[1].trim();
+};
+exports.runtimeSessionIdFromPath = runtimeSessionIdFromPath;
+const runtimeBaseUrlSessionId = (runtimeBaseUrl) => {
+    return (0, exports.runtimeSessionIdFromPath)(new URL(runtimeBaseUrl).pathname);
+};
+exports.runtimeBaseUrlSessionId = runtimeBaseUrlSessionId;

package/dist/sandbox/ws.js

@@ -6,6 +6,7 @@ Object.defineProperty(exports, "__esModule", { value: true });
 exports.openRuntimeWebSocket = exports.toWebSocketUrl = exports.resolveRuntimeTransportTarget = exports.AsyncEventQueue = void 0;
 const ws_1 = __importDefault(require("ws"));
 const client_1 = require("../client");
+const runtime_path_1 = require("./runtime-path");
 class AsyncEventQueue {
     constructor() {
         this.values = [];
@@ -75,8 +76,42 @@ const RETRYABLE_NETWORK_CODES = new Set([
     "ESOCKETTIMEDOUT",
 ]);
 const hasScheme = (value) => /^[a-z][a-z0-9+.-]*:\/\//i.test(value);
+const shouldPrependSandboxToRuntimeAPI = (runtimeBaseUrl) => {
+    return (0, runtime_path_1.runtimeBaseUrlSessionId)(runtimeBaseUrl) === null;
+};
+const normalizeRuntimeAPIPath = (pathname, prependSandbox) => {
+    const trimmed = pathname.trim();
+    if (!trimmed) {
+        return prependSandbox ? "/sandbox" : "/";
+    }
+    const absolute = trimmed.startsWith("/") ? trimmed : `/${trimmed}`;
+    if (prependSandbox) {
+        if (absolute === "/sandbox" || absolute.startsWith("/sandbox/")) {
+            return absolute;
+        }
+        return `/sandbox${absolute}`;
+    }
+    if (absolute === "/sandbox") {
+        return "/";
+    }
+    if (absolute.startsWith("/sandbox/")) {
+        return `/${absolute.slice("/sandbox/".length)}`;
+    }
+    return absolute;
+};
+const normalizeRuntimeRelativePath = (baseUrl, path) => {
+    const trimmed = path.trim();
+    if (!trimmed) {
+        return "";
+    }
+    const parsedPath = new URL(trimmed, "http://runtime.local");
+    const prependSandbox = shouldPrependSandboxToRuntimeAPI(baseUrl);
+    const normalizedPath = normalizeRuntimeAPIPath(parsedPath.pathname, prependSandbox);
+    const relativePath = normalizedPath.replace(/^\/+/, "");
+    return `${relativePath}${parsedPath.search}${parsedPath.hash}`;
+};
 const resolveRuntimeTransportTarget = (baseUrl, path, runtimeProxyOverride) => {
-    const url = new URL(path, baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
+    const url = new URL(normalizeRuntimeRelativePath(baseUrl, path), baseUrl.endsWith("/") ? baseUrl : `${baseUrl}/`);
     if (!runtimeProxyOverride) {
         return {
             url: url.toString(),

package/dist/services/sandboxes.js

@@ -4,6 +4,7 @@ exports.SandboxesService = exports.SandboxHandle = void 0;
 const client_1 = require("../client");
 const files_1 = require("../sandbox/files");
 const base_1 = require("../sandbox/base");
+const runtime_path_1 = require("../sandbox/runtime-path");
 const process_1 = require("../sandbox/process");
 const terminal_1 = require("../sandbox/terminal");
 const base_2 = require("./base");
@@ -71,11 +72,35 @@ const serializeCreateSandboxParams = (params) => {
         timeoutMinutes: snapshotParams.timeoutMinutes,
     };
 };
+const resolveSandboxRuntimeSessionHost = (runtime, baseUrl) => {
+    const sessionIdFromBasePath = (0, runtime_path_1.runtimeSessionIdFromPath)(baseUrl.pathname);
+    if (sessionIdFromBasePath && baseUrl.hostname) {
+        return `${sessionIdFromBasePath}.${baseUrl.hostname}`;
+    }
+    const runtimeHost = runtime.host?.trim() || "";
+    if (runtimeHost) {
+        try {
+            const parsedHost = new URL(runtimeHost);
+            const sessionIdFromHostPath = (0, runtime_path_1.runtimeSessionIdFromPath)(parsedHost.pathname);
+            if (sessionIdFromHostPath && parsedHost.hostname) {
+                return `${sessionIdFromHostPath}.${parsedHost.hostname}`;
+            }
+            if (parsedHost.hostname) {
+                return parsedHost.hostname;
+            }
+        }
+        catch {
+            return runtimeHost;
+        }
+    }
+    return baseUrl.hostname;
+};
 const buildSandboxExposedUrl = (runtime, port) => {
     const baseUrl = new URL(runtime.baseUrl);
+    const sessionHost = resolveSandboxRuntimeSessionHost(runtime, baseUrl);
     const authority = baseUrl.port
-        ? `${port}-${runtime.host}:${baseUrl.port}`
-        : `${port}-${runtime.host}`;
+        ? `${port}-${sessionHost}:${baseUrl.port}`
+        : `${port}-${sessionHost}`;
     return new URL("/", `${baseUrl.protocol}//${authority}`).toString();
 };
 const upsertExposedPort = (exposedPorts, updated) => [...exposedPorts.filter((entry) => entry.port !== updated.port), updated].sort((left, right) => left.port - right.port);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@hyperbrowser/sdk",
-  "version": "0.89.2",
+  "version": "0.89.3",
   "description": "Node SDK for Hyperbrowser API",
   "author": "",
   "repository": {