@aixnn/aixautots 0.5.3 → 0.5.4

package/dist/react/index.d.ts

@@ -0,0 +1,487 @@
+import * as react from 'react';
+import react__default, { ReactNode } from 'react';
+import { A as AixConfig, R as ResolvedConfig, c as AixClient, e as EnvEventKind, q as EnvFinished, t as EnvSetupInput, x as EnvTeardownInput, E as EnvOs } from '../config-fsx4jlLK.js';
+import { D as DeviceChannel, A as AdbResult, W as WdaResult, S as ScriptEvent, e as ScriptRunInput } from '../script-debugger-Cu_coj-h.js';
+import { F as FlowEvent, b as FlowSubmit, B as BatchConfig } from '../automation-queue-CKsueO9z.js';
+import { M as MirrorSession, I as InputMessage, b as ScrcpyProfileName } from '../mirror-session-DM-trg1F.js';
+import { w as AuthResult, aH as SendCodeResult, a$ as VerifyCodeResult, ap as Project, I as CreateProjectInput, J as CreateProjectResult, am as PowerAction, aG as ScreenshotResult, X as ElementNode, D as DeviceRow, N as NodeRow, ah as NodeScope, aF as RegisterNodeResult, ag as NodeOwnerPolicy, aL as Shortcut, ae as NewShortcut, aN as ShortcutRunResult, an as PowerRunResult, f as ScriptSummary, S as Script, E as Cluster, G as CreateClusterInput, Z as FleetRunDetail, Y as FleetMode, d as AgentTaskBlocker, e as AgentTaskEvidence, aT as TaskStatus, aV as TaskSummary, aR as TaskListFilter, b0 as WebhookConfig, L as CreateWebhookInput, aE as RegisterNodeInput, ab as Locator, H as CreateLocatorInput, a0 as ImageArtifact, a1 as ImageInput, aa as LlmTestResult, U as DeviceRate, aB as RateInput, y as BillingPlan, aj as PlanInput, V as DeviceUsageSession, aC as RebateLedgerRow, x as BalanceResp, aX as TopupInput, aY as TopupResult, q as ApiTokenRow, K as CreateTokenInput, M as CreatedToken } from '../types-C2WXVcam.js';
+import { a as TaskAgentDevice, b as TaskAgentDeviceStatus, T as TaskAgentRunner } from '../task-agent-runner-CMq9Cir1.js';
+export { D as Device, i as DevicesProvider, j as DevicesProviderProps, k as DevicesView, c as TaskAgentNodeSnapshot, d as TaskAgentPreflightResult, e as TaskAgentRunRequest, f as TaskAgentStreamEvent, g as TaskAgentTarget, m as mapDevice, p as preflightTaskAgentDevice, u as useDevicesView } from '../task-agent-runner-CMq9Cir1.js';
+import { L as LogEntry } from '../use-script-run-Diay7ibY.js';
+export { b as LogLevel, S as ScriptRunStatus, a as StepEvent, U as UseScriptRun, u as useScriptRun } from '../use-script-run-Diay7ibY.js';
+import { A as AgentKind } from '../agent-runner-V60B0is1.js';
+import '../device-normalize-BaThgnH7.js';
+
+declare function AixProvider({ config, children }: {
+    config: AixConfig;
+    children: react__default.ReactNode;
+}): react__default.JSX.Element;
+declare function useAixConfig(): ResolvedConfig;
+
+interface UseDevice {
+    deviceId: string;
+    channel: DeviceChannel | null;
+    error: Error | null;
+}
+declare function useDevice(deviceId: string): UseDevice;
+
+interface UseCommands {
+    ready: boolean;
+    loading: boolean;
+    error: Error | null;
+    lastResult: AdbResult | WdaResult | null;
+    adb(argv: string[], opts?: {
+        timeoutMs?: number;
+    }): Promise<AdbResult>;
+    wda(method: string, path: string, body?: unknown): Promise<WdaResult>;
+}
+declare function useCommands(deviceId: string): UseCommands;
+
+interface UseScript {
+    ready: boolean;
+    running: boolean;
+    runId: string | null;
+    events: ScriptEvent[];
+    error: Error | null;
+    run(input: ScriptRunInput): Promise<{
+        runId: string;
+    }>;
+    call(method: string, args?: unknown): Promise<unknown>;
+    cancel(): Promise<void>;
+    clearEvents(): void;
+}
+declare function useScript(deviceId: string, opts: {
+    engine: 'frida' | 'scriptlet';
+}): UseScript;
+
+interface UseFlowRun {
+    taskId: string | null;
+    events: FlowEvent[];
+    done: boolean;
+    error: Error | null;
+    submit(body: FlowSubmit): Promise<{
+        taskId: string;
+    }>;
+    close(): void;
+}
+declare function useFlowRun(): UseFlowRun;
+
+interface UseMirror {
+    session: MirrorSession | null;
+    stream: MediaStream | null;
+    error: Error | null;
+    sendInput(msg: InputMessage): void;
+    /** Switch the device encode profile (node restarts its capture pipeline). */
+    setQuality(profile: ScrcpyProfileName): void;
+}
+declare function useMirror(sessionId: string): UseMirror;
+
+/** 一次群控的软上限:每台设备一条 WebRTC 连接,浏览器并发与带宽有限。超出的
+ *  id 被截断并 console.warn。 */
+declare const GROUP_MIRROR_MAX = 9;
+interface UseGroupMirror {
+    /** device id → live MediaStream(按各设备出流时间陆续填充)。 */
+    streams: Map<string, MediaStream>;
+    /** device id → join/连接错误(其余设备不受影响)。 */
+    errors: Map<string, Error>;
+    /** 已成功 join 的会话数(含尚未出流的)。 */
+    connected: number;
+    /** 把一条控制消息扇出到所有已连接设备。坐标为 [0,1] 归一化,天然适配
+     *  不同分辨率(各节点自行缩放到 px)。 */
+    broadcastInput(msg: InputMessage): void;
+    /** 所有已连接设备统一切画质档位。 */
+    setQualityAll(profile: ScrcpyProfileName): void;
+}
+declare function useGroupMirror(ids: string[]): UseGroupMirror;
+
+/** The shared, memoized resource client for the current `<AixProvider>` config. */
+declare function useClient(): AixClient;
+interface Query<T> {
+    data: T | null;
+    loading: boolean;
+    error: Error | null;
+    refetch: () => Promise<void>;
+    setData: (updater: (prev: T | null) => T | null) => void;
+}
+/** Run an async loader on mount (and when `deps` change), tracking
+ *  loading/error and exposing a `refetch`. Safe against unmount. */
+declare function useQuery<T>(loader: () => Promise<T>, deps: unknown[]): Query<T>;
+
+interface UseAuth {
+    login(email: string, password: string): Promise<AuthResult>;
+    register(email: string, password: string): Promise<AuthResult>;
+    sendCode(email: string): Promise<SendCodeResult>;
+    verifyCode(email: string, code: string): Promise<VerifyCodeResult>;
+    setPassword(password: string): Promise<void>;
+    projectUser(projectId: string): Promise<{
+        token: string;
+        user_id: string;
+        project_id: string;
+    }>;
+}
+/** Auth flows. Token persistence/caching is the app's responsibility — wire the
+ *  returned tokens back into the `AixConfig.auth` credential closures. */
+declare function useAuth(): UseAuth;
+
+interface UseProjects extends Query<Project[]> {
+    create(input: CreateProjectInput): Promise<CreateProjectResult>;
+    remove(id: string): Promise<void>;
+    rotateSecret(id: string): Promise<string>;
+}
+declare function useProjects(): UseProjects;
+
+type UseDevices = Query<DeviceRow[]>;
+/** List the caller's devices (raw backend rows; map to UI shape in the app). */
+declare function useDevices(): UseDevices;
+interface UseDeviceActions {
+    power(action: PowerAction, extra?: Record<string, unknown>): Promise<unknown>;
+    control(op: Record<string, unknown>): Promise<unknown>;
+    installApkUrl(url: string): Promise<unknown>;
+    lease(): Promise<unknown>;
+    release(): Promise<unknown>;
+    claim(): Promise<unknown>;
+    screenshot(): Promise<ScreenshotResult>;
+    captureUiTree(): Promise<ElementNode>;
+}
+/** Imperative live-device actions for one device id. */
+declare function useDeviceActions(deviceId: string): UseDeviceActions;
+
+interface NodesView {
+    nodes: NodeRow[];
+    loading: boolean;
+    error: string | null;
+    fetchNodes: () => Promise<void>;
+    /** Background refetch: updates `nodes` without toggling `loading` or
+     *  clobbering `error`, so pollers don't flicker the UI. */
+    refreshNodes: () => Promise<void>;
+    createNode: (name: string, scope: NodeScope, region?: string) => Promise<RegisterNodeResult>;
+    updateNode: (id: string, patch: {
+        name?: string;
+        scope?: NodeScope;
+        region?: string | null;
+        owner_policy?: NodeOwnerPolicy;
+    }) => Promise<void>;
+    rotateToken: (id: string) => Promise<RegisterNodeResult>;
+    removeNode: (id: string) => Promise<void>;
+}
+interface NodesProviderProps {
+    children: ReactNode;
+    /** Fetch the list on mount (default true). */
+    autoFetch?: boolean;
+}
+declare function NodesProvider({ children, autoFetch }: NodesProviderProps): react.FunctionComponentElement<react.ProviderProps<NodesView | null>>;
+/** Access the shared nodes view. Must be inside a `<NodesProvider>`. */
+declare function useNodesView(): NodesView;
+
+interface ShortcutsView {
+    shortcuts: Shortcut[];
+    loading: boolean;
+    error: string | null;
+    fetch: (platform?: 'android' | 'ios' | 'any') => Promise<void>;
+    create: (body: NewShortcut) => Promise<Shortcut | null>;
+    update: (id: string, body: NewShortcut) => Promise<Shortcut | null>;
+    remove: (id: string) => Promise<void>;
+    /** Run a shortcut (a parameterised function script) on the given devices via a
+     *  Broadcast fleet run, then poll the run to a terminal state so the caller
+     *  gets a real receipt (per-device status/output). Returns `null` when there
+     *  are no target devices. The run keeps going server-side if polling times out
+     *  (`result.timedOut === true`). */
+    runShortcut: (shortcut: Shortcut, values: Record<string, unknown>, deviceIds: string[]) => Promise<ShortcutRunResult | null>;
+    /** Run a power-kind shortcut: call the backend power API per device and return
+     *  a per-device receipt (`ok` + raw `result`, or `error` on rejection). The
+     *  backend awaits the node, so `ok` reflects whether the op actually ran. */
+    runPower: (shortcut: Shortcut, deviceIds: string[]) => Promise<PowerRunResult[]>;
+}
+interface ShortcutsProviderProps {
+    children: ReactNode;
+}
+declare function ShortcutsProvider({ children }: ShortcutsProviderProps): react.FunctionComponentElement<react.ProviderProps<ShortcutsView | null>>;
+/** Access the shared shortcuts view. Must be inside a `<ShortcutsProvider>`. */
+declare function useShortcutsView(): ShortcutsView;
+
+interface UseScripts extends Query<ScriptSummary[]> {
+    get(id: string): Promise<Script>;
+    save(script: Script): Promise<unknown>;
+    remove(id: string): Promise<void>;
+    duplicate(id: string): Promise<ScriptSummary>;
+    setVisibility(id: string, visibility: string): Promise<ScriptSummary>;
+}
+/** Stored script (flow) library CRUD. */
+declare function useScripts(): UseScripts;
+
+interface UseClusters extends Query<Cluster[]> {
+    create(input: CreateClusterInput): Promise<Cluster>;
+    remove(id: string): Promise<void>;
+    setDevices(id: string, deviceIds: string[]): Promise<Cluster>;
+    run(id: string, flow: unknown): Promise<{
+        run_id: string;
+    }>;
+}
+declare function useClusters(): UseClusters;
+
+type FleetStatus = 'idle' | 'running' | 'paused' | 'completed' | 'failed';
+interface UseFleetRun {
+    runId: string | null;
+    status: FleetStatus;
+    progress: number;
+    detail: FleetRunDetail | null;
+    error: Error | null;
+    start(script: Script, deviceIds: string[], mode?: FleetMode): Promise<string>;
+    cancel(): Promise<void>;
+    pause(): Promise<void>;
+    resume(): Promise<void>;
+    reset(): void;
+}
+/** Submit a fleet run and poll per-device progress until terminal. */
+declare function useFleetRun(pollMs?: number): UseFleetRun;
+
+interface TaskAgentDeviceRun extends TaskAgentDevice {
+    /** Stable backend target id. Controls always address this id, never a device id. */
+    targetId?: string;
+    /** Current immutable attempt id, replaced only when the backend creates a retry. */
+    attemptId?: string;
+    status: TaskAgentDeviceStatus;
+    error?: string;
+    blocker?: AgentTaskBlocker | null;
+    evidence: AgentTaskEvidence[];
+}
+interface UseTaskAgentRun {
+    runId: string | null;
+    agent: AgentKind;
+    concurrency: number;
+    devices: TaskAgentDeviceRun[];
+    logs: LogEntry[];
+    error: string | null;
+    running: boolean;
+    start(input: {
+        agent: AgentKind;
+        devices: TaskAgentDevice[];
+        prompt: string;
+        concurrency: number;
+    }): Promise<void>;
+    resume(runId: string, devices: TaskAgentDevice[]): Promise<void>;
+    cancelAll(): Promise<void>;
+    cancelDevice(deviceId: string): Promise<void>;
+    retryDevice(deviceId: string): Promise<void>;
+    approveDevice(deviceId: string): Promise<void>;
+    clearLogs(): void;
+    reset(): void;
+}
+/**
+ * State adapter for a task-agent runner. It owns cursor-safe stream aggregation
+ * while the runner submits and controls node-backed tasks, so web hosts never
+ * acquire a Tauri dependency.
+ */
+declare function useTaskAgentRun(runner?: TaskAgentRunner): UseTaskAgentRun;
+
+interface UseTaskStatus {
+    data: TaskStatus | null;
+    loading: boolean;
+    error: Error | null;
+    done: boolean;
+    refetch: () => Promise<void>;
+}
+/** Read a webhook task's status. Polls until terminal when `pollMs > 0`;
+ *  TanStack-friendly — also exposes `refetch` for manual/external control. */
+declare function useTaskStatus(taskId: string | null, pollMs?: number): UseTaskStatus;
+
+interface UseTasks extends Query<TaskSummary[]> {
+    cancel(id: string): Promise<void>;
+}
+/** List webhook tasks (newest first), with optional device/status filter. */
+declare function useTasks(filter?: TaskListFilter): UseTasks;
+
+interface UseAutomationQueue extends UseTasks {
+    /** 展开并提交一个批次(rows×mode → 多次 `/api/webhook/tasks`),返回 task id
+     *  数组,并刷新队列列表。见 `core/automation-queue` 的 `submitBatch`。 */
+    submitBatch(config: BatchConfig): Promise<string[]>;
+    /** 暂停一个任务(still-pending 目标 → paused),刷新列表。 */
+    pause(id: string): Promise<void>;
+    /** 恢复一个被暂停的任务(paused → pending),刷新列表。 */
+    resume(id: string): Promise<void>;
+}
+/** 自动化队列 hook:复用 `useTasks`(列表/轮询/cancel),再叠加批次提交与
+ *  暂停/恢复。webhook 入站任务与本地批次落同一张表 → 同一队列统一展示。 */
+declare function useAutomationQueue(filter?: TaskListFilter): UseAutomationQueue;
+
+interface UseInspector {
+    screenshot: string | null;
+    tree: ElementNode | null;
+    selected: ElementNode | null;
+    loading: boolean;
+    error: Error | null;
+    captureScreenshot(): Promise<void>;
+    captureTree(): Promise<void>;
+    refresh(): Promise<void>;
+    select(el: ElementNode | null): void;
+}
+/** Capture a device screenshot + UI tree via the live-op proxy. */
+declare function useInspector(deviceId: string | null): UseInspector;
+
+/** A locator probe result — the device-op `find_elements` returns the lighter
+ *  `Element` shape (rect + identity, NO xpath/children) used for highlight. */
+interface MatchElement {
+    rect: {
+        x: number;
+        y: number;
+        width: number;
+        height: number;
+    };
+    label: string | null;
+    text: string | null;
+    resource_id: string | null;
+    class_name: string | null;
+}
+/** A device-side `Locator` — serde tag/value pair the node deserializes. */
+interface InspectorLocator {
+    strategy: string;
+    value: string;
+}
+interface InspectorView {
+    screenshot: string | null;
+    tree: ElementNode | null;
+    selectedElement: ElementNode | null;
+    loading: boolean;
+    error: string | null;
+    /** Last verified locator + its live matches (highlighted on the screenshot). */
+    verifyLocator: InspectorLocator | null;
+    matches: MatchElement[];
+    verifying: boolean;
+    recording: boolean;
+    /** Recorded automation lines — each is one `device.*` TS statement. */
+    recordedLines: string[];
+    captureScreenshot: () => Promise<void>;
+    captureTree: () => Promise<void>;
+    selectElement: (el: ElementNode | null) => void;
+    refresh: () => Promise<void>;
+    /** Clear captured state (used when switching devices). */
+    reset: () => void;
+    tap: (x: number, y: number) => Promise<void>;
+    inputText: (text: string) => Promise<void>;
+    pressKey: (key: string) => Promise<void>;
+    swipe: (x1: number, y1: number, x2: number, y2: number, duration?: number) => Promise<void>;
+    longPress: (x: number, y: number, durationSecs?: number) => Promise<void>;
+    verify: (strategy: string, value: string) => Promise<void>;
+    clearMatches: () => void;
+    setRecording: (on: boolean) => void;
+    recordLine: (line: string) => void;
+    removeLine: (index: number) => void;
+    clearRecording: () => void;
+}
+interface InspectorProviderProps {
+    children: ReactNode;
+}
+declare function InspectorProvider({ children }: InspectorProviderProps): react.FunctionComponentElement<react.ProviderProps<InspectorView | null>>;
+/** Access the shared inspector view. Must be inside an `<InspectorProvider>`. */
+declare function useInspectorView(): InspectorView;
+
+interface UseWebhooks extends Query<WebhookConfig[]> {
+    create(input: CreateWebhookInput): Promise<void>;
+    setEnabled(id: string, enabled: boolean): Promise<void>;
+    remove(id: string): Promise<void>;
+    trigger(eventType: string, payload?: unknown): Promise<void>;
+}
+declare function useWebhooks(): UseWebhooks;
+
+interface UseNodes extends Query<NodeRow[]> {
+    register(input: string | RegisterNodeInput): Promise<RegisterNodeResult>;
+}
+declare function useNodes(): UseNodes;
+
+interface UseEnvRun {
+    reqId: string | null;
+    events: EnvEventKind[];
+    /** The terminal `finished` frame once it arrives (carries ok/result/error). */
+    finished: EnvFinished | null;
+    done: boolean;
+    error: Error | null;
+    setup(nodeId: string, input?: EnvSetupInput): Promise<{
+        reqId: string;
+    }>;
+    status(nodeId: string, input?: {
+        os?: EnvSetupInput['os'];
+    }): Promise<{
+        reqId: string;
+    }>;
+    teardown(nodeId: string, input?: EnvTeardownInput): Promise<{
+        reqId: string;
+    }>;
+    close(): void;
+}
+/** Trigger + stream a node's env-base setup/status/teardown. Reuses the SDK's
+ *  `EnvRun`, which itself reuses the shared `/ws/execution` relay — no new WS. */
+declare function useEnvRun(): UseEnvRun;
+
+interface UseEnvGate {
+    os: EnvOs | null;
+    /** null until the first probe resolves; then true iff the base is missing. */
+    needsSetup: boolean | null;
+    ready: boolean;
+    probing: boolean;
+    error: Error | null;
+    open: boolean;
+    setOpen(o: boolean): void;
+    /** Status-probe events — pass as `seedEvents` to <EnvInitDialog>. */
+    statusEvents: EnvEventKind[];
+    /** Re-run the probe (e.g. after setup completes, to confirm readiness). */
+    refresh(): void;
+}
+declare function useEnvGate(nodeId: string | null, opts?: {
+    os?: EnvOs | null;
+    autoOpen?: boolean;
+}): UseEnvGate;
+
+interface UseLocators extends Query<Locator[]> {
+    create(input: CreateLocatorInput): Promise<Locator>;
+    remove(id: string): Promise<void>;
+}
+declare function useLocators(): UseLocators;
+
+interface UseImages extends Query<ImageArtifact[]> {
+    upsert(input: ImageInput): Promise<ImageArtifact>;
+    setActive(id: string, active: boolean): Promise<void>;
+    remove(id: string): Promise<void>;
+}
+declare function useImages(): UseImages;
+
+interface UseLlm {
+    test(opts?: {
+        token?: string;
+        model?: string;
+    }): Promise<LlmTestResult>;
+}
+declare function useLlm(): UseLlm;
+
+interface UseAdmin {
+    listRates(): Promise<DeviceRate[]>;
+    upsertRate(body: RateInput): Promise<DeviceRate>;
+    listPlans(): Promise<BillingPlan[]>;
+    createPlan(body: PlanInput): Promise<BillingPlan>;
+    usage(): Promise<DeviceUsageSession[]>;
+    ledger(): Promise<RebateLedgerRow[]>;
+    setRebate(projectId: string, ratio: number): Promise<unknown>;
+    setNodePlatform(nodeId: string, isPlatform: boolean): Promise<unknown>;
+}
+/** Imperative admin/billing operations (admin-scoped). Pair with `useImages`
+ *  for the image catalog. */
+declare function useAdmin(): UseAdmin;
+
+interface UseBilling extends Query<BalanceResp> {
+    /** 充值到指定用户钱包(admin scope),成功后刷新余额。 */
+    topup(input: TopupInput): Promise<TopupResult>;
+}
+/** 当前钱包余额 + 最近流水;`topup` 充值后自动刷新。 */
+declare function useBilling(): UseBilling;
+
+interface UseApiTokens extends Query<ApiTokenRow[]> {
+    /** 创建一个 PAT;返回值含明文 `token`(仅此一次)。成功后刷新列表。 */
+    create(input: CreateTokenInput): Promise<CreatedToken>;
+    /** 撤销一个 PAT,成功后刷新列表。 */
+    revoke(id: string): Promise<void>;
+    /** 轮换一个 PAT;返回新明文 `token`。成功后刷新列表。 */
+    rotate(id: string): Promise<CreatedToken>;
+}
+/** 名下用户 PAT 列表 + 创建/撤销/轮换(改完刷新列表)。 */
+declare function useApiTokens(): UseApiTokens;
+
+export { AixProvider, ElementNode, type FleetStatus, GROUP_MIRROR_MAX, type InspectorLocator, InspectorProvider, type InspectorProviderProps, type InspectorView, LogEntry, type MatchElement, NodesProvider, type NodesProviderProps, type NodesView, type Query, ShortcutsProvider, type ShortcutsProviderProps, type ShortcutsView, TaskAgentDevice, type TaskAgentDeviceRun, TaskAgentDeviceStatus, TaskAgentRunner, type UseAdmin, type UseApiTokens, type UseAuth, type UseAutomationQueue, type UseBilling, type UseClusters, type UseCommands, type UseDevice, type UseDeviceActions, type UseDevices, type UseEnvGate, type UseEnvRun, type UseFleetRun, type UseFlowRun, type UseGroupMirror, type UseImages, type UseInspector, type UseLlm, type UseLocators, type UseMirror, type UseNodes, type UseProjects, type UseScript, type UseScripts, type UseTaskAgentRun, type UseTaskStatus, type UseTasks, type UseWebhooks, useAdmin, useAixConfig, useApiTokens, useAuth, useAutomationQueue, useBilling, useClient, useClusters, useCommands, useDevice, useDeviceActions, useDevices, useEnvGate, useEnvRun, useFleetRun, useFlowRun, useGroupMirror, useImages, useInspector, useInspectorView, useLlm, useLocators, useMirror, useNodes, useNodesView, useProjects, useQuery, useScript, useScripts, useShortcutsView, useTaskAgentRun, useTaskStatus, useTasks, useWebhooks };

package/dist/script-debugger-Cu_coj-h.d.ts

@@ -0,0 +1,114 @@
+import { A as AixConfig, R as ResolvedConfig, F as FridaEventFrame, S as ScriptletEventFrame, b as StatusFrame, O as OutgoingFrame } from './config-fsx4jlLK.js';
+
+declare class DeviceTunnel {
+    readonly streamId: string;
+    private readonly sink;
+    private readonly dataListeners;
+    constructor(streamId: string, sink: (frame: OutgoingFrame) => void);
+    send(bytes: Uint8Array): void;
+    onData(cb: (b: Uint8Array) => void): () => void;
+    _deliver(b: Uint8Array): void;
+    close(): void;
+}
+interface AdbResult {
+    exit: number | null;
+    stdout: string;
+    stderr: string;
+    stdout_b64: string;
+}
+interface WdaResult {
+    status: number;
+    body: unknown;
+}
+declare class DeviceChannel {
+    private readonly cfg;
+    readonly deviceId: string;
+    private readonly pending;
+    private corr;
+    private socketRef;
+    private channelClosed;
+    private readonly fridaListeners;
+    private readonly scriptletListeners;
+    private readonly statusListeners;
+    private readonly tunnels;
+    private constructor();
+    static open(cfg: AixConfig | ResolvedConfig, deviceId: string, opts?: {
+        prefer?: 'direct' | 'relay';
+    }): Promise<DeviceChannel>;
+    private nextId;
+    private request;
+    on(event: 'frida_event', cb: (e: Omit<FridaEventFrame, 't'>) => void): () => void;
+    on(event: 'scriptlet_event', cb: (e: Omit<ScriptletEventFrame, 't'>) => void): () => void;
+    on(event: 'status', cb: (s: Omit<StatusFrame, 't'>) => void): () => void;
+    fridaRun(script: string, target?: unknown, spawn?: boolean): Promise<{
+        run_id: string;
+    }>;
+    fridaCall(runId: string, method: string, args?: unknown): Promise<unknown>;
+    fridaCancel(runId: string): Promise<unknown>;
+    scriptletRun(script: string, vars?: unknown): Promise<{
+        run_id: string;
+    }>;
+    scriptletCall(runId: string, method: string, args?: unknown): Promise<unknown>;
+    scriptletCancel(runId: string): Promise<unknown>;
+    protected onMessage(text: string): void;
+    openTunnel(kind: 'adb' | 'wda' | 'frida' | 'tcp', addr?: string): DeviceTunnel;
+    adbExec(argv: string[], o?: {
+        timeoutMs?: number;
+    }): Promise<AdbResult>;
+    wdaReq(method: string, path: string, body?: unknown): Promise<WdaResult>;
+    close(): void;
+}
+
+type ScriptEngine = 'frida' | 'scriptlet' | 'flow';
+/** A normalized streaming event from a running script (engine-agnostic). */
+interface ScriptEvent {
+    runId: string;
+    name: string;
+    data: unknown;
+}
+type ScriptDebuggerOptions = {
+    engine: 'frida' | 'scriptlet';
+    channel: DeviceChannel;
+} | {
+    engine: 'flow';
+    cfg: AixConfig | ResolvedConfig;
+};
+interface ScriptRunInput {
+    script?: string;
+    /** scriptlet: flow/vars object injected as JS `vars`. */
+    vars?: unknown;
+    /** frida: attach target (e.g. `{ pid }`). */
+    target?: unknown;
+    /** frida: spawn+resume instead of attach. */
+    spawn?: boolean;
+    flow?: unknown;
+    scriptId?: string;
+    deviceIds?: string[];
+    params?: unknown;
+}
+/**
+ * Unified run/call/cancel + event facade over a single script engine on a
+ * `DeviceChannel`. `frida`, `scriptlet`, and `flow` are supported.
+ * One debugger drives one run at a time; `run()` replaces any previous run's
+ * event subscription.
+ */
+declare class ScriptDebugger {
+    private readonly opts;
+    private runId;
+    private unsub;
+    private flow;
+    private readonly listeners;
+    constructor(opts: ScriptDebuggerOptions);
+    get engine(): ScriptEngine;
+    get currentRunId(): string | null;
+    on(_event: 'event', cb: (e: ScriptEvent) => void): () => void;
+    run(input: ScriptRunInput): Promise<{
+        runId: string;
+    }>;
+    call(method: string, args?: unknown): Promise<unknown>;
+    cancel(): Promise<void>;
+    private attachChannel;
+    private detach;
+}
+
+export { type AdbResult as A, DeviceChannel as D, type ScriptEvent as S, type WdaResult as W, type ScriptEngine as a, DeviceTunnel as b, ScriptDebugger as c, type ScriptDebuggerOptions as d, type ScriptRunInput as e };