agent-device 0.7.21 → 0.7.22

package/dist/src/index.d.ts

@@ -0,0 +1,4 @@
+export { createAgentDeviceClient, type AgentDeviceClient, type AgentDeviceClientConfig, type AgentDeviceDevice, type AgentDeviceIdentifiers, type AgentDeviceSelectionOptions, type AgentDeviceSession, type AgentDeviceSessionDevice, type AppCloseOptions, type AppCloseResult, type AppDeployOptions, type AppDeployResult, type AppInstallFromSourceOptions, type AppInstallFromSourceResult, type AppOpenOptions, type AppOpenResult, type CaptureScreenshotOptions, type CaptureScreenshotResult, type CaptureSnapshotOptions, type CaptureSnapshotResult, type EnsureSimulatorOptions, type EnsureSimulatorResult, type MaterializationReleaseOptions, type MaterializationReleaseResult, type RuntimeResult, type RuntimeSetOptions, type RuntimeShowOptions, type SessionCloseResult, type StartupPerfSample, } from './client.ts';
+export { AppError, type NormalizedError } from './utils/errors.ts';
+export type { SessionRuntimeHints } from './daemon/types.ts';
+export type { SnapshotNode } from './utils/snapshot.ts';

package/dist/src/index.js

@@ -0,0 +1 @@
+export{AppError}from"./331.js";export{createAgentDeviceClient}from"./224.js";

package/dist/src/platforms/android/adb.d.ts

@@ -0,0 +1,5 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+export declare function adbArgs(device: DeviceInfo, args: string[]): string[];
+export declare function ensureAdb(): Promise<void>;
+export declare function isClipboardShellUnsupported(stdout: string, stderr: string): boolean;
+export declare function sleep(ms: number): Promise<void>;

package/dist/src/platforms/android/app-lifecycle.d.ts

@@ -0,0 +1,30 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+export declare function resolveAndroidApp(device: DeviceInfo, app: string): Promise<{
+    type: 'intent' | 'package';
+    value: string;
+}>;
+export declare function listAndroidApps(device: DeviceInfo, filter?: 'user-installed' | 'all'): Promise<Array<{
+    package: string;
+    name: string;
+}>>;
+export declare function inferAndroidAppName(packageName: string): string;
+export declare function getAndroidAppState(device: DeviceInfo): Promise<{
+    package?: string;
+    activity?: string;
+}>;
+export declare function openAndroidApp(device: DeviceInfo, app: string, activity?: string): Promise<void>;
+export declare function isAmStartError(stdout: string, stderr: string): boolean;
+export declare function parseAndroidLaunchComponent(stdout: string): string | null;
+export declare function openAndroidDevice(device: DeviceInfo): Promise<void>;
+export declare function closeAndroidApp(device: DeviceInfo, app: string): Promise<void>;
+export declare function installAndroidInstallablePath(device: DeviceInfo, installablePath: string): Promise<void>;
+export declare function installAndroidApp(device: DeviceInfo, appPath: string): Promise<{
+    archivePath?: string;
+    installablePath: string;
+    packageName?: string;
+    appName?: string;
+    launchTarget?: string;
+}>;
+export declare function reinstallAndroidApp(device: DeviceInfo, app: string, appPath: string): Promise<{
+    package: string;
+}>;

package/dist/src/platforms/android/device-input-state.d.ts

@@ -0,0 +1,19 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+type AndroidKeyboardType = 'text' | 'number' | 'email' | 'phone' | 'password' | 'datetime' | 'unknown';
+export type AndroidKeyboardState = {
+    visible: boolean;
+    inputType?: string;
+    type?: AndroidKeyboardType;
+};
+export declare function getAndroidKeyboardState(device: DeviceInfo): Promise<AndroidKeyboardState>;
+export declare function dismissAndroidKeyboard(device: DeviceInfo): Promise<{
+    attempts: number;
+    wasVisible: boolean;
+    dismissed: boolean;
+    visible: boolean;
+    inputType?: string;
+    type?: AndroidKeyboardType;
+}>;
+export declare function readAndroidClipboardText(device: DeviceInfo): Promise<string>;
+export declare function writeAndroidClipboardText(device: DeviceInfo, text: string): Promise<void>;
+export {};

package/dist/src/platforms/android/devices.d.ts

@@ -0,0 +1,22 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+type AndroidDeviceDiscoveryOptions = {
+    serialAllowlist?: ReadonlySet<string>;
+};
+export declare function parseAndroidTargetFromCharacteristics(rawOutput: string): 'tv' | null;
+export declare function parseAndroidFeatureListForTv(rawOutput: string): boolean;
+export declare function listAndroidDevices(options?: AndroidDeviceDiscoveryOptions): Promise<DeviceInfo[]>;
+export declare function parseAndroidAvdList(rawOutput: string): string[];
+export declare function resolveAndroidAvdName(avdNames: string[], requestedName: string): string | undefined;
+export declare function ensureAndroidEmulatorBooted(params: {
+    avdName: string;
+    serial?: string;
+    timeoutMs?: number;
+    headless?: boolean;
+}): Promise<DeviceInfo>;
+export declare function ensureAndroidEmulatorHeadlessBooted(params: {
+    avdName: string;
+    serial?: string;
+    timeoutMs?: number;
+}): Promise<DeviceInfo>;
+export declare function waitForAndroidBoot(serial: string, timeoutMs?: number): Promise<void>;
+export {};

package/dist/src/platforms/android/index.d.ts

@@ -0,0 +1,7 @@
+export { ensureAdb } from './adb.ts';
+export { resolveAndroidApp, listAndroidApps, inferAndroidAppName, getAndroidAppState, openAndroidApp, isAmStartError, parseAndroidLaunchComponent, openAndroidDevice, closeAndroidApp, installAndroidInstallablePath, installAndroidApp, reinstallAndroidApp, } from './app-lifecycle.ts';
+export { pressAndroid, swipeAndroid, backAndroid, homeAndroid, appSwitcherAndroid, longPressAndroid, typeAndroid, focusAndroid, fillAndroid, scrollAndroid, scrollIntoViewAndroid, } from './input-actions.ts';
+export { type AndroidKeyboardState, getAndroidKeyboardState, dismissAndroidKeyboard, readAndroidClipboardText, writeAndroidClipboardText, } from './device-input-state.ts';
+export { setAndroidSetting } from './settings.ts';
+export { pushAndroidNotification } from './notifications.ts';
+export { snapshotAndroid, screenshotAndroid } from './snapshot.ts';

package/dist/src/platforms/android/input-actions.d.ts

@@ -0,0 +1,12 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+export declare function pressAndroid(device: DeviceInfo, x: number, y: number): Promise<void>;
+export declare function swipeAndroid(device: DeviceInfo, x1: number, y1: number, x2: number, y2: number, durationMs?: number): Promise<void>;
+export declare function backAndroid(device: DeviceInfo): Promise<void>;
+export declare function homeAndroid(device: DeviceInfo): Promise<void>;
+export declare function appSwitcherAndroid(device: DeviceInfo): Promise<void>;
+export declare function longPressAndroid(device: DeviceInfo, x: number, y: number, durationMs?: number): Promise<void>;
+export declare function typeAndroid(device: DeviceInfo, text: string): Promise<void>;
+export declare function focusAndroid(device: DeviceInfo, x: number, y: number): Promise<void>;
+export declare function fillAndroid(device: DeviceInfo, x: number, y: number, text: string): Promise<void>;
+export declare function scrollAndroid(device: DeviceInfo, direction: string, amount?: number): Promise<void>;
+export declare function scrollIntoViewAndroid(device: DeviceInfo, text: string): Promise<void>;

package/dist/src/platforms/android/install-artifact.d.ts

@@ -0,0 +1,11 @@
+import { type MaterializeInstallSource } from '../install-source.ts';
+export type PreparedAndroidInstallArtifact = {
+    archivePath?: string;
+    installablePath: string;
+    packageName?: string;
+    cleanup: () => Promise<void>;
+};
+export declare function prepareAndroidInstallArtifact(source: MaterializeInstallSource, options?: {
+    signal?: AbortSignal;
+    resolveIdentity?: boolean;
+}): Promise<PreparedAndroidInstallArtifact>;

package/dist/src/platforms/android/manifest.d.ts

@@ -0,0 +1 @@
+export declare function resolveAndroidArchivePackageName(archivePath: string): Promise<string | undefined>;

package/dist/src/platforms/android/notifications.d.ts

@@ -0,0 +1,11 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+type AndroidBroadcastPayload = {
+    action?: string;
+    receiver?: string;
+    extras?: Record<string, unknown>;
+};
+export declare function pushAndroidNotification(device: DeviceInfo, packageName: string, payload: AndroidBroadcastPayload): Promise<{
+    action: string;
+    extrasCount: number;
+}>;
+export {};

package/dist/src/platforms/android/open-target.d.ts

@@ -0,0 +1,4 @@
+export type AndroidAppTargetKind = 'package' | 'binary' | 'other';
+export declare function classifyAndroidAppTarget(target: string): AndroidAppTargetKind;
+export declare function looksLikeAndroidPackageName(value: string): boolean;
+export declare function formatAndroidInstalledPackageRequiredMessage(target: string): string;

package/dist/src/platforms/android/settings.d.ts

@@ -0,0 +1,3 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+import { type PermissionSettingOptions } from '../permission-utils.ts';
+export declare function setAndroidSetting(device: DeviceInfo, setting: string, state: string, appPackage?: string, options?: PermissionSettingOptions): Promise<void>;

package/dist/src/platforms/android/snapshot.d.ts

@@ -0,0 +1,8 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+import type { RawSnapshotNode, SnapshotOptions } from '../../utils/snapshot.ts';
+export declare function snapshotAndroid(device: DeviceInfo, options?: SnapshotOptions): Promise<{
+    nodes: RawSnapshotNode[];
+    truncated?: boolean;
+}>;
+export declare function screenshotAndroid(device: DeviceInfo, outPath: string): Promise<void>;
+export declare function dumpUiHierarchy(device: DeviceInfo): Promise<string>;

package/dist/src/platforms/android/ui-hierarchy.d.ts

@@ -0,0 +1,21 @@
+import type { RawSnapshotNode, Rect, SnapshotOptions } from '../../utils/snapshot.ts';
+export declare function findBounds(xml: string, query: string): {
+    x: number;
+    y: number;
+} | null;
+export declare function parseUiHierarchy(xml: string, maxNodes: number, options: SnapshotOptions): {
+    nodes: RawSnapshotNode[];
+    truncated?: boolean;
+};
+export declare function readNodeAttributes(node: string): {
+    text: string | null;
+    desc: string | null;
+    resourceId: string | null;
+    className: string | null;
+    bounds: string | null;
+    clickable?: boolean;
+    enabled?: boolean;
+    focusable?: boolean;
+    focused?: boolean;
+};
+export declare function parseBounds(bounds: string | null): Rect | undefined;

package/dist/src/platforms/appearance.d.ts

@@ -0,0 +1,2 @@
+export type AppearanceAction = 'light' | 'dark' | 'toggle';
+export declare function parseAppearanceAction(state: string): AppearanceAction;

package/dist/src/platforms/boot-diagnostics.d.ts

@@ -0,0 +1,14 @@
+type BootFailureReason = 'IOS_BOOT_TIMEOUT' | 'IOS_RUNNER_CONNECT_TIMEOUT' | 'IOS_TOOL_MISSING' | 'ANDROID_BOOT_TIMEOUT' | 'ADB_TRANSPORT_UNAVAILABLE' | 'CI_RESOURCE_STARVATION_SUSPECTED' | 'BOOT_COMMAND_FAILED' | 'UNKNOWN';
+type BootDiagnosticContext = {
+    platform?: 'ios' | 'android';
+    phase?: 'boot' | 'connect' | 'transport';
+};
+export declare function classifyBootFailure(input: {
+    error?: unknown;
+    message?: string;
+    stdout?: string;
+    stderr?: string;
+    context?: BootDiagnosticContext;
+}): BootFailureReason;
+export declare function bootFailureHint(reason: BootFailureReason): string;
+export {};

package/dist/src/platforms/install-source.d.ts

@@ -0,0 +1,26 @@
+export type MaterializeInstallSource = {
+    kind: 'url';
+    url: string;
+    headers?: Record<string, string>;
+} | {
+    kind: 'path';
+    path: string;
+};
+type MaterializeInstallableOptions = {
+    source: MaterializeInstallSource;
+    isInstallablePath: (candidatePath: string, stat: {
+        isFile(): boolean;
+        isDirectory(): boolean;
+    }) => boolean;
+    installableLabel: string;
+    signal?: AbortSignal;
+    downloadTimeoutMs?: number;
+};
+export type MaterializedInstallable = {
+    archivePath?: string;
+    installablePath: string;
+    cleanup: () => Promise<void>;
+};
+export declare function materializeInstallablePath(options: MaterializeInstallableOptions): Promise<MaterializedInstallable>;
+export declare function expandSourcePath(inputPath: string): string;
+export {};

package/dist/src/platforms/ios/apps.d.ts

@@ -0,0 +1,34 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+import { type PermissionSettingOptions } from '../permission-utils.ts';
+import { type IosAppInfo } from './devicectl.ts';
+export { screenshotIos, shouldFallbackToRunnerForIosScreenshot, shouldRetryIosSimulatorScreenshot, } from './screenshot.ts';
+type InstallIosAppOptions = {
+    appIdentifierHint?: string;
+};
+export declare function resolveIosApp(device: DeviceInfo, app: string): Promise<string>;
+export declare function openIosApp(device: DeviceInfo, app: string, options?: {
+    appBundleId?: string;
+    url?: string;
+}): Promise<void>;
+export declare function openIosDevice(device: DeviceInfo): Promise<void>;
+export declare function closeIosApp(device: DeviceInfo, app: string): Promise<void>;
+export declare function uninstallIosApp(device: DeviceInfo, app: string): Promise<{
+    bundleId: string;
+}>;
+export declare function installIosApp(device: DeviceInfo, appPath: string, options?: InstallIosAppOptions): Promise<{
+    archivePath?: string;
+    installablePath: string;
+    bundleId?: string;
+    appName?: string;
+    launchTarget?: string;
+}>;
+export declare function reinstallIosApp(device: DeviceInfo, app: string, appPath: string): Promise<{
+    bundleId: string;
+}>;
+export declare function installIosInstallablePath(device: DeviceInfo, installablePath: string): Promise<void>;
+export declare function readIosClipboardText(device: DeviceInfo): Promise<string>;
+export declare function writeIosClipboardText(device: DeviceInfo, text: string): Promise<void>;
+export declare function pushIosNotification(device: DeviceInfo, bundleId: string, payload: Record<string, unknown>): Promise<void>;
+export declare function setIosSetting(device: DeviceInfo, setting: string, state: string, appBundleId?: string, options?: PermissionSettingOptions): Promise<void>;
+export declare function listIosApps(device: DeviceInfo, filter?: 'user-installed' | 'all'): Promise<IosAppInfo[]>;
+export declare function listSimulatorApps(device: DeviceInfo): Promise<IosAppInfo[]>;

package/dist/src/platforms/ios/config.d.ts

@@ -0,0 +1,9 @@
+export declare const IOS_BOOT_TIMEOUT_MS: number;
+export declare const IOS_SIMCTL_LIST_TIMEOUT_MS: number;
+export declare const IOS_APP_LAUNCH_TIMEOUT_MS: number;
+export declare const IOS_DEVICECTL_TIMEOUT_MS: number;
+export declare const IOS_SIMULATOR_SCREENSHOT_TIMEOUT_MS: number;
+export declare const IOS_RUNNER_SCREENSHOT_COPY_TIMEOUT_MS: number;
+export declare const IOS_SIMULATOR_SCREENSHOT_RETRY_MAX_ATTEMPTS = 5;
+export declare const IOS_SIMULATOR_SCREENSHOT_RETRY_BASE_DELAY_MS = 1000;
+export declare const IOS_SIMULATOR_SCREENSHOT_RETRY_MAX_DELAY_MS = 5000;

package/dist/src/platforms/ios/devicectl.d.ts

@@ -0,0 +1,13 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+export type IosAppInfo = {
+    bundleId: string;
+    name: string;
+};
+export declare function runIosDevicectl(args: string[], context: {
+    action: string;
+    deviceId: string;
+}): Promise<void>;
+export declare function listIosDeviceApps(device: DeviceInfo, filter: 'user-installed' | 'all'): Promise<IosAppInfo[]>;
+export declare function parseIosDeviceAppsPayload(payload: unknown): IosAppInfo[];
+export declare const IOS_DEVICECTL_DEFAULT_HINT = "Ensure the iOS device is unlocked, trusted, and available in Xcode > Devices, then retry.";
+export declare function resolveIosDevicectlHint(stdout: string, stderr: string): string | null;

package/dist/src/platforms/ios/devices.d.ts

@@ -0,0 +1,39 @@
+import type { DeviceInfo, DeviceTarget } from '../../utils/device.ts';
+type DevicectlAppleDevice = {
+    identifier?: string;
+    name?: string;
+    hardwareProperties?: {
+        platform?: string;
+        udid?: string;
+        productType?: string;
+    };
+    deviceProperties?: {
+        name?: string;
+        productType?: string;
+        deviceType?: string;
+    };
+    connectionProperties?: {
+        tunnelState?: string;
+    };
+};
+type IosDeviceDiscoveryOptions = {
+    simulatorSetPath?: string;
+};
+export declare function isAppleProductType(productType: string): boolean;
+export declare function isAppleTvProductType(productType: string): boolean;
+export declare function resolveAppleTargetFromDevicectlDevice(device: DevicectlAppleDevice): DeviceTarget;
+export declare function isSupportedAppleDevicectlDevice(device: DevicectlAppleDevice): boolean;
+type FindBootableSimulatorOptions = IosDeviceDiscoveryOptions & {
+    target?: DeviceTarget;
+};
+/**
+ * Finds an available iOS simulator by querying simctl directly.  This is used
+ * as a fallback when `listIosDevices` returned no simulators (e.g. all filtered
+ * out) or only a physical device.  Only simulators with `isAvailable: true` are
+ * considered so the caller can safely boot the result.
+ *
+ * Returns `null` when no suitable simulator can be found.
+ */
+export declare function findBootableIosSimulator(options?: FindBootableSimulatorOptions): Promise<DeviceInfo | null>;
+export declare function listIosDevices(options?: IosDeviceDiscoveryOptions): Promise<DeviceInfo[]>;
+export {};

package/dist/src/platforms/ios/ensure-simulator.d.ts

@@ -0,0 +1,18 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+export type EnsureSimulatorResult = {
+    udid: string;
+    device: string;
+    runtime: string;
+    created: boolean;
+    booted: boolean;
+};
+type EnsureSimulatorOptions = {
+    deviceName: string;
+    runtime?: string;
+    simulatorSetPath?: string | null;
+    reuseExisting: boolean;
+    boot: boolean;
+    ensureReady: (device: DeviceInfo) => Promise<void>;
+};
+export declare function ensureSimulatorExists(options: EnsureSimulatorOptions): Promise<EnsureSimulatorResult>;
+export {};

package/dist/src/platforms/ios/index.d.ts

@@ -0,0 +1,3 @@
+export { closeIosApp, installIosApp, installIosInstallablePath, listIosApps, listSimulatorApps, openIosApp, openIosDevice, pushIosNotification, readIosClipboardText, reinstallIosApp, resolveIosApp, screenshotIos, setIosSetting, uninstallIosApp, writeIosClipboardText, } from './apps.ts';
+export { ensureBootedSimulator } from './simulator.ts';
+export { parseIosDeviceAppsPayload, type IosAppInfo, } from './devicectl.ts';

package/dist/src/platforms/ios/install-artifact.d.ts

@@ -0,0 +1,18 @@
+import { type MaterializeInstallSource } from '../install-source.ts';
+type InstallIosArtifactOptions = {
+    appIdentifierHint?: string;
+    signal?: AbortSignal;
+};
+export type PreparedIosInstallArtifact = {
+    archivePath?: string;
+    installablePath: string;
+    bundleId?: string;
+    appName?: string;
+    cleanup: () => Promise<void>;
+};
+export declare function prepareIosInstallArtifact(source: MaterializeInstallSource, options?: InstallIosArtifactOptions): Promise<PreparedIosInstallArtifact>;
+export declare function readIosBundleInfo(appBundlePath: string): Promise<{
+    bundleId?: string;
+    appName?: string;
+}>;
+export {};

package/dist/src/platforms/ios/launch-diagnostics.d.ts

@@ -0,0 +1,11 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+export type LaunchFailureReason = 'ARCH_MISMATCH' | 'APP_NOT_INSTALLED' | 'PERSISTENT_LAUNCH_FAIL' | 'UNKNOWN';
+type LaunchProbeResult = {
+    installed: boolean;
+    simulatorCompatible?: boolean;
+};
+export declare function isSimulatorLaunchFBSError(error: unknown): boolean;
+export declare function probeSimulatorLaunchContext(device: DeviceInfo, bundleId: string): Promise<LaunchProbeResult>;
+export declare function classifyLaunchFailure(probe: LaunchProbeResult): LaunchFailureReason;
+export declare function launchFailureHint(reason: LaunchFailureReason): string;
+export {};

package/dist/src/platforms/ios/plist.d.ts

@@ -0,0 +1 @@
+export declare function readInfoPlistString(infoPlistPath: string, key: string): Promise<string | undefined>;

package/dist/src/platforms/ios/runner-client.d.ts

@@ -0,0 +1,36 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+export type RunnerCommand = {
+    command: 'tap' | 'tapSeries' | 'longPress' | 'drag' | 'dragSeries' | 'type' | 'swipe' | 'findText' | 'snapshot' | 'screenshot' | 'back' | 'home' | 'appSwitcher' | 'alert' | 'pinch' | 'recordStart' | 'recordStop' | 'shutdown';
+    appBundleId?: string;
+    text?: string;
+    action?: 'get' | 'accept' | 'dismiss';
+    x?: number;
+    y?: number;
+    count?: number;
+    intervalMs?: number;
+    doubleTap?: boolean;
+    pauseMs?: number;
+    pattern?: 'one-way' | 'ping-pong';
+    x2?: number;
+    y2?: number;
+    durationMs?: number;
+    direction?: 'up' | 'down' | 'left' | 'right';
+    scale?: number;
+    outPath?: string;
+    fps?: number;
+    interactiveOnly?: boolean;
+    compact?: boolean;
+    depth?: number;
+    scope?: string;
+    raw?: boolean;
+    clearFirst?: boolean;
+};
+export declare function runIosRunnerCommand(device: DeviceInfo, command: RunnerCommand, options?: {
+    verbose?: boolean;
+    logPath?: string;
+    traceLogPath?: string;
+    requestId?: string;
+}): Promise<Record<string, unknown>>;
+export { isRetryableRunnerError, shouldRetryRunnerConnectError, resolveRunnerEarlyExitHint, } from './runner-errors.ts';
+export { resolveRunnerDestination, resolveRunnerBuildDestination, resolveRunnerMaxConcurrentDestinationsFlag, resolveRunnerSigningBuildSettings, resolveRunnerBundleBuildSettings, assertSafeDerivedCleanup, IOS_RUNNER_CONTAINER_BUNDLE_IDS, } from './runner-xctestrun.ts';
+export { stopIosRunnerSession, abortAllIosRunnerSessions, stopAllIosRunnerSessions, } from './runner-session.ts';

package/dist/src/platforms/ios/runner-errors.d.ts

@@ -0,0 +1,20 @@
+import { AppError } from '../../utils/errors.ts';
+import type { RunnerCommand } from './runner-client.ts';
+import type { RunnerSession } from './runner-session.ts';
+export declare function isRetryableRunnerError(err: unknown): boolean;
+export declare function shouldRetryRunnerConnectError(error: unknown): boolean;
+export declare function resolveRunnerEarlyExitHint(message: string, stdout: string, stderr: string): string;
+export declare function buildRunnerConnectError(params: {
+    port: number;
+    endpoints: string[];
+    logPath?: string;
+    lastError: unknown;
+}): AppError;
+export declare function buildRunnerEarlyExitError(params: {
+    session: RunnerSession;
+    port: number;
+    logPath?: string;
+}): Promise<AppError>;
+export declare function resolveSigningFailureHint(error: AppError): string | undefined;
+export declare function isReadOnlyRunnerCommand(command: RunnerCommand['command']): boolean;
+export declare function assertRunnerRequestActive(requestId: string | undefined): void;

package/dist/src/platforms/ios/runner-session.d.ts

@@ -0,0 +1,25 @@
+import { type ExecResult, type ExecBackgroundResult } from '../../utils/exec.ts';
+import type { DeviceInfo } from '../../utils/device.ts';
+import type { RunnerCommand } from './runner-client.ts';
+export type RunnerSession = {
+    device: DeviceInfo;
+    deviceId: string;
+    port: number;
+    xctestrunPath: string;
+    jsonPath: string;
+    testPromise: Promise<ExecResult>;
+    child: ExecBackgroundResult['child'];
+    ready: boolean;
+};
+export declare function ensureRunnerSession(device: DeviceInfo, options: {
+    verbose?: boolean;
+    logPath?: string;
+    traceLogPath?: string;
+}): Promise<RunnerSession>;
+export declare function stopRunnerSession(session: RunnerSession): Promise<void>;
+export declare function stopIosRunnerSession(deviceId: string): Promise<void>;
+export declare function abortAllIosRunnerSessions(): Promise<void>;
+export declare function stopAllIosRunnerSessions(): Promise<void>;
+export declare function validateRunnerDevice(device: DeviceInfo): void;
+export declare function executeRunnerCommandWithSession(device: DeviceInfo, session: RunnerSession, command: RunnerCommand, logPath: string | undefined, timeoutMs: number, signal?: AbortSignal): Promise<Record<string, unknown>>;
+export declare function parseRunnerResponse(response: Response, session: RunnerSession, logPath?: string): Promise<Record<string, unknown>>;

package/dist/src/platforms/ios/runner-transport.d.ts

@@ -0,0 +1,10 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+import type { RunnerCommand } from './runner-client.ts';
+import type { RunnerSession } from './runner-session.ts';
+export declare const RUNNER_STARTUP_TIMEOUT_MS: number;
+export declare const RUNNER_COMMAND_TIMEOUT_MS: number;
+export declare const RUNNER_DESTINATION_TIMEOUT_SECONDS: number;
+export declare function waitForRunner(device: DeviceInfo, port: number, command: RunnerCommand, logPath?: string, timeoutMs?: number, session?: RunnerSession, signal?: AbortSignal): Promise<Response>;
+export declare function getFreePort(): Promise<number>;
+export declare function logChunk(chunk: string, logPath?: string, traceLogPath?: string, verbose?: boolean): void;
+export declare function cleanupTempFile(filePath: string): void;

package/dist/src/platforms/ios/runner-xctestrun.d.ts

@@ -0,0 +1,18 @@
+import { type DeviceInfo } from '../../utils/device.ts';
+export declare const runnerPrepProcesses: Set<import("child_process").ChildProcess>;
+export declare const IOS_RUNNER_CONTAINER_BUNDLE_IDS: string[];
+export declare function ensureXctestrun(device: DeviceInfo, options: {
+    verbose?: boolean;
+    logPath?: string;
+    traceLogPath?: string;
+}): Promise<string>;
+export declare function prepareXctestrunWithEnv(xctestrunPath: string, envVars: Record<string, string>, suffix: string): Promise<{
+    xctestrunPath: string;
+    jsonPath: string;
+}>;
+export declare function resolveRunnerDestination(device: DeviceInfo): string;
+export declare function resolveRunnerBuildDestination(device: DeviceInfo): string;
+export declare function resolveRunnerMaxConcurrentDestinationsFlag(device: DeviceInfo): string;
+export declare function resolveRunnerSigningBuildSettings(env?: NodeJS.ProcessEnv, forDevice?: boolean): string[];
+export declare function resolveRunnerBundleBuildSettings(env?: NodeJS.ProcessEnv): string[];
+export declare function assertSafeDerivedCleanup(derivedPath: string, env?: NodeJS.ProcessEnv): void;

package/dist/src/platforms/ios/screenshot.d.ts

@@ -0,0 +1,13 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+type SimulatorScreenshotFlowDeps = {
+    ensureBooted: (device: DeviceInfo) => Promise<void>;
+    captureWithRetry: (device: DeviceInfo, outPath: string) => Promise<void>;
+    captureWithRunner: (device: DeviceInfo, outPath: string, appBundleId?: string) => Promise<void>;
+    shouldFallbackToRunner: (error: unknown) => boolean;
+};
+export declare function screenshotIos(device: DeviceInfo, outPath: string, appBundleId?: string): Promise<void>;
+export declare function captureSimulatorScreenshotWithFallback(device: DeviceInfo, outPath: string, appBundleId?: string, deps?: SimulatorScreenshotFlowDeps): Promise<void>;
+export declare function resolveSimulatorRunnerScreenshotCandidatePaths(containerPath: string, remoteFileName: string): string[];
+export declare function shouldFallbackToRunnerForIosScreenshot(error: unknown): boolean;
+export declare function shouldRetryIosSimulatorScreenshot(error: unknown): boolean;
+export {};

package/dist/src/platforms/ios/simctl.d.ts

@@ -0,0 +1,7 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+type SimctlArgsOptions = {
+    simulatorSetPath?: string;
+};
+export declare function buildSimctlArgs(args: string[], options?: SimctlArgsOptions): string[];
+export declare function buildSimctlArgsForDevice(device: DeviceInfo, args: string[]): string[];
+export {};

package/dist/src/platforms/ios/simulator.d.ts

@@ -0,0 +1,11 @@
+import type { DeviceInfo } from '../../utils/device.ts';
+export declare function ensureSimulator(device: DeviceInfo, command: string): void;
+export declare function focusIosSimulatorWindow(): Promise<void>;
+export declare function ensureBootedSimulator(device: DeviceInfo): Promise<void>;
+export declare function shutdownSimulator(device: DeviceInfo): Promise<{
+    success: boolean;
+    exitCode: number;
+    stdout: string;
+    stderr: string;
+}>;
+export declare function getSimulatorState(deviceOrUdid: DeviceInfo | string): Promise<string | null>;

package/dist/src/platforms/permission-utils.d.ts

@@ -0,0 +1,9 @@
+export type PermissionAction = 'grant' | 'deny' | 'reset';
+export type PermissionTarget = 'camera' | 'microphone' | 'photos' | 'contacts' | 'contacts-limited' | 'notifications' | 'calendar' | 'location' | 'location-always' | 'media-library' | 'motion' | 'reminders' | 'siri';
+export type PermissionSettingOptions = {
+    permissionTarget?: string;
+    permissionMode?: string;
+};
+export declare const PERMISSION_TARGETS: readonly PermissionTarget[];
+export declare function parsePermissionAction(action: string): PermissionAction;
+export declare function parsePermissionTarget(value: string | undefined): PermissionTarget;

package/dist/src/upload-client.d.ts

@@ -0,0 +1,7 @@
+type UploadArtifactOptions = {
+    localPath: string;
+    baseUrl: string;
+    token: string;
+};
+export declare function uploadArtifact(options: UploadArtifactOptions): Promise<string>;
+export {};

package/dist/src/utils/args.d.ts

@@ -0,0 +1,15 @@
+import { type CliFlags } from './command-schema.ts';
+type ParsedArgs = {
+    command: string | null;
+    positionals: string[];
+    flags: CliFlags;
+    warnings: string[];
+};
+type ParseArgsOptions = {
+    strictFlags?: boolean;
+};
+export declare function parseArgs(argv: string[], options?: ParseArgsOptions): ParsedArgs;
+export declare function toDaemonFlags(flags: CliFlags): Omit<CliFlags, 'json' | 'help' | 'version'>;
+export declare function usage(): string;
+export declare function usageForCommand(command: string): string | null;
+export {};