agent-device-proxy 0.1.5 → 0.2.0

package/.env.example

@@ -0,0 +1,19 @@
+AGENT_DEVICE_PROXY_HOST=0.0.0.0
+AGENT_DEVICE_PROXY_PORT=9124
+# Shared secret checked by host API (Authorization: Bearer ...).
+# Must match client value: AGENT_DEVICE_PROXY_BEARER_TOKEN.
+# Generate with: openssl rand -hex 32
+AGENT_DEVICE_PROXY_BEARER_TOKEN=replace-with-strong-token
+# Optional override for where agent-device state lives on the macOS host.
+# The proxy resolves the live daemon port/token from
+# AGENT_DEVICE_STATE_DIR/daemon.json (defaults to ~/.agent-device/daemon.json).
+# AGENT_DEVICE_STATE_DIR=/Users/you/.agent-device
+AGENT_DEVICE_PROXY_VALIDATE_DAEMON_STARTUP=true
+AGENT_DEVICE_PROXY_DAEMON_PROBE_TIMEOUT_MS=3000
+
+# Host-local Metro bridge used for iOS sandbox-host runs.
+AGENT_DEVICE_PROXY_METRO_BRIDGE_ENABLED=true
+AGENT_DEVICE_PROXY_METRO_BRIDGE_HOST=127.0.0.1
+AGENT_DEVICE_PROXY_METRO_BRIDGE_PORT=8081
+AGENT_DEVICE_PROXY_METRO_BRIDGE_ANDROID_HOST=10.0.2.2
+AGENT_DEVICE_PROXY_METRO_BRIDGE_TIMEOUT_MS=120000

package/ARCHITECTURE.md

@@ -0,0 +1,263 @@
+# agent-device-proxy Architecture
+
+See [README.md](./README.md) for install and day-to-day usage. This document
+covers the system model, repo integration, and endpoint behavior.
+
+## Architecture
+
+```
+Vercel Sandbox (Linux)                    macOS host
+┌───────────────────────┐                ┌──────────────────────────────┐
+│                       │                │  agent-device-proxy (:9124)  │
+│  Metro dev server     │  /api/metro/   │  ┌────────────────────────┐  │
+│  (port 8081 inside    │──  bridge  ───▶│  │ Metro bridge (:8081)   │  │
+│   sandbox)            │                │  │ HTTP + WebSocket proxy │  │
+│                       │                │  └───────────┬────────────┘  │
+│  agent-device CLI     │  /agent-device │              │               │
+│  (npm global)         │──   /rpc    ──▶│  ┌───────────▼────────────┐  │
+│                       │                │  │ Daemon forwarder       │  │
+│  .forfiter/ scripts   │                │  │ → agent-device daemon  │  │
+│                       │                │  └────────────────────────┘  │
+└───────────────────────┘                │                              │
+                                         │                              │
+                                         │  iOS Simulator / Android Emu │
+                                         │  → 127.0.0.1:8081 (iOS)     │
+                                         │  → 10.0.2.2:8081 (Android)  │
+                                         └──────────────────────────────┘
+```
+
+## Why This Exists
+
+The QA worker runs in a Vercel sandbox. Metro also runs in that sandbox.
+
+The iOS simulator and Android emulator do not run in the sandbox. They run on a
+macOS host machine, and `agent-device` also runs there.
+
+That means the app cannot reliably load JavaScript directly from the sandbox's
+public URL:
+
+- sandbox Metro is externally reachable as `https://<sandbox>.vercel.run`
+- stock React Native iOS builds do not reliably consume that public HTTPS URL as
+  a packager origin
+- Android emulator networking is also host-specific
+
+So the supported architecture is:
+
+1. Metro runs in the sandbox.
+2. The sandbox helper resolves the public upstream Metro URL.
+3. `agent-device-proxy` creates a host-local HTTP bridge on macOS.
+4. Runtime hints point the app at that host-local bridge:
+   - iOS simulator: `127.0.0.1:<bridge-port>`
+   - Android emulator: `10.0.2.2:<bridge-port>`
+
+The app talks to a normal local HTTP Metro endpoint. The proxy forwards that
+traffic back to the sandbox's public Metro origin.
+
+## What Is Bridged
+
+`agent-device-proxy` currently exposes:
+
+- transparent forwarding for any `/agent-device/*` path to the upstream daemon
+  - common examples are `GET /agent-device/health` and `POST /agent-device/rpc`
+- `POST /api/metro/resolve` to normalize Metro runtime hints
+- `POST /api/metro/probe` to probe upstream Metro reachability
+- `POST /api/metro/bridge` to create or reconfigure the host-local Metro bridge
+- `GET /api/health` for proxy health
+- `GET /healthz` for lightweight health
+
+The proxy is not the product boundary for artifact semantics in this repo. QA
+artifact selection happens in workflow code, the sandbox must resolve a
+host-downloadable install source plus any required auth, and app installation
+happens through the typed `agent-device` client on the host. If no
+host-downloadable source can be produced, QA blocks instead of falling back to
+sandbox-local installation.
+
+## Runtime Model
+
+Runtime hints are still relevant, but their role changed.
+
+They are no longer meant to point apps at the public sandbox Metro URL. Instead,
+they tell the app which host-local bridge endpoint to use.
+
+Typical runtime values returned by `/api/metro/bridge`:
+
+- iOS:
+  - `metro_host=127.0.0.1`
+  - `metro_port=8081`
+  - `metro_bundle_url=http://127.0.0.1:8081/index.bundle?...`
+- Android:
+  - `metro_host=10.0.2.2`
+  - `metro_port=8081`
+  - `metro_bundle_url=http://10.0.2.2:8081/index.bundle?...`
+
+The upstream public sandbox URL is still tracked and probed, but the app should
+not launch against it directly when the bridge is available.
+
+## QA Flow In This Repo
+
+The staged sandbox Metro helper is the source of truth for Metro:
+
+- `.forfiter/start-metro-runtime.js`
+  - is invoked only when the repo-side QA bootstrap determines that the artifact
+    needs a Metro-backed dev runtime
+  - starts Metro inside the sandbox
+  - resolves the public upstream Metro runtime
+  - calls `POST /api/metro/bridge`
+  - writes `.forfiter/metro-runtime.json`
+  - fails closed if a bridge is required but unavailable
+
+App launch is no longer owned by a sandbox helper script. The workflow bootstrap
+reads `.forfiter/metro-runtime.json`, installs the app through the typed
+`agent-device` client, and then calls `open({ runtime })`.
+
+For iOS React Native dev builds, that bridge-backed runtime remains the
+supported launch path.
+
+## Host Env File
+
+Use [.env.example](.env.example) as the host-side template.
+
+Important defaults:
+
+- `AGENT_DEVICE_PROXY_PORT=9124`
+- `AGENT_DEVICE_PROXY_METRO_BRIDGE_ENABLED=true`
+- `AGENT_DEVICE_PROXY_METRO_BRIDGE_HOST=127.0.0.1`
+- `AGENT_DEVICE_PROXY_METRO_BRIDGE_PORT=8081`
+- `AGENT_DEVICE_PROXY_METRO_BRIDGE_ANDROID_HOST=10.0.2.2`
+
+The proxy validates the upstream daemon health on startup by default. If
+`~/.agent-device/daemon.json` does not point at a live HTTP daemon, proxy
+startup should fail early.
+
+Practical startup modes:
+
+- Installed package, auto-discovered daemon:
+  - set `AGENT_DEVICE_PROXY_BEARER_TOKEN`
+  - ensure `~/.agent-device/daemon.json` exists, or set `AGENT_DEVICE_STATE_DIR`
+  - run `agent-device-proxy serve`
+- Installed package, helper-managed local daemon:
+  - set `AGENT_DEVICE_PROXY_BEARER_TOKEN`
+  - run `agent-device-proxy dev`
+
+## Worker Envs
+
+The Linux/Vercel worker uses two related connections:
+
+### 1. Remote `agent-device` daemon bridge
+
+This is what the workflow-side typed `agent-device` client uses:
+
+```bash
+AGENT_DEVICE_DAEMON_BASE_URL=http://<mac-host>:9124/agent-device
+AGENT_DEVICE_DAEMON_AUTH_TOKEN=<strong-token>
+AGENT_DEVICE_DAEMON_TRANSPORT=http
+```
+
+### 2. Direct proxy API
+
+This is what the staged Metro helper uses:
+
+```bash
+AGENT_DEVICE_PROXY_BASE_URL=http://<mac-host>:9124
+AGENT_DEVICE_PROXY_BEARER_TOKEN=<strong-token>
+```
+
+At runtime inside the sandbox, QA writes `~/.agent-device/config.json` with the
+derived daemon settings and the per-run session/platform lock. The runtime
+agent then uses plain `agent-device` commands without wrapper scripts.
+
+## Metro Endpoints
+
+### `/api/metro/resolve`
+
+Normalizes incoming runtime hints into a resolved upstream runtime.
+
+Use this when you want to inspect how the proxy interprets:
+
+- `metro_bundle_url`
+- `metro_host + metro_port`
+
+### `/api/metro/probe`
+
+Probes the upstream Metro endpoint and returns reachability details.
+
+This is useful as a diagnostic endpoint. It is not enough by itself to prove
+that the app is using the correct runtime.
+
+### `/api/metro/bridge`
+
+Creates or reconfigures the host-local Metro bridge and returns the bridge-backed
+runtime hints that apps should use.
+
+This is the important endpoint for sandbox-host QA.
+
+Example response shape:
+
+```json
+{
+  "base_url": "http://127.0.0.1:8081",
+  "status_url": "http://127.0.0.1:8081/status",
+  "bundle_url": "http://127.0.0.1:8081/index.bundle?platform=ios&dev=true&minify=false",
+  "ios_runtime": {
+    "metro_host": "127.0.0.1",
+    "metro_port": 8081,
+    "metro_bundle_url": "http://127.0.0.1:8081/index.bundle?platform=ios&dev=true&minify=false"
+  },
+  "android_runtime": {
+    "metro_host": "10.0.2.2",
+    "metro_port": 8081,
+    "metro_bundle_url": "http://10.0.2.2:8081/index.bundle?platform=android&dev=true&minify=false"
+  },
+  "upstream": {
+    "bundle_url": "https://<sandbox>.vercel.run/index.bundle?...",
+    "host": "<sandbox>.vercel.run",
+    "port": 443,
+    "status_url": "https://<sandbox>.vercel.run/status"
+  }
+}
+```
+
+## Operational Notes
+
+- The Metro bridge is lazy. It starts listening when `/api/metro/bridge` is
+  called.
+- Initial bundle fetch is supported. Websocket and HMR traffic are also proxied
+  by the bridge.
+- The current repo QA flow assumes the bridge is available when
+  `AGENT_DEVICE_PROXY_BASE_URL` and `AGENT_DEVICE_PROXY_BEARER_TOKEN` are set.
+- Public sandbox Metro URLs are still recorded as upstream metadata, but they
+  should be treated as debug or probe inputs, not as the primary app runtime.
+
+## Troubleshooting
+
+**Proxy startup fails with daemon health check error**
+
+The proxy validates the upstream daemon on startup. Make sure `agent-device` is
+running in HTTP mode:
+
+```bash
+export AGENT_DEVICE_DAEMON_SERVER_MODE=http
+agent-device session list --json --daemon-transport http
+```
+
+If using the helper command, the proxy resolves the live daemon from
+`~/.agent-device/daemon.json` automatically. If that file is missing or stale,
+restart `agent-device` in HTTP mode.
+
+**Port 8081 already in use**
+
+The Metro bridge binds to port 8081 by default. If another Metro instance or
+process already occupies that port, either stop it or set a different bridge
+port:
+
+```bash
+export AGENT_DEVICE_PROXY_METRO_BRIDGE_PORT=8082
+```
+
+Note: the sandbox scripts and runtime hints must also be updated to match.
+
+**Bearer token mismatch**
+
+The proxy rejects requests where the `Authorization: Bearer` header does not
+match `AGENT_DEVICE_PROXY_BEARER_TOKEN`. Ensure the same token is exported on
+both the worker side and the macOS host side.

package/README.md

@@ -1,196 +1,88 @@
 # agent-device-proxy
 
-Reusable macOS `agent-device-proxy` sidecar for:
+Reusable macOS sidecar for remote mobile QA.
 
-- native `agent-device` remote-daemon bridge
-- Metro resolve/probe
-- artifact upload/install for `.app` and `.apk`
+It has two jobs:
 
-Default hardening:
+- expose a host-local HTTP bridge to a macOS `agent-device` HTTP daemon
+- expose a host-local HTTP Metro bridge for simulator/emulator app traffic
 
-- streamed artifact uploads (no in-memory full body for uploads)
-- ZIP entry validation before `.app` extraction
-- strict command status (`exit_code != 0` -> HTTP `502`)
-- artifact retention cleanup (TTL + max total bytes)
+## Why
 
-## Hidden Transport Behavior
+The QA worker and Metro run in a Linux sandbox, while the iOS simulator,
+Android emulator, and `agent-device` run on a macOS host. `agent-device-proxy`
+bridges those two environments so the worker can talk to the host daemon and
+the app can use a normal host-local Metro endpoint.
 
-- `.app` directories are zipped by client API and unzipped by host API
-- `.apk` files are sent raw (not zipped)
-
-Consumers should pass `.app` / `.apk` paths and call the client API.
-
-## Primary endpoints
-
-- `GET /api/health`
-- `GET /agent-device/health`
-- `POST /agent-device/rpc`
-- `POST /api/artifacts/upload`
-- `POST /api/agent-device/install`
-- `POST /api/agent-device/exec`
-- `POST /api/metro/resolve`
-- `POST /api/metro/probe`
-
-Compatibility aliases remain available under `/v1/*`.
-
-## Run
+## Install
 
 ```bash
-pnpm --filter agent-device-proxy start
+npm install -g agent-device-proxy
 ```
 
-From repo root:
+## Run
+
+Start the proxy against an already-running `agent-device` HTTP daemon:
 
 ```bash
-pnpm dev:agent-device-proxy
+export AGENT_DEVICE_PROXY_BEARER_TOKEN='<strong-token>' # openssl rand -hex 32
+agent-device-proxy serve
 ```
 
-## Remote macOS + Linux/Vercel setup
-
-### 1) Remote macOS machine (runs `agent-device-proxy` + `agent-device`)
+For `serve`, set:
 
-Use `agent-device-proxy/.env.example` as the host-side env template.
-Use one shared bearer token value on both sides:
+- `AGENT_DEVICE_PROXY_BEARER_TOKEN` (e.g. generated with `openssl rand -hex 32`)
+- a readable `~/.agent-device/daemon.json` (set by `agent-device`) or `AGENT_DEVICE_STATE_DIR`
 
-- host: `AGENT_DEVICE_PROXY_BEARER_TOKEN`
-- client: `AGENT_DEVICE_PROXY_BEARER_TOKEN`
-- generate once: `openssl rand -hex 32`
+If you want the package to prepare the local `agent-device` HTTP daemon first,
+use the helper command instead:
 
 ```bash
-# on remote macOS
-git clone https://github.com/callstackincubator/forfiter.git
-
-cd forfiter/agent-device-proxy && pnpm install
-
-# run agent-device HTTP daemon
-AGENT_DEVICE_DAEMON_SERVER_MODE=http \
-agent-device session list --json
-
-# run agent-device-proxy API
-AGENT_DEVICE_PROXY_BEARER_TOKEN='<strong-token>' \
-AGENT_DEVICE_PROXY_DAEMON_BASE_URL='http://127.0.0.1:4310/agent-device' \
-pnpm --filter agent-device-proxy start
+export AGENT_DEVICE_PROXY_BEARER_TOKEN='<strong-token>'
+agent-device-proxy dev
 ```
 
-Optional hardening envs:
+`dev` is macOS-host oriented. It expects:
 
-```bash
-AGENT_DEVICE_PROXY_STRICT_COMMAND_STATUS=true
-AGENT_DEVICE_PROXY_ARTIFACT_TTL_HOURS=24
-AGENT_DEVICE_PROXY_ARTIFACT_MAX_TOTAL_BYTES=5368709120
-```
+- `agent-device` to be installed locally and runnable
+- standard host utilities such as `ps` and `lsof`
+- `AGENT_DEVICE_PROXY_BEARER_TOKEN` to already be set
 
-### 2) Client Linux/Vercel side
+If you want a host-side env template, use [.env.example](.env.example).
 
-For native `agent-device` remote-daemon mode in sandboxes, point the client at the
-proxy bridge:
+The package also exposes the macOS bootstrap helper as:
 
 ```bash
-export AGENT_DEVICE_DAEMON_BASE_URL="http://<remote-mac-ip>:9123/agent-device"
-export AGENT_DEVICE_DAEMON_AUTH_TOKEN="<strong-token>"
+agent-device-proxy-macos-remote-setup --help
 ```
 
-The proxy bridge exposes `GET /agent-device/health` and `POST /agent-device/rpc`,
-and forwards them to the configured host daemon base URL.
+## Programmatic Usage
 
-For artifact upload/install and Metro helper flows, the same worker can call the
-`agent-device-proxy` API directly.
-
-In your workflow/agent worker:
+Node client:
 
 ```ts
 import { createAgentDeviceProxyClient } from "agent-device-proxy"
-import { ensureMetroRuntime } from "agent-device-proxy/metro-runtime"
 
-const agentDeviceProxy = createAgentDeviceProxyClient({
-  baseUrl: "http://<remote-mac-ip>:9123",
+const client = createAgentDeviceProxyClient({
+  baseUrl: "http://<mac-host>:9124",
   bearerToken: process.env.AGENT_DEVICE_PROXY_BEARER_TOKEN,
 })
-
-const metro = await ensureMetroRuntime({
-  projectRoot: "/workspace/RNCLI83",
-  port: 8081,
-  publicHost: process.env.AGENT_DEVICE_PROXY_METRO_PUBLIC_HOST, // must be reachable from remote mac
-})
-
-try {
-  // iOS: pass ios_runtime so remote mac can connect to Metro
-  await agentDeviceProxy.installApp({
-    app: "RNCLI83",
-    filePath: "/workspace/ios-build/RNCLI83.app",
-    platform: "ios",
-    device: "iPhone 17 Pro",
-  })
-
-  await agentDeviceProxy.agentDeviceExec({
-    argv: ["open", "RNCLI83", "--platform", "ios", "--device", "iPhone 17 Pro"],
-    ios_runtime: metro.ios_runtime,
-  })
-
-  // Android: no Metro hint needed
-  await agentDeviceProxy.installApp({
-    app: "com.rncli83",
-    filePath: "/workspace/android/app/build/outputs/apk/debug/app-debug.apk",
-    platform: "android",
-    serial: "emulator-5554",
-  })
-} finally {
-  await metro.stop()
-}
 ```
 
-### Networking rule
+Embedded server:
 
-`metro.publicHost:metro.port` must be reachable from remote macOS.
-If not reachable directly, use a tunnel and pass that tunnel endpoint in `ios_runtime`.
-
-### Migration note
-
-Older docs may reference `host-agent`, `@platform/host-agent`, or `HOST_AGENT_*` env names.
-Use `agent-device-proxy`, `agent-device-proxy/*`, and `AGENT_DEVICE_PROXY_*` env names instead.
-
-## Client
-
-```js
-import { createAgentDeviceProxyClient } from "agent-device-proxy"
-```
-
-## Auxiliary helpers
-
-For Node consumers, use:
-
-```js
-import {
-  createAgentDeviceProxyClient,
-  ensureMetroRuntime,
-} from "agent-device-proxy"
-```
-
-Use `installApp()` for artifact handoff and `agentDeviceExec()` only when you
-explicitly need the proxy API from Node. This package does not install an
-`agent-device` bin shim; use the real `agent-device` package for CLI execution
-and native remote-daemon support.
-
-## Embedded server
-
-```js
+```ts
 import { startAgentDeviceProxyServer } from "agent-device-proxy/server"
 
 startAgentDeviceProxyServer()
 ```
 
-## Metro runtime helper (Linux/Vercel)
+## More Details
 
-```js
-import { ensureMetroRuntime } from "agent-device-proxy/metro-runtime"
+See [ARCHITECTURE.md](./ARCHITECTURE.md) for:
 
-const metro = await ensureMetroRuntime({
-  projectRoot: "/workspace/RNCLI83",
-  publicHost: "10.0.0.10",
-})
-
-// use metro.ios_runtime when opening iOS app through agent-device-proxy
-// await agentDeviceProxy.agentDeviceExec({ argv: [...], ios_runtime: metro.ios_runtime })
-
-await metro.stop()
-```
+- system architecture and runtime model
+- QA flow in this repo
+- worker-side env wiring
+- Metro endpoint behavior
+- operational notes and troubleshooting

package/dist/src/224.js

@@ -1 +1 @@
-import{randomUUID as t,node_path as e,promises as i,createReadStream as a}from"./402.js";import{spawn as r}from"./493.js";import{node_os as o}from"./47.js";function n(t){let r=function(t){if("string"!=typeof t||!t.trim())throw Error("baseUrl is required");return t.trim().replace(/\/+$/,"")}(t.baseUrl),o="string"==typeof t.bearerToken?t.bearerToken.trim():"",n=f(t.timeoutMs,12e4);return{health:async()=>await s({baseUrl:r,method:"GET",endpoint:"/api/health",bearerToken:o,timeoutMs:n}),metroResolve:async t=>await s({baseUrl:r,method:"POST",endpoint:"/api/metro/resolve",bodyJson:{ios_runtime:d(t)},bearerToken:o,timeoutMs:f(u(t),n)}),async metroProbe(t){let e=f(u(t),n);return await s({baseUrl:r,method:"POST",endpoint:"/api/metro/probe",bodyJson:{ios_runtime:d(t),...u(t)?{timeout_ms:u(t)}:{}},bearerToken:o,timeoutMs:e})},async agentDeviceExec(t){let e={argv:Array.isArray(t?.argv)?t.argv:[],...t?.cwd?{cwd:t.cwd}:{},...t?.run_id?{run_id:t.run_id}:{},...t?.ios_session_id?{ios_session_id:t.ios_session_id}:{},...t?.tenant_id?{tenant_id:t.tenant_id}:{},...t?.ios_runtime?{ios_runtime:t.ios_runtime}:{}};return await s({baseUrl:r,method:"POST",endpoint:"/api/agent-device/exec",bodyJson:e,bearerToken:o,timeoutMs:f(t?.timeout_ms,n)})},async uploadArtifact(t){let e=await p(t.filePath);try{let p=await i.stat(e.uploadPath);return await s({baseUrl:r,method:"POST",endpoint:"/api/artifacts/upload",rawBody:a(e.uploadPath),rawBodyLength:p.size,contentType:"application/octet-stream",extraHeaders:{"x-artifact-type":e.artifactType,"x-artifact-archive":e.archive,"x-artifact-filename":e.fileName,...t.sha256?{"x-artifact-sha256":t.sha256}:{}},bearerToken:o,timeoutMs:f(t.timeout_ms,n)})}finally{e.cleanupPath&&await h(e.cleanupPath)}},async installArtifact(t){let e={app:m(t.app,"app"),artifact_id:m(t.artifact_id,"artifact_id"),platform:m(t.platform,"platform"),...t.device?{device:t.device}:{},...t.session?{session:t.session}:{},...t.udid?{udid:t.udid}:{},...t.serial?{serial:t.serial}:{},...!0===t.reinstall?{reinstall:!0}:{},...!1===t.json?{json:!1}:{}};return await s({baseUrl:r,method:"POST",endpoint:"/api/agent-device/install",bodyJson:e,bearerToken:o,timeoutMs:f(t.timeout_ms,n)})},async installApp(t){var i;let a,r=m(t.filePath,"filePath"),o=(i=r,(a=e.resolve(i)).endsWith(".app")?e.basename(a,".app"):""),n=t.app||o;if(!n)throw Error("app is required when filePath does not end with .app");let s=await this.uploadArtifact({filePath:r,...t.sha256?{sha256:t.sha256}:{},...t.timeout_ms?{timeout_ms:t.timeout_ms}:{}}),p=await this.installArtifact({app:n,artifact_id:s.artifact_id,platform:m(t.platform,"platform"),...t.device?{device:t.device}:{},...t.session?{session:t.session}:{},...t.udid?{udid:t.udid}:{},...t.serial?{serial:t.serial}:{},...!0===t.reinstall?{reinstall:!0}:{},...!1===t.json?{json:!1}:{},...t.timeout_ms?{timeout_ms:t.timeout_ms}:{}});return{artifact:s,install:p}}}}async function s({baseUrl:t,method:e,endpoint:i,bodyJson:a,rawBody:r,rawBodyLength:o,contentType:n,extraHeaders:p,bearerToken:l,timeoutMs:d}){let u,c,m={...p||{}};void 0!==r?(u=r,m["content-type"]=n||"application/octet-stream","number"==typeof o&&Number.isFinite(o)&&o>=0&&(m["content-length"]=String(o))):void 0!==a&&(u=JSON.stringify(a),m["content-type"]="application/json"),l&&(m.authorization=`Bearer ${l}`);let f=await fetch(`${t}${i}`,{method:e,headers:m,...void 0!==u?{body:u}:{},...void 0!==r?{duplex:"half"}:{},signal:AbortSignal.timeout(d)}),h=await f.text();try{c=h?JSON.parse(h):{}}catch{c={raw:h}}if(!f.ok){var _;let t=Error(((_=c)&&"object"==typeof _?"string"==typeof _.error?_.error:_.error&&"object"==typeof _.error&&"string"==typeof _.error.message?_.error.message:null:null)??`agent-device-proxy request failed (${f.status})`);throw t.statusCode=f.status,t.payload=c,t}return c&&"object"==typeof c&&"ok"in c&&"data"in c?c.data:c}async function p(a){let r=e.resolve(m(a,"filePath")),n=await i.stat(r);if(n.isDirectory()){if(!r.endsWith(".app"))throw Error("directory uploads must be .app bundles");let i=e.join(o.tmpdir(),`agent-device-proxy-${t()}.zip`);return await l("zip",["-qry",i,e.basename(r)],e.dirname(r)),{artifactType:"app",archive:"zip",uploadPath:i,fileName:`${e.basename(r)}.zip`,cleanupPath:i}}if(!n.isFile())throw Error("filePath must point to a file or .app directory");if(!r.toLowerCase().endsWith(".apk"))throw Error("file uploads must be .apk (for iOS, pass a .app directory)");return{artifactType:"apk",archive:"raw",uploadPath:r,fileName:e.basename(r),cleanupPath:""}}async function l(t,e,i){await new Promise((a,o)=>{let n=r(t,e,{cwd:i,stdio:["ignore","pipe","pipe"]}),s="";n.stderr.on("data",t=>{s+=t.toString("utf8")}),n.on("error",e=>{o(Error(`${t} failed: ${e.message}`))}),n.on("close",e=>{0===e?a():o(Error(`${t} exited with code ${e}: ${s||"unknown error"}`))})})}function d(t){return c(t)?t.ios_runtime:t}function u(t){if(c(t))return t.timeout_ms}function c(t){return"ios_runtime"in t}function m(t,e){if("string"!=typeof t||!t.trim())throw Error(`${e} is required`);return t.trim()}function f(t,e){if(null==t||""===t)return e;let i=Number.parseInt(String(t),10);return!Number.isInteger(i)||i<100||i>36e5?e:i}async function h(t){try{await i.unlink(t)}catch{}}export{n as createAgentDeviceProxyClient};
+function t(t){let i=function(t){if("string"!=typeof t||!t.trim())throw Error("baseUrl is required");return t.trim().replace(/\/+$/,"")}(t.baseUrl),a="string"==typeof t.bearerToken?t.bearerToken.trim():"",s=n(t.timeoutMs,12e4);return{health:async()=>await e({baseUrl:i,method:"GET",endpoint:"/api/health",bearerToken:a,timeoutMs:s}),metroResolve:async t=>await e({baseUrl:i,method:"POST",endpoint:"/api/metro/resolve",bodyJson:{ios_runtime:r(t)},bearerToken:a,timeoutMs:n(o(t),s)}),async metroProbe(t){let u=n(o(t),s);return await e({baseUrl:i,method:"POST",endpoint:"/api/metro/probe",bodyJson:{ios_runtime:r(t),...o(t)?{timeout_ms:o(t)}:{}},bearerToken:a,timeoutMs:u})},async metroBridge(t){let u=n(o(t),s);return await e({baseUrl:i,method:"POST",endpoint:"/api/metro/bridge",bodyJson:{ios_runtime:r(t),...o(t)?{timeout_ms:o(t)}:{}},bearerToken:a,timeoutMs:u})}}}async function e({baseUrl:t,method:r,endpoint:o,bodyJson:i,bearerToken:n,timeoutMs:a}){let s,u,m={};void 0!==i&&(s=JSON.stringify(i),m["content-type"]="application/json"),n&&(m.authorization=`Bearer ${n}`);let l=await fetch(`${t}${o}`,{method:r,headers:m,...void 0!==s?{body:s}:{},signal:AbortSignal.timeout(a)}),p=await l.text();try{u=p?JSON.parse(p):{}}catch{u={raw:p}}if(!l.ok){var c;let t=Error(((c=u)&&"object"==typeof c?"string"==typeof c.error?c.error:c.error&&"object"==typeof c.error&&"string"==typeof c.error.message?c.error.message:null:null)??`agent-device-proxy request failed (${l.status})`);throw t.statusCode=l.status,t.payload=u,t}return u&&"object"==typeof u&&"ok"in u&&"data"in u?u.data:u}function r(t){return i(t)?t.ios_runtime:t}function o(t){if(i(t))return t.timeout_ms}function i(t){return"ios_runtime"in t}function n(t,e){if(null==t||""===t)return e;let r=Number.parseInt(String(t),10);return!Number.isInteger(r)||r<100||r>36e5?e:r}export{t as createAgentDeviceProxyClient};