agent-device 0.7.21 → 0.8.0

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

@@ -0,0 +1,267 @@
+import type { DaemonInstallSource, DaemonLockPolicy, DaemonRequest, DaemonResponse, SessionRuntimeHints } from './daemon/types.ts';
+import type { DeviceKind, DeviceTarget, Platform, PlatformSelector } from './utils/device.ts';
+import type { SnapshotNode } from './utils/snapshot.ts';
+type DaemonTransportMode = 'auto' | 'socket' | 'http';
+type DaemonServerMode = 'socket' | 'http' | 'dual';
+type SessionIsolationMode = 'none' | 'tenant';
+export type AgentDeviceDaemonTransport = (req: Omit<DaemonRequest, 'token'>) => Promise<DaemonResponse>;
+export type AgentDeviceClientConfig = {
+    session?: string;
+    lockPolicy?: DaemonLockPolicy;
+    lockPlatform?: PlatformSelector;
+    requestId?: string;
+    stateDir?: string;
+    daemonBaseUrl?: string;
+    daemonAuthToken?: string;
+    daemonTransport?: DaemonTransportMode;
+    daemonServerMode?: DaemonServerMode;
+    tenant?: string;
+    sessionIsolation?: SessionIsolationMode;
+    runId?: string;
+    leaseId?: string;
+    cwd?: string;
+    debug?: boolean;
+};
+export type AgentDeviceRequestOverrides = Pick<AgentDeviceClientConfig, 'session' | 'lockPolicy' | 'lockPlatform' | 'requestId' | 'tenant' | 'sessionIsolation' | 'runId' | 'leaseId' | 'cwd' | 'debug'>;
+export type AgentDeviceIdentifiers = {
+    session?: string;
+    deviceId?: string;
+    deviceName?: string;
+    udid?: string;
+    serial?: string;
+    appId?: string;
+    appBundleId?: string;
+    package?: string;
+};
+export type AgentDeviceSelectionOptions = {
+    platform?: PlatformSelector;
+    target?: DeviceTarget;
+    device?: string;
+    udid?: string;
+    serial?: string;
+    iosSimulatorDeviceSet?: string;
+    androidDeviceAllowlist?: string;
+};
+export type AgentDeviceDevice = {
+    platform: Platform;
+    target: DeviceTarget;
+    kind: DeviceKind;
+    id: string;
+    name: string;
+    booted?: boolean;
+    identifiers: AgentDeviceIdentifiers;
+    ios?: {
+        udid: string;
+    };
+    android?: {
+        serial: string;
+    };
+};
+export type AgentDeviceSessionDevice = {
+    platform: Platform;
+    target: DeviceTarget;
+    id: string;
+    name: string;
+    identifiers: AgentDeviceIdentifiers;
+    ios?: {
+        udid: string;
+        simulatorSetPath?: string | null;
+    };
+    android?: {
+        serial: string;
+    };
+};
+export type AgentDeviceSession = {
+    name: string;
+    createdAt: number;
+    device: AgentDeviceSessionDevice;
+    identifiers: AgentDeviceIdentifiers;
+};
+export type StartupPerfSample = {
+    durationMs: number;
+    measuredAt: string;
+    method: string;
+    appTarget?: string;
+    appBundleId?: string;
+};
+export type SessionCloseResult = {
+    session: string;
+    shutdown?: Record<string, unknown>;
+    identifiers: AgentDeviceIdentifiers;
+};
+export type EnsureSimulatorOptions = AgentDeviceRequestOverrides & {
+    device: string;
+    runtime?: string;
+    boot?: boolean;
+    reuseExisting?: boolean;
+    iosSimulatorDeviceSet?: string;
+};
+export type EnsureSimulatorResult = {
+    udid: string;
+    device: string;
+    runtime: string;
+    created: boolean;
+    booted: boolean;
+    iosSimulatorDeviceSet?: string | null;
+    identifiers: AgentDeviceIdentifiers;
+};
+export type AppDeployOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions & {
+    app: string;
+    appPath: string;
+};
+export type AppDeployResult = {
+    app: string;
+    appPath: string;
+    platform: Platform;
+    appId?: string;
+    bundleId?: string;
+    package?: string;
+    identifiers: AgentDeviceIdentifiers;
+};
+export type AppOpenOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions & {
+    app: string;
+    url?: string;
+    activity?: string;
+    relaunch?: boolean;
+    saveScript?: boolean | string;
+    noRecord?: boolean;
+    runtime?: SessionRuntimeHints;
+};
+export type AppOpenResult = {
+    session: string;
+    appName?: string;
+    appBundleId?: string;
+    appId?: string;
+    startup?: StartupPerfSample;
+    runtime?: SessionRuntimeHints;
+    device?: AgentDeviceSessionDevice;
+    identifiers: AgentDeviceIdentifiers;
+};
+export type AppCloseOptions = AgentDeviceRequestOverrides & {
+    app?: string;
+    shutdown?: boolean;
+};
+export type AppCloseResult = {
+    session: string;
+    closedApp?: string;
+    shutdown?: Record<string, unknown>;
+    identifiers: AgentDeviceIdentifiers;
+};
+export type AppInstallFromSourceOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions & {
+    source: DaemonInstallSource;
+    retainPaths?: boolean;
+    retentionMs?: number;
+};
+export type AppInstallFromSourceResult = {
+    appName?: string;
+    appId?: string;
+    bundleId?: string;
+    packageName?: string;
+    launchTarget: string;
+    installablePath?: string;
+    archivePath?: string;
+    materializationId?: string;
+    materializationExpiresAt?: string;
+    identifiers: AgentDeviceIdentifiers;
+};
+export type MaterializationReleaseOptions = AgentDeviceRequestOverrides & {
+    materializationId: string;
+};
+export type MaterializationReleaseResult = {
+    released: boolean;
+    materializationId: string;
+    identifiers: AgentDeviceIdentifiers;
+};
+export type RuntimeShowOptions = AgentDeviceRequestOverrides;
+export type RuntimeSetOptions = AgentDeviceRequestOverrides & {
+    platform?: PlatformSelector;
+    metroHost?: string;
+    metroPort?: number;
+    bundleUrl?: string;
+    launchUrl?: string;
+};
+export type RuntimeResult = {
+    session: string;
+    configured: boolean;
+    cleared?: boolean;
+    runtime?: SessionRuntimeHints;
+    identifiers: AgentDeviceIdentifiers;
+};
+export type CaptureSnapshotOptions = AgentDeviceRequestOverrides & AgentDeviceSelectionOptions & {
+    interactiveOnly?: boolean;
+    compact?: boolean;
+    depth?: number;
+    scope?: string;
+    raw?: boolean;
+};
+export type CaptureSnapshotResult = {
+    nodes: SnapshotNode[];
+    truncated: boolean;
+    appName?: string;
+    appBundleId?: string;
+    identifiers: AgentDeviceIdentifiers;
+};
+export type CaptureScreenshotOptions = AgentDeviceRequestOverrides & {
+    path?: string;
+};
+export type CaptureScreenshotResult = {
+    path: string;
+    identifiers: AgentDeviceIdentifiers;
+};
+export type InternalRequestOptions = AgentDeviceClientConfig & AgentDeviceSelectionOptions & {
+    simulatorRuntimeId?: string;
+    runtime?: SessionRuntimeHints;
+    boot?: boolean;
+    reuseExisting?: boolean;
+    activity?: string;
+    relaunch?: boolean;
+    shutdown?: boolean;
+    saveScript?: boolean | string;
+    noRecord?: boolean;
+    metroHost?: string;
+    metroPort?: number;
+    bundleUrl?: string;
+    launchUrl?: string;
+    interactiveOnly?: boolean;
+    compact?: boolean;
+    depth?: number;
+    scope?: string;
+    raw?: boolean;
+    installSource?: DaemonInstallSource;
+    retainMaterializedPaths?: boolean;
+    materializedPathRetentionMs?: number;
+    materializationId?: string;
+};
+export type AgentDeviceClient = {
+    devices: {
+        list: (options?: AgentDeviceRequestOverrides & AgentDeviceSelectionOptions) => Promise<AgentDeviceDevice[]>;
+    };
+    sessions: {
+        list: (options?: AgentDeviceRequestOverrides) => Promise<AgentDeviceSession[]>;
+        close: (options?: AgentDeviceRequestOverrides & {
+            shutdown?: boolean;
+        }) => Promise<SessionCloseResult>;
+    };
+    simulators: {
+        ensure: (options: EnsureSimulatorOptions) => Promise<EnsureSimulatorResult>;
+    };
+    apps: {
+        install: (options: AppDeployOptions) => Promise<AppDeployResult>;
+        reinstall: (options: AppDeployOptions) => Promise<AppDeployResult>;
+        installFromSource: (options: AppInstallFromSourceOptions) => Promise<AppInstallFromSourceResult>;
+        open: (options: AppOpenOptions) => Promise<AppOpenResult>;
+        close: (options?: AppCloseOptions) => Promise<AppCloseResult>;
+    };
+    materializations: {
+        release: (options: MaterializationReleaseOptions) => Promise<MaterializationReleaseResult>;
+    };
+    runtime: {
+        set: (options: RuntimeSetOptions) => Promise<RuntimeResult>;
+        show: (options?: RuntimeShowOptions) => Promise<RuntimeResult>;
+    };
+    capture: {
+        snapshot: (options?: CaptureSnapshotOptions) => Promise<CaptureSnapshotResult>;
+        screenshot: (options?: CaptureScreenshotOptions) => Promise<CaptureScreenshotResult>;
+    };
+};
+export {};

package/dist/src/client.d.ts

@@ -0,0 +1,5 @@
+import type { AgentDeviceClient, AgentDeviceClientConfig, AgentDeviceDaemonTransport } from './client-types.ts';
+export declare function createAgentDeviceClient(config?: AgentDeviceClientConfig, deps?: {
+    transport?: AgentDeviceDaemonTransport;
+}): AgentDeviceClient;
+export type { AgentDeviceClient, AgentDeviceClientConfig, AgentDeviceDaemonTransport, AgentDeviceDevice, AgentDeviceIdentifiers, AgentDeviceRequestOverrides, AgentDeviceSelectionOptions, AgentDeviceSession, AgentDeviceSessionDevice, AppCloseOptions, AppCloseResult, AppDeployOptions, AppDeployResult, AppInstallFromSourceOptions, AppInstallFromSourceResult, AppOpenOptions, AppOpenResult, CaptureScreenshotOptions, CaptureScreenshotResult, CaptureSnapshotOptions, CaptureSnapshotResult, EnsureSimulatorOptions, EnsureSimulatorResult, MaterializationReleaseOptions, MaterializationReleaseResult, RuntimeResult, RuntimeSetOptions, RuntimeShowOptions, SessionCloseResult, StartupPerfSample, } from './client-types.ts';

package/dist/src/core/app-events.d.ts

@@ -0,0 +1,8 @@
+import type { DeviceInfo } from '../utils/device.ts';
+type AppEventPayload = Record<string, unknown> | undefined;
+export declare function parseTriggerAppEventArgs(positionals: string[]): {
+    eventName: string;
+    payload: AppEventPayload;
+};
+export declare function resolveAppEventUrl(platform: DeviceInfo['platform'], eventName: string, payload?: AppEventPayload): string;
+export {};

package/dist/src/core/batch.d.ts

@@ -0,0 +1,17 @@
+import type { BatchStep, CommandFlags } from './dispatch.ts';
+export declare const DEFAULT_BATCH_MAX_STEPS = 100;
+export type NormalizedBatchStep = {
+    command: string;
+    positionals: string[];
+    flags: Partial<CommandFlags>;
+    runtime?: unknown;
+};
+export type BatchStepResult = {
+    step: number;
+    command: string;
+    ok: true;
+    data: Record<string, unknown>;
+    durationMs: number;
+};
+export declare function parseBatchStepsJson(raw: string): BatchStep[];
+export declare function validateAndNormalizeBatchSteps(steps: CommandFlags['batchSteps'], maxSteps: number): NormalizedBatchStep[];

package/dist/src/core/capabilities.d.ts

@@ -0,0 +1,3 @@
+import type { DeviceInfo } from '../utils/device.ts';
+export declare function isCommandSupportedOnDevice(command: string, device: DeviceInfo): boolean;
+export declare function listCapabilityCommands(): string[];

package/dist/src/core/dispatch-payload.d.ts

@@ -0,0 +1 @@
+export declare function readNotificationPayload(payloadArg: string): Promise<Record<string, unknown>>;

package/dist/src/core/dispatch-resolve.d.ts

@@ -0,0 +1,28 @@
+import { selectDevice, type DeviceInfo } from '../utils/device.ts';
+import { findBootableIosSimulator } from '../platforms/ios/devices.ts';
+import type { CliFlags } from '../utils/command-schema.ts';
+import type { DeviceTarget } from '../utils/device.ts';
+type ResolveDeviceFlags = Pick<CliFlags, 'platform' | 'target' | 'device' | 'udid' | 'serial' | 'iosSimulatorDeviceSet' | 'androidDeviceAllowlist'>;
+type IosDeviceSelector = {
+    platform?: 'ios';
+    target?: DeviceTarget;
+    deviceName?: string;
+    udid?: string;
+    serial?: string;
+};
+type ResolveIosDeviceDeps = {
+    selectDevice: typeof selectDevice;
+    findBootableSimulator: typeof findBootableIosSimulator;
+};
+/**
+ * Resolves the best iOS device given pre-fetched candidates.  When no explicit
+ * device selector was used, physical devices are rejected in favour of a
+ * bootable simulator discovered via `findBootableSimulator`.
+ *
+ * Exported for testing; production callers should use `resolveTargetDevice`.
+ */
+export declare function resolveIosDevice(devices: DeviceInfo[], selector: IosDeviceSelector, context: {
+    simulatorSetPath?: string;
+}, deps: ResolveIosDeviceDeps): Promise<DeviceInfo>;
+export declare function resolveTargetDevice(flags: ResolveDeviceFlags): Promise<DeviceInfo>;
+export {};

package/dist/src/core/dispatch-series.d.ts

@@ -0,0 +1,7 @@
+import type { DeviceInfo } from '../utils/device.ts';
+export declare function requireIntInRange(value: number, name: string, min: number, max: number): number;
+export declare function clampIosSwipeDuration(durationMs: number): number;
+export declare function shouldUseIosTapSeries(device: DeviceInfo, count: number, holdMs: number, jitterPx: number): boolean;
+export declare function shouldUseIosDragSeries(device: DeviceInfo, count: number): boolean;
+export declare function computeDeterministicJitter(index: number, jitterPx: number): [number, number];
+export declare function runRepeatedSeries(count: number, pauseMs: number, operation: (index: number) => Promise<void>): Promise<void>;

package/dist/src/core/dispatch.d.ts

@@ -0,0 +1,34 @@
+import type { DeviceInfo } from '../utils/device.ts';
+import type { CliFlags } from '../utils/command-schema.ts';
+import { shouldUseIosTapSeries, shouldUseIosDragSeries } from './dispatch-series.ts';
+export { resolveTargetDevice } from './dispatch-resolve.ts';
+export { shouldUseIosTapSeries, shouldUseIosDragSeries };
+export type BatchStep = {
+    command: string;
+    positionals?: string[];
+    flags?: Partial<CommandFlags>;
+    runtime?: unknown;
+};
+export type CommandFlags = Omit<CliFlags, 'json' | 'help' | 'version' | 'batchSteps'> & {
+    batchSteps?: BatchStep[];
+};
+export declare function dispatchCommand(device: DeviceInfo, command: string, positionals: string[], outPath?: string, context?: {
+    requestId?: string;
+    appBundleId?: string;
+    activity?: string;
+    verbose?: boolean;
+    logPath?: string;
+    traceLogPath?: string;
+    snapshotInteractiveOnly?: boolean;
+    snapshotCompact?: boolean;
+    snapshotDepth?: number;
+    snapshotScope?: string;
+    snapshotRaw?: boolean;
+    count?: number;
+    intervalMs?: number;
+    holdMs?: number;
+    jitterPx?: number;
+    doubleTap?: boolean;
+    pauseMs?: number;
+    pattern?: 'one-way' | 'ping-pong';
+}): Promise<Record<string, unknown> | void>;

package/dist/src/core/open-target.d.ts

@@ -0,0 +1,4 @@
+export declare function isDeepLinkTarget(input: string): boolean;
+export declare function isWebUrl(input: string): boolean;
+export declare const IOS_SAFARI_BUNDLE_ID = "com.apple.mobilesafari";
+export declare function resolveIosDeviceDeepLinkBundleId(appBundleId: string | undefined, url: string): string | undefined;

package/dist/src/core/settings-contract.d.ts

@@ -0,0 +1,8 @@
+export declare const SETTINGS_WIFI_USAGE = "<wifi|airplane|location> <on|off>";
+export declare const SETTINGS_APPEARANCE_USAGE = "appearance <light|dark|toggle>";
+export declare const SETTINGS_FACEID_USAGE = "faceid <match|nonmatch|enroll|unenroll>";
+export declare const SETTINGS_TOUCHID_USAGE = "touchid <match|nonmatch|enroll|unenroll>";
+export declare const SETTINGS_FINGERPRINT_USAGE = "fingerprint <match|nonmatch>";
+export declare const SETTINGS_PERMISSION_USAGE = "permission <grant|deny|reset> <camera|microphone|photos|contacts|contacts-limited|notifications|calendar|location|location-always|media-library|motion|reminders|siri> [full|limited]";
+export declare const SETTINGS_USAGE_OVERRIDE: string;
+export declare const SETTINGS_INVALID_ARGS_MESSAGE = "settings requires <wifi|airplane|location> <on|off>, appearance <light|dark|toggle>, faceid <match|nonmatch|enroll|unenroll>, touchid <match|nonmatch|enroll|unenroll>, fingerprint <match|nonmatch>, or permission <grant|deny|reset> <camera|microphone|photos|contacts|contacts-limited|notifications|calendar|location|location-always|media-library|motion|reminders|siri> [full|limited]";

package/dist/src/daemon/action-utils.d.ts

@@ -0,0 +1,3 @@
+import type { SessionAction } from './types.ts';
+export declare function inferFillText(action: SessionAction): string;
+export declare function uniqueStrings(values: string[]): string[];

package/dist/src/daemon/app-log-android.d.ts

@@ -0,0 +1,4 @@
+import fs from 'node:fs';
+import { type AppLogResult } from './app-log-process.ts';
+export declare function assertAndroidPackageArgSafe(appBundleId: string): void;
+export declare function startAndroidAppLog(deviceId: string, appBundleId: string, stream: fs.WriteStream, redactionPatterns: RegExp[], pidPath?: string): Promise<AppLogResult>;

package/dist/src/daemon/app-log-ios.d.ts

@@ -0,0 +1,6 @@
+import fs from 'node:fs';
+import { type AppLogResult } from './app-log-process.ts';
+export declare function buildIosLogPredicate(appBundleId: string): string;
+export declare function buildIosDeviceLogStreamArgs(deviceId: string): string[];
+export declare function startIosSimulatorAppLog(appBundleId: string, stream: fs.WriteStream, redactionPatterns: RegExp[], pidPath?: string): Promise<AppLogResult>;
+export declare function startIosDeviceAppLog(deviceId: string, stream: fs.WriteStream, redactionPatterns: RegExp[], pidPath?: string): Promise<AppLogResult>;

package/dist/src/daemon/app-log-process.d.ts

@@ -0,0 +1,15 @@
+export declare const APP_LOG_PID_FILENAME = "app-log.pid";
+export type AppLogResult = {
+    backend: 'ios-simulator' | 'ios-device' | 'android';
+    getState: () => 'active' | 'failed';
+    startedAt: number;
+    stop: () => Promise<void>;
+    wait: Promise<{
+        stdout: string;
+        stderr: string;
+        exitCode: number;
+    }>;
+};
+export declare function writePidFile(pidPath: string | undefined, pid: number): void;
+export declare function clearPidFile(pidPath: string | undefined): void;
+export declare function cleanupStaleAppLogProcesses(sessionsDir: string): void;

package/dist/src/daemon/app-log-stream.d.ts

@@ -0,0 +1,19 @@
+import { spawn } from 'node:child_process';
+import fs from 'node:fs';
+import type { ExecResult } from '../utils/exec.ts';
+export declare function waitForChildExit(wait: Promise<ExecResult>, timeoutMs?: number): Promise<void>;
+export declare function sleep(ms: number): Promise<void>;
+export declare function createLineWriter(stream: fs.WriteStream, options: {
+    redactionPatterns: RegExp[];
+    includeTokens?: string[];
+}): {
+    onChunk: (chunk: string) => void;
+    flush: () => void;
+};
+export declare function attachChildToStream(child: ReturnType<typeof spawn>, stream: fs.WriteStream, options: {
+    endStreamOnClose: boolean;
+    writer: {
+        onChunk: (chunk: string) => void;
+        flush: () => void;
+    };
+}): Promise<ExecResult>;

package/dist/src/daemon/app-log.d.ts

@@ -0,0 +1,28 @@
+import type { DeviceInfo } from '../utils/device.ts';
+import type { AppLogResult } from './app-log-process.ts';
+export type { AppLogResult } from './app-log-process.ts';
+export { APP_LOG_PID_FILENAME, cleanupStaleAppLogProcesses } from './app-log-process.ts';
+export { assertAndroidPackageArgSafe } from './app-log-android.ts';
+export { buildIosDeviceLogStreamArgs, buildIosLogPredicate } from './app-log-ios.ts';
+export type AppLogDoctorResult = {
+    checks: Record<string, boolean>;
+    notes: string[];
+};
+export declare function rotateAppLogIfNeeded(outPath: string, config: {
+    maxBytes: number;
+    maxRotatedFiles: number;
+}): void;
+export declare function getAppLogPathMetadata(outPath: string): {
+    exists: boolean;
+    sizeBytes: number;
+    modifiedAt?: string;
+};
+export declare function startAppLog(device: DeviceInfo, appBundleId: string, outPath: string, pidPath?: string): Promise<AppLogResult>;
+export declare function stopAppLog(appLog: AppLogResult): Promise<void>;
+export declare function runAppLogDoctor(device: DeviceInfo, appBundleId?: string): Promise<AppLogDoctorResult>;
+export declare function appendAppLogMarker(outPath: string, marker: string): void;
+export declare function clearAppLogFiles(outPath: string): {
+    path: string;
+    cleared: boolean;
+    removedRotatedFiles: number;
+};

package/dist/src/daemon/artifact-archive.d.ts

@@ -0,0 +1,12 @@
+export declare function extractTarInstallableArtifact(params: {
+    archivePath: string;
+    tempDir: string;
+    platform: 'ios' | 'android';
+    expectedRootName?: string;
+}): Promise<string>;
+export declare function resolveTarArchiveRootName(params: {
+    archivePath: string;
+    platform: 'ios' | 'android';
+    expectedRootName?: string;
+}): Promise<string>;
+export declare function readZipEntries(archivePath: string): Promise<string[] | null>;

package/dist/src/daemon/artifact-download.d.ts

@@ -0,0 +1,12 @@
+export declare function sanitizeArtifactFilename(raw: string): string;
+export declare function createArtifactTempDir(requestId?: string): string;
+export declare function validateArtifactContentLength(rawLength: string | number | undefined): void;
+export declare function streamReadableToFile(source: NodeJS.ReadableStream, destPath: string): Promise<void>;
+export declare function downloadArtifactToTempDir(params: {
+    url: string;
+    headers?: Record<string, string>;
+    requestId?: string;
+    tempDir: string;
+}): Promise<{
+    archivePath: string;
+}>;

package/dist/src/daemon/artifact-materialization.d.ts

@@ -0,0 +1,17 @@
+export type MaterializeArtifactParams = {
+    platform: 'ios' | 'android';
+    url: string;
+    headers?: Record<string, string>;
+    requestId?: string;
+};
+export type MaterializedArtifact = {
+    archivePath: string;
+    installablePath: string;
+    detected: {
+        packageName?: string;
+        bundleId?: string;
+        appName?: string;
+    };
+};
+export declare function cleanupMaterializedArtifact(result: MaterializedArtifact): void;
+export declare function materializeArtifact(params: MaterializeArtifactParams): Promise<MaterializedArtifact>;

package/dist/src/daemon/artifact-registry.d.ts

@@ -0,0 +1,12 @@
+export declare function trackDownloadableArtifact(params: {
+    artifactPath: string;
+    tenantId?: string;
+    fileName?: string;
+    deleteAfterDownload?: boolean;
+}): string;
+export declare function prepareDownloadableArtifact(artifactId: string, tenantId?: string): {
+    artifactPath: string;
+    fileName?: string;
+    deleteAfterDownload: boolean;
+};
+export declare function cleanupDownloadableArtifact(artifactId: string): void;

package/dist/src/daemon/config.d.ts

@@ -0,0 +1,16 @@
+export type DaemonServerMode = 'socket' | 'http' | 'dual';
+export type DaemonTransportPreference = 'auto' | 'socket' | 'http';
+export type SessionIsolationMode = 'none' | 'tenant';
+export type DaemonPaths = {
+    baseDir: string;
+    infoPath: string;
+    lockPath: string;
+    logPath: string;
+    sessionsDir: string;
+};
+export declare function resolveDaemonPaths(stateDir: string | undefined): DaemonPaths;
+export declare function resolveStateDir(raw: string | undefined): string;
+export declare function resolveDaemonServerMode(raw: string | undefined): DaemonServerMode;
+export declare function resolveDaemonTransportPreference(raw: string | undefined): DaemonTransportPreference;
+export declare function resolveSessionIsolationMode(raw: string | undefined): SessionIsolationMode;
+export declare function normalizeTenantId(raw: string | undefined): string | undefined;

package/dist/src/daemon/context.d.ts

@@ -0,0 +1,22 @@
+import type { CommandFlags } from '../core/dispatch.ts';
+export type DaemonCommandContext = {
+    requestId?: string;
+    appBundleId?: string;
+    activity?: string;
+    verbose?: boolean;
+    logPath?: string;
+    traceLogPath?: string;
+    snapshotInteractiveOnly?: boolean;
+    snapshotCompact?: boolean;
+    snapshotDepth?: number;
+    snapshotScope?: string;
+    snapshotRaw?: boolean;
+    count?: number;
+    intervalMs?: number;
+    holdMs?: number;
+    jitterPx?: number;
+    doubleTap?: boolean;
+    pauseMs?: number;
+    pattern?: 'one-way' | 'ping-pong';
+};
+export declare function contextFromFlags(logPath: string, flags: CommandFlags | undefined, appBundleId?: string, traceLogPath?: string, requestId?: string): DaemonCommandContext;

package/dist/src/daemon/device-ready.d.ts

@@ -0,0 +1,6 @@
+import type { DeviceInfo } from '../utils/device.ts';
+export declare function ensureDeviceReady(device: DeviceInfo): Promise<void>;
+export declare function parseIosReadyPayload(payload: unknown): {
+    tunnelState?: string;
+};
+export declare function resolveIosReadyHint(stdout: string, stderr: string): string;

package/dist/src/daemon/handlers/find.d.ts

@@ -0,0 +1,40 @@
+import { dispatchCommand } from '../../core/dispatch.ts';
+import { type FindLocator } from '../../utils/finders.ts';
+import type { DaemonRequest, DaemonResponse } from '../types.ts';
+import { SessionStore } from '../session-store.ts';
+export declare function handleFindCommands(params: {
+    req: DaemonRequest;
+    sessionName: string;
+    logPath: string;
+    sessionStore: SessionStore;
+    invoke: (req: DaemonRequest) => Promise<DaemonResponse>;
+    dispatch?: typeof dispatchCommand;
+}): Promise<DaemonResponse | null>;
+type FindAction = {
+    kind: 'click';
+} | {
+    kind: 'focus';
+} | {
+    kind: 'fill';
+    value: string;
+} | {
+    kind: 'type';
+    value: string;
+} | {
+    kind: 'get_text';
+} | {
+    kind: 'get_attrs';
+} | {
+    kind: 'exists';
+} | {
+    kind: 'wait';
+    timeoutMs?: number;
+};
+export declare function parseFindArgs(args: string[]): {
+    locator: FindLocator;
+    query: string;
+    action: FindAction['kind'];
+    value?: string;
+    timeoutMs?: number;
+};
+export {};

package/dist/src/daemon/handlers/install-source.d.ts

@@ -0,0 +1,10 @@
+import { SessionStore } from '../session-store.ts';
+import type { DaemonRequest, DaemonResponse } from '../types.ts';
+export declare function handleInstallFromSourceCommand(params: {
+    req: DaemonRequest;
+    sessionName: string;
+    sessionStore: SessionStore;
+}): Promise<DaemonResponse>;
+export declare function handleReleaseMaterializedPathsCommand(params: {
+    req: DaemonRequest;
+}): Promise<DaemonResponse>;

package/dist/src/daemon/handlers/interaction.d.ts

@@ -0,0 +1,14 @@
+import { dispatchCommand, type CommandFlags } from '../../core/dispatch.ts';
+import type { DaemonCommandContext } from '../context.ts';
+import type { DaemonRequest, DaemonResponse } from '../types.ts';
+import { SessionStore } from '../session-store.ts';
+type ContextFromFlags = (flags: CommandFlags | undefined, appBundleId?: string, traceLogPath?: string) => DaemonCommandContext;
+export declare function handleInteractionCommands(params: {
+    req: DaemonRequest;
+    sessionName: string;
+    sessionStore: SessionStore;
+    contextFromFlags: ContextFromFlags;
+    dispatch?: typeof dispatchCommand;
+}): Promise<DaemonResponse | null>;
+export declare function unsupportedRefSnapshotFlags(flags: CommandFlags | undefined): string[];
+export {};