humanish 0.141.0 → 0.143.0

package/dist/substrates/modal/sandbox.js

@@ -7,6 +7,7 @@
 // default gVisor runtime sets no_new_privs on every process, so the user's sudo, which the Node
 // bootstrap and product installs run, cannot work there.
 import { E2BDesktopStartupError, reportDesktopAllocation } from "../e2b/sdk.js";
+import { shellOnlySurface } from "../e2b/shell-only.js";
 import { readBytes, readFile, runCommand, sandboxPath, wholeSeconds, writeFile, } from "./commands.js";
 import { MODAL_DESKTOP_DISPLAY, MODAL_STREAM_PORT, modalDesktopSurface, startModalDesktop, } from "./desktop.js";
 import { MODAL_SANDBOX_USER, modalDesktopImage, modalShellImage } from "./image.js";
@@ -70,9 +71,7 @@ export function modalSandboxModule(client, connection, profile) {
                 ...(options.resolution === undefined ? {} : { resolution: options.resolution }),
                 ...(options.dpi === undefined ? {} : { dpi: options.dpi }),
             });
-            const tunnels = await sandbox.tunnels(30_000);
-            const hosts = new Map(Object.entries(tunnels).map(([port, tunnel]) => [Number(port), new URL(tunnel.url).host]));
-            return modalSandboxHandle(sandbox, profile, connection, hosts);
+            return modalSandboxHandle(sandbox, profile, connection, await tunnelHosts(sandbox));
         }
         catch (error) {
             const gone = await modalSandboxes(client, connection)
@@ -82,13 +81,33 @@ export function modalSandboxModule(client, connection, profile) {
             throw new E2BDesktopStartupError(error, gone);
         }
     }
+    async function connect(sandboxId, options) {
+        const ms = options?.requestTimeoutMs ?? DEFAULT_REQUEST_TIMEOUT_MS;
+        let sandbox;
+        try {
+            sandbox = await within(client.sandboxes.fromId(sandboxId), ms, "a sandbox lookup");
+            if ((await within(sandbox.poll(), ms, "a sandbox poll")) !== null)
+                throw sandboxNotFound(sandboxId);
+        }
+        catch (error) {
+            throw isModalNotFoundError(error) ? sandboxNotFound(sandboxId) : error;
+        }
+        const hosts = profile.desktop === true ? await tunnelHosts(sandbox) : new Map();
+        return modalSandboxHandle(sandbox, profile, connection, hosts);
+    }
     return {
         Sandbox: {
             create: hidingTokens(connection, create),
+            connect: hidingTokens(connection, connect),
             ...modalSandboxes(client, connection),
         },
     };
 }
+/** The host of each tunnel a desktop sandbox exposes, by port. */
+async function tunnelHosts(sandbox) {
+    const tunnels = await sandbox.tunnels(30_000);
+    return new Map(Object.entries(tunnels).map(([port, tunnel]) => [Number(port), new URL(tunnel.url).host]));
+}
 /** The humanish App in the connection's environment; only a create may make it. */
 function appLookup(client, connection, createIfMissing) {
     let app;
@@ -240,6 +259,10 @@ function modalSandboxHandle(sandbox, profile, connection, hosts) {
     const run = hidingTokens(connection, (command, options) => runCommand(sandbox, command, options));
     const shell = {
         sandboxId: sandbox.sandboxId,
+        portAccess: hidingTokens(connection, async (port) => {
+            const { url, token } = await sandbox.createConnectToken({ port });
+            return { url, headers: { Authorization: `Bearer ${token}` } };
+        }),
         // Modal reports no allocation for a sandbox; the create's request is what it bills.
         getInfo: () => Promise.resolve({ cpuCount: profile.cpu * 2, memoryMB: profile.memoryMiB }),
         commands: { run },
@@ -257,31 +280,7 @@ function modalSandboxHandle(sandbox, profile, connection, hosts) {
             ...shell,
             ...modalDesktopSurface(run, hidingTokens(connection, (path) => readBytes(sandbox, path)), hosts),
         };
-    const desktopOnly = (what) => () => Promise.reject(new ModalUnsupportedError(what));
-    return {
-        ...shell,
-        wait: (ms) => new Promise((resolve) => setTimeout(resolve, ms)),
-        launch: desktopOnly("A desktop application launch"),
-        screenshot: desktopOnly("A desktop screenshot"),
-        leftClick: desktopOnly("Desktop input"),
-        rightClick: desktopOnly("Desktop input"),
-        middleClick: desktopOnly("Desktop input"),
-        doubleClick: desktopOnly("Desktop input"),
-        moveMouse: desktopOnly("Desktop input"),
-        scroll: desktopOnly("Desktop input"),
-        write: desktopOnly("Desktop input"),
-        press: desktopOnly("Desktop input"),
-        drag: desktopOnly("Desktop input"),
-        stream: {
-            getAuthKey: () => {
-                throw new ModalUnsupportedError("A desktop stream");
-            },
-            getUrl: () => {
-                throw new ModalUnsupportedError("A desktop stream");
-            },
-            start: desktopOnly("A desktop stream"),
-        },
-    };
+    return { ...shell, ...shellOnlySurface((what) => new ModalUnsupportedError(what)) };
 }
 /** The Modal account `env` names, for release by id and reclaim. Throws when it names none. */
 export async function modalAccount(env, load = loadModalModule) {

package/dist/substrates/modal/sdk.d.ts

@@ -51,6 +51,13 @@ export interface ModalSandbox {
     tunnels(timeoutMs?: number): Promise<Record<number, {
         url: string;
     }>>;
+    /** A URL to `port` and a token Modal's proxy requires as `Authorization: Bearer <token>`. */
+    createConnectToken(params?: {
+        port?: number;
+    }): Promise<{
+        url: string;
+        token: string;
+    }>;
 }
 export interface ModalSandboxCreateParams {
     cpu?: number;