@mobilerun/sdk 5.2.0 → 5.3.0

package/src/client.ts

@@ -27,6 +27,7 @@ import {
   AppListVersionsResponse,
   AppMarkFailedResponse,
   AppRetrieveResponse,
+  AppStorageUsageResponse,
   Apps,
 } from './resources/apps';
 import {
@@ -42,8 +43,26 @@ import {
   CarrierUpdateResponse,
   Carriers,
 } from './resources/carriers';
-import { Hooks } from './resources/hooks';
+import {
+  FileCancelPendingResponse,
+  FileConfirmResponse,
+  FileDeleteResponse,
+  FileListParams,
+  FileListResponse,
+  FileUpdateParams,
+  FileUpdateResponse,
+  FileUploadURLParams,
+  FileUploadURLResponse,
+  Files,
+} from './resources/files';
 import { ModelListResponse, Models } from './resources/models';
+import {
+  NotificationCatalogResponse,
+  NotificationGetPreferencesResponse,
+  NotificationUpdatePreferencesParams,
+  NotificationUpdatePreferencesResponse,
+  Notifications,
+} from './resources/notifications';
 import {
   ProfileCreateParams,
   ProfileCreateResponse,
@@ -57,7 +76,6 @@ import {
 } from './resources/profiles';
 import {
   Proxies,
-  ProxyConfig,
   ProxyCreateParams,
   ProxyCreateResponse,
   ProxyDeleteResponse,
@@ -69,6 +87,13 @@ import {
   ProxyUpdateParams,
   ProxyUpdateResponse,
 } from './resources/proxies';
+import {
+  AppEventListParams,
+  AppEventListResponse,
+  AppEventRetrieveResponse,
+  AppEvents,
+} from './resources/app-events/app-events';
+import { Assistant } from './resources/assistant/assistant';
 import { Connect } from './resources/connect/connect';
 import {
   CredentialListParams,
@@ -76,20 +101,56 @@ import {
   Credentials,
 } from './resources/credentials/credentials';
 import {
-  Device,
   DeviceCountResponse,
   DeviceCreateParams,
+  DeviceCreateResponse,
   DeviceFingerprintParams,
   DeviceFingerprintResponse,
   DeviceListParams,
   DeviceListResponse,
+  DeviceRetrieveCapabilitiesResponse,
+  DeviceRetrieveResponse,
   DeviceSetNameParams,
+  DeviceSetNameResponse,
   DeviceTerminateParams,
+  DeviceWaitReadyResponse,
   Devices,
 } from './resources/devices/devices';
 import {
-  PackageCredentials,
-  Task,
+  EsimCapacityResponse,
+  EsimConfirmPaymentResponse,
+  EsimCreateParams,
+  EsimCreateResponse,
+  EsimImportParams,
+  EsimImportResponse,
+  EsimInstallParams,
+  EsimInstallResponse,
+  EsimInstallStatusResponse,
+  EsimListParams,
+  EsimListResponse,
+  EsimRetrieveResponse,
+  EsimSelectorParams,
+  EsimSelectorResponse,
+  EsimUpdateParams,
+  EsimUpdateResponse,
+  Esims,
+} from './resources/esims/esims';
+import { MessageListParams, MessageListResponse, Messages } from './resources/messages/messages';
+import {
+  NumberCountriesResponse,
+  NumberCreateParams,
+  NumberCreateResponse,
+  NumberDeleteResponse,
+  NumberListParams,
+  NumberListResponse,
+  NumberPurposesResponse,
+  NumberRetrieveResponse,
+  NumberUpdateParams,
+  NumberUpdateResponse,
+  Numbers,
+} from './resources/numbers/numbers';
+import { Store, StoreCategoriesResponse } from './resources/store/store';
+import {
   TaskGetStatusResponse,
   TaskGetTrajectoryResponse,
   TaskListParams,
@@ -101,10 +162,8 @@ import {
   TaskRunStreamedResponse,
   TaskSendMessageParams,
   TaskSendMessageResponse,
-  TaskStatus,
   TaskStopResponse,
   Tasks,
-  UsageResult,
 } from './resources/tasks/tasks';
 import {
   WebhookCreateParams,
@@ -119,7 +178,7 @@ import {
   WebhookUpdateResponse,
   Webhooks,
 } from './resources/webhooks/webhooks';
-import { Flow, Workflows } from './resources/workflows/workflows';
+import { Workflows } from './resources/workflows/workflows';
 import { type Fetch } from './internal/builtin-types';
 import { HeadersLike, NullableHeaders, buildHeaders } from './internal/headers';
 import { FinalRequestOptions, RequestOptions } from './internal/request-options';
@@ -135,7 +194,7 @@ import { isEmptyObj } from './internal/utils/values';
 
 export interface ClientOptions {
   /**
-   * Defaults to process.env['MOBILERUN_CLOUD_API_KEY'].
+   * A bearer API key to authenticate requests.
    */
   apiKey?: string | null | undefined;
 
@@ -847,7 +906,6 @@ export class Mobilerun {
   carriers: API.Carriers = new API.Carriers(this);
   credentials: API.Credentials = new API.Credentials(this);
   devices: API.Devices = new API.Devices(this);
-  hooks: API.Hooks = new API.Hooks(this);
   /**
    * LLM Models
    */
@@ -861,13 +919,20 @@ export class Mobilerun {
   tasks: API.Tasks = new API.Tasks(this);
   workflows: API.Workflows = new API.Workflows(this);
   webhooks: API.Webhooks = new API.Webhooks(this);
+  files: API.Files = new API.Files(this);
+  assistant: API.Assistant = new API.Assistant(this);
+  appEvents: API.AppEvents = new API.AppEvents(this);
+  notifications: API.Notifications = new API.Notifications(this);
+  esims: API.Esims = new API.Esims(this);
+  messages: API.Messages = new API.Messages(this);
+  numbers: API.Numbers = new API.Numbers(this);
+  store: API.Store = new API.Store(this);
 }
 
 Mobilerun.Apps = Apps;
 Mobilerun.Carriers = Carriers;
 Mobilerun.Credentials = Credentials;
 Mobilerun.Devices = Devices;
-Mobilerun.Hooks = Hooks;
 Mobilerun.Models = Models;
 Mobilerun.Profiles = Profiles;
 Mobilerun.Proxies = Proxies;
@@ -875,6 +940,14 @@ Mobilerun.Connect = Connect;
 Mobilerun.Tasks = Tasks;
 Mobilerun.Workflows = Workflows;
 Mobilerun.Webhooks = Webhooks;
+Mobilerun.Files = Files;
+Mobilerun.Assistant = Assistant;
+Mobilerun.AppEvents = AppEvents;
+Mobilerun.Notifications = Notifications;
+Mobilerun.Esims = Esims;
+Mobilerun.Messages = Messages;
+Mobilerun.Numbers = Numbers;
+Mobilerun.Store = Store;
 
 export declare namespace Mobilerun {
   export type RequestOptions = Opts.RequestOptions;
@@ -888,6 +961,7 @@ export declare namespace Mobilerun {
     type AppCreateSignedUploadURLResponse as AppCreateSignedUploadURLResponse,
     type AppListVersionsResponse as AppListVersionsResponse,
     type AppMarkFailedResponse as AppMarkFailedResponse,
+    type AppStorageUsageResponse as AppStorageUsageResponse,
     type AppListParams as AppListParams,
     type AppCreateSignedUploadURLParams as AppCreateSignedUploadURLParams,
   };
@@ -914,10 +988,14 @@ export declare namespace Mobilerun {
 
   export {
     Devices as Devices,
-    type Device as Device,
+    type DeviceCreateResponse as DeviceCreateResponse,
+    type DeviceRetrieveResponse as DeviceRetrieveResponse,
     type DeviceListResponse as DeviceListResponse,
     type DeviceCountResponse as DeviceCountResponse,
     type DeviceFingerprintResponse as DeviceFingerprintResponse,
+    type DeviceRetrieveCapabilitiesResponse as DeviceRetrieveCapabilitiesResponse,
+    type DeviceSetNameResponse as DeviceSetNameResponse,
+    type DeviceWaitReadyResponse as DeviceWaitReadyResponse,
     type DeviceCreateParams as DeviceCreateParams,
     type DeviceListParams as DeviceListParams,
     type DeviceFingerprintParams as DeviceFingerprintParams,
@@ -925,8 +1003,6 @@ export declare namespace Mobilerun {
     type DeviceTerminateParams as DeviceTerminateParams,
   };
 
-  export { Hooks as Hooks };
-
   export { Models as Models, type ModelListResponse as ModelListResponse };
 
   export {
@@ -943,7 +1019,6 @@ export declare namespace Mobilerun {
 
   export {
     Proxies as Proxies,
-    type ProxyConfig as ProxyConfig,
     type ProxyCreateResponse as ProxyCreateResponse,
     type ProxyRetrieveResponse as ProxyRetrieveResponse,
     type ProxyUpdateResponse as ProxyUpdateResponse,
@@ -960,10 +1035,6 @@ export declare namespace Mobilerun {
 
   export {
     Tasks as Tasks,
-    type PackageCredentials as PackageCredentials,
-    type Task as Task,
-    type TaskStatus as TaskStatus,
-    type UsageResult as UsageResult,
     type TaskRetrieveResponse as TaskRetrieveResponse,
     type TaskListResponse as TaskListResponse,
     type TaskGetStatusResponse as TaskGetStatusResponse,
@@ -978,7 +1049,7 @@ export declare namespace Mobilerun {
     type TaskSendMessageParams as TaskSendMessageParams,
   };
 
-  export { Workflows as Workflows, type Flow as Flow };
+  export { Workflows as Workflows };
 
   export {
     Webhooks as Webhooks,
@@ -994,6 +1065,78 @@ export declare namespace Mobilerun {
     type WebhookListParams as WebhookListParams,
   };
 
+  export {
+    Files as Files,
+    type FileUpdateResponse as FileUpdateResponse,
+    type FileListResponse as FileListResponse,
+    type FileDeleteResponse as FileDeleteResponse,
+    type FileCancelPendingResponse as FileCancelPendingResponse,
+    type FileConfirmResponse as FileConfirmResponse,
+    type FileUploadURLResponse as FileUploadURLResponse,
+    type FileUpdateParams as FileUpdateParams,
+    type FileListParams as FileListParams,
+    type FileUploadURLParams as FileUploadURLParams,
+  };
+
+  export { Assistant as Assistant };
+
+  export {
+    AppEvents as AppEvents,
+    type AppEventRetrieveResponse as AppEventRetrieveResponse,
+    type AppEventListResponse as AppEventListResponse,
+    type AppEventListParams as AppEventListParams,
+  };
+
+  export {
+    Notifications as Notifications,
+    type NotificationCatalogResponse as NotificationCatalogResponse,
+    type NotificationGetPreferencesResponse as NotificationGetPreferencesResponse,
+    type NotificationUpdatePreferencesResponse as NotificationUpdatePreferencesResponse,
+    type NotificationUpdatePreferencesParams as NotificationUpdatePreferencesParams,
+  };
+
+  export {
+    Esims as Esims,
+    type EsimCreateResponse as EsimCreateResponse,
+    type EsimRetrieveResponse as EsimRetrieveResponse,
+    type EsimUpdateResponse as EsimUpdateResponse,
+    type EsimListResponse as EsimListResponse,
+    type EsimCapacityResponse as EsimCapacityResponse,
+    type EsimConfirmPaymentResponse as EsimConfirmPaymentResponse,
+    type EsimImportResponse as EsimImportResponse,
+    type EsimInstallResponse as EsimInstallResponse,
+    type EsimInstallStatusResponse as EsimInstallStatusResponse,
+    type EsimSelectorResponse as EsimSelectorResponse,
+    type EsimCreateParams as EsimCreateParams,
+    type EsimUpdateParams as EsimUpdateParams,
+    type EsimListParams as EsimListParams,
+    type EsimImportParams as EsimImportParams,
+    type EsimInstallParams as EsimInstallParams,
+    type EsimSelectorParams as EsimSelectorParams,
+  };
+
+  export {
+    Messages as Messages,
+    type MessageListResponse as MessageListResponse,
+    type MessageListParams as MessageListParams,
+  };
+
+  export {
+    Numbers as Numbers,
+    type NumberCreateResponse as NumberCreateResponse,
+    type NumberRetrieveResponse as NumberRetrieveResponse,
+    type NumberUpdateResponse as NumberUpdateResponse,
+    type NumberListResponse as NumberListResponse,
+    type NumberDeleteResponse as NumberDeleteResponse,
+    type NumberCountriesResponse as NumberCountriesResponse,
+    type NumberPurposesResponse as NumberPurposesResponse,
+    type NumberCreateParams as NumberCreateParams,
+    type NumberUpdateParams as NumberUpdateParams,
+    type NumberListParams as NumberListParams,
+  };
+
+  export { Store as Store, type StoreCategoriesResponse as StoreCategoriesResponse };
+
   export type DeviceCarrier = API.DeviceCarrier;
   export type DeviceIdentifiers = API.DeviceIdentifiers;
   export type DeviceSpec = API.DeviceSpec;
@@ -1002,5 +1145,5 @@ export declare namespace Mobilerun {
   export type Pagination = API.Pagination;
   export type PaginationMeta = API.PaginationMeta;
   export type PermissionSet = API.PermissionSet;
-  export type Socks5 = API.Socks5;
+  export type Socks5ProxyConfig = API.Socks5ProxyConfig;
 }

package/src/core/streaming.ts

@@ -0,0 +1,315 @@
+import { MobilerunError } from './error';
+import { type ReadableStream } from '../internal/shim-types';
+import { makeReadableStream } from '../internal/shims';
+import { findDoubleNewlineIndex, LineDecoder } from '../internal/decoders/line';
+import { ReadableStreamToAsyncIterable } from '../internal/shims';
+import { isAbortError } from '../internal/errors';
+import { encodeUTF8 } from '../internal/utils/bytes';
+import { loggerFor } from '../internal/utils/log';
+import type { Mobilerun } from '../client';
+
+type Bytes = string | ArrayBuffer | Uint8Array | null | undefined;
+
+export type ServerSentEvent = {
+  event: string | null;
+  data: string;
+  raw: string[];
+};
+
+export class Stream<Item> implements AsyncIterable<Item> {
+  controller: AbortController;
+  #client: Mobilerun | undefined;
+
+  constructor(
+    private iterator: () => AsyncIterator<Item>,
+    controller: AbortController,
+    client?: Mobilerun,
+  ) {
+    this.controller = controller;
+    this.#client = client;
+  }
+
+  static fromSSEResponse<Item>(
+    response: Response,
+    controller: AbortController,
+    client?: Mobilerun,
+  ): Stream<Item> {
+    let consumed = false;
+    const logger = client ? loggerFor(client) : console;
+
+    async function* iterator(): AsyncIterator<Item, any, undefined> {
+      if (consumed) {
+        throw new MobilerunError('Cannot iterate over a consumed stream, use `.tee()` to split the stream.');
+      }
+      consumed = true;
+      let done = false;
+      try {
+        for await (const sse of _iterSSEMessages(response, controller)) {
+          try {
+            yield JSON.parse(sse.data) as Item;
+          } catch (e) {
+            logger.error(`Could not parse message into JSON:`, sse.data);
+            logger.error(`From chunk:`, sse.raw);
+            throw e;
+          }
+        }
+        done = true;
+      } catch (e) {
+        // If the user calls `stream.controller.abort()`, we should exit without throwing.
+        if (isAbortError(e)) return;
+        throw e;
+      } finally {
+        // If the user `break`s, abort the ongoing request.
+        if (!done) controller.abort();
+      }
+    }
+
+    return new Stream(iterator, controller, client);
+  }
+
+  /**
+   * Generates a Stream from a newline-separated ReadableStream
+   * where each item is a JSON value.
+   */
+  static fromReadableStream<Item>(
+    readableStream: ReadableStream,
+    controller: AbortController,
+    client?: Mobilerun,
+  ): Stream<Item> {
+    let consumed = false;
+
+    async function* iterLines(): AsyncGenerator<string, void, unknown> {
+      const lineDecoder = new LineDecoder();
+
+      const iter = ReadableStreamToAsyncIterable<Bytes>(readableStream);
+      for await (const chunk of iter) {
+        for (const line of lineDecoder.decode(chunk)) {
+          yield line;
+        }
+      }
+
+      for (const line of lineDecoder.flush()) {
+        yield line;
+      }
+    }
+
+    async function* iterator(): AsyncIterator<Item, any, undefined> {
+      if (consumed) {
+        throw new MobilerunError('Cannot iterate over a consumed stream, use `.tee()` to split the stream.');
+      }
+      consumed = true;
+      let done = false;
+      try {
+        for await (const line of iterLines()) {
+          if (done) continue;
+          if (line) yield JSON.parse(line) as Item;
+        }
+        done = true;
+      } catch (e) {
+        // If the user calls `stream.controller.abort()`, we should exit without throwing.
+        if (isAbortError(e)) return;
+        throw e;
+      } finally {
+        // If the user `break`s, abort the ongoing request.
+        if (!done) controller.abort();
+      }
+    }
+
+    return new Stream(iterator, controller, client);
+  }
+
+  [Symbol.asyncIterator](): AsyncIterator<Item> {
+    return this.iterator();
+  }
+
+  /**
+   * Splits the stream into two streams which can be
+   * independently read from at different speeds.
+   */
+  tee(): [Stream<Item>, Stream<Item>] {
+    const left: Array<Promise<IteratorResult<Item>>> = [];
+    const right: Array<Promise<IteratorResult<Item>>> = [];
+    const iterator = this.iterator();
+
+    const teeIterator = (queue: Array<Promise<IteratorResult<Item>>>): AsyncIterator<Item> => {
+      return {
+        next: () => {
+          if (queue.length === 0) {
+            const result = iterator.next();
+            left.push(result);
+            right.push(result);
+          }
+          return queue.shift()!;
+        },
+      };
+    };
+
+    return [
+      new Stream(() => teeIterator(left), this.controller, this.#client),
+      new Stream(() => teeIterator(right), this.controller, this.#client),
+    ];
+  }
+
+  /**
+   * Converts this stream to a newline-separated ReadableStream of
+   * JSON stringified values in the stream
+   * which can be turned back into a Stream with `Stream.fromReadableStream()`.
+   */
+  toReadableStream(): ReadableStream {
+    const self = this;
+    let iter: AsyncIterator<Item>;
+
+    return makeReadableStream({
+      async start() {
+        iter = self[Symbol.asyncIterator]();
+      },
+      async pull(ctrl: any) {
+        try {
+          const { value, done } = await iter.next();
+          if (done) return ctrl.close();
+
+          const bytes = encodeUTF8(JSON.stringify(value) + '\n');
+
+          ctrl.enqueue(bytes);
+        } catch (err) {
+          ctrl.error(err);
+        }
+      },
+      async cancel() {
+        await iter.return?.();
+      },
+    });
+  }
+}
+
+export async function* _iterSSEMessages(
+  response: Response,
+  controller: AbortController,
+): AsyncGenerator<ServerSentEvent, void, unknown> {
+  if (!response.body) {
+    controller.abort();
+    if (
+      typeof (globalThis as any).navigator !== 'undefined' &&
+      (globalThis as any).navigator.product === 'ReactNative'
+    ) {
+      throw new MobilerunError(
+        `The default react-native fetch implementation does not support streaming. Please use expo/fetch: https://docs.expo.dev/versions/latest/sdk/expo/#expofetch-api`,
+      );
+    }
+    throw new MobilerunError(`Attempted to iterate over a response with no body`);
+  }
+
+  const sseDecoder = new SSEDecoder();
+  const lineDecoder = new LineDecoder();
+
+  const iter = ReadableStreamToAsyncIterable<Bytes>(response.body);
+  for await (const sseChunk of iterSSEChunks(iter)) {
+    for (const line of lineDecoder.decode(sseChunk)) {
+      const sse = sseDecoder.decode(line);
+      if (sse) yield sse;
+    }
+  }
+
+  for (const line of lineDecoder.flush()) {
+    const sse = sseDecoder.decode(line);
+    if (sse) yield sse;
+  }
+}
+
+/**
+ * Given an async iterable iterator, iterates over it and yields full
+ * SSE chunks, i.e. yields when a double new-line is encountered.
+ */
+async function* iterSSEChunks(iterator: AsyncIterableIterator<Bytes>): AsyncGenerator<Uint8Array> {
+  let data = new Uint8Array();
+
+  for await (const chunk of iterator) {
+    if (chunk == null) {
+      continue;
+    }
+
+    const binaryChunk =
+      chunk instanceof ArrayBuffer ? new Uint8Array(chunk)
+      : typeof chunk === 'string' ? encodeUTF8(chunk)
+      : chunk;
+
+    let newData = new Uint8Array(data.length + binaryChunk.length);
+    newData.set(data);
+    newData.set(binaryChunk, data.length);
+    data = newData;
+
+    let patternIndex;
+    while ((patternIndex = findDoubleNewlineIndex(data)) !== -1) {
+      yield data.slice(0, patternIndex);
+      data = data.slice(patternIndex);
+    }
+  }
+
+  if (data.length > 0) {
+    yield data;
+  }
+}
+
+class SSEDecoder {
+  private data: string[];
+  private event: string | null;
+  private chunks: string[];
+
+  constructor() {
+    this.event = null;
+    this.data = [];
+    this.chunks = [];
+  }
+
+  decode(line: string) {
+    if (line.endsWith('\r')) {
+      line = line.substring(0, line.length - 1);
+    }
+
+    if (!line) {
+      // empty line and we didn't previously encounter any messages
+      if (!this.event && !this.data.length) return null;
+
+      const sse: ServerSentEvent = {
+        event: this.event,
+        data: this.data.join('\n'),
+        raw: this.chunks,
+      };
+
+      this.event = null;
+      this.data = [];
+      this.chunks = [];
+
+      return sse;
+    }
+
+    this.chunks.push(line);
+
+    if (line.startsWith(':')) {
+      return null;
+    }
+
+    let [fieldname, _, value] = partition(line, ':');
+
+    if (value.startsWith(' ')) {
+      value = value.substring(1);
+    }
+
+    if (fieldname === 'event') {
+      this.event = value;
+    } else if (fieldname === 'data') {
+      this.data.push(value);
+    }
+
+    return null;
+  }
+}
+
+function partition(str: string, delimiter: string): [string, string, string] {
+  const index = str.indexOf(delimiter);
+  if (index !== -1) {
+    return [str.substring(0, index), delimiter, str.substring(index + delimiter.length)];
+  }
+
+  return [str, '', ''];
+}