@phone-use/sdk 0.3.1 → 0.4.0

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@phone-use/sdk",
-  "version": "0.3.1",
+  "version": "0.4.0",
   "description": "Typed mobile-device SDK \u2014 Device, backends, errors, actions",
   "type": "module",
   "license": "Apache-2.0",

package/src/backends/cloud-sandbox.ts

@@ -163,6 +163,48 @@ export class CloudSandboxBackend extends BaseDeviceBackend {
   }
 
   /** Upload a zipped .app bundle (base64) and install it on the sandbox device. */
+  /**
+   * Upload a zipped .app as a raw stream. Prefer this over {@link installApp}:
+   * base64 inside a JSON body inflates the payload by a third, which caps real
+   * apps near 144MB. Pass a `Bun.file(...)` (or any Blob) and the bytes go to the
+   * wire without being buffered in memory.
+   */
+  async installAppStream(zip: Blob): Promise<{ installed?: string }> {
+    const response = await this.fetchImpl(`${this.endpoint}/app`, {
+      method: 'POST',
+      headers: {
+        authorization: `Bearer ${this.token}`,
+        'content-type': 'application/zip',
+      },
+      body: zip,
+    });
+    // A worker older than this SDK has no /app route. Fall back to the base64
+    // RPC rather than failing: a client should keep working against a fleet
+    // that has not been redeployed yet. The old ceiling (~144MB of zip) still
+    // applies on that path, and an app above it will say so.
+    if (response.status === 404) {
+      const bytes = await zip.arrayBuffer();
+      return this.installApp(Buffer.from(bytes).toString('base64'));
+    }
+    const body = (await response.json().catch(() => ({}))) as
+      | SandboxRpcResponse
+      | { error?: string };
+    if (!response.ok || !('ok' in body)) {
+      const message =
+        ('error' in body && typeof body.error === 'string' ? body.error : undefined) ??
+        `HTTP ${response.status}`;
+      throw new PhoneUseError(message, { code: 'UNKNOWN', retryable: false });
+    }
+    if (!body.ok) {
+      throw new PhoneUseError(body.error.message, {
+        code: normalizeErrorCode(body.error.code),
+        retryable: body.error.retryable ?? false,
+      });
+    }
+    return body.result as { installed?: string };
+  }
+
+  /** @deprecated Base64-in-JSON; use {@link installAppStream}. */
   installApp(base64Zip: string): Promise<{ installed?: string }> {
     return this.rpc('installApp', base64Zip);
   }

package/src/index.ts

@@ -7,7 +7,7 @@
  * deliberately not re-exported here.
  */
 /** The published package version (kept in sync with package.json by the release flow). */
-export const VERSION = '0.3.1';
+export const VERSION = '0.4.0';
 
 export {
   type Action,

package/src/observe.ts

@@ -880,8 +880,11 @@ export class DeviceCore {
           await this.press(el.ref);
           return true;
         } catch (error) {
-          if (!/off-?screen/i.test(describeError(error))) throw error;
-          // straddled the edge — fall through to a nudge scroll and retry
+          // Straddled the edge, or sitting under a sheet/toast/overlay. Both are
+          // positional and both are what the nudge scroll below is for, so retry
+          // rather than throw — real apps stack overlays over their own chrome,
+          // and a covered element used to abort an entire crawl.
+          if (!/off-?screen|covered/i.test(describeError(error))) throw error;
         }
       }
       // Known position → scroll toward it. Not in the realized tree at all →