@aixnn/aixautots 0.5.3 → 0.5.4

package/dist/task-agent-runner-CMq9Cir1.d.ts

@@ -0,0 +1,160 @@
+import * as react from 'react';
+import { ReactNode } from 'react';
+import { P as ProvisionSpec, a as ProvisionResult, b as DiscoveredDevice, A as AgentTaskTargetStatus, c as AgentTaskTarget, d as AgentTaskBlocker, e as AgentTaskEvidence } from './types-C2WXVcam.js';
+import { N as NormalizedDevice } from './device-normalize-BaThgnH7.js';
+import { A as AixConfig, R as ResolvedConfig } from './config-fsx4jlLK.js';
+import { A as AgentKind } from './agent-runner-V60B0is1.js';
+
+interface Device {
+    id: string;
+    name: string;
+    platform: 'ios' | 'android' | 'macos' | 'windows';
+    status: 'connected' | 'disconnected' | 'connecting';
+    udid: string;
+    /** Live online state from the backend node registry. */
+    online: boolean;
+    /** Capability/spec metadata reported by the node (os_version, model, rooted, tier, provisioned…). */
+    meta: Record<string, unknown>;
+    /** User-defined group tags. */
+    tags: string[];
+    /** User-set free-text remark ("" = unset). */
+    note: string;
+    /** Creation timestamp in ms (0 if unknown). */
+    createdAt: number;
+    /** Node this device lives on (from the live registry), if any. */
+    nodeId: string | null;
+    nodeName: string | null;
+    /** Underlying transport rows merged into this device (USB + WiFi → length > 1). */
+    transports: NormalizedDevice['transports'];
+}
+declare function mapDevice(r: NormalizedDevice): Device;
+interface DevicesView {
+    devices: Device[];
+    selectedDeviceId: string | null;
+    loading: boolean;
+    error: string | null;
+    /** Reload the device list. `silent` skips the loading flag (for throttled refreshes). */
+    fetchDevices: (opts?: {
+        silent?: boolean;
+    }) => Promise<void>;
+    /** Throttled silent refresh (≤ once per ~5s); used by card preview polling. */
+    refreshDevicesSoon: () => void;
+    selectDevice: (id: string | null) => void;
+    connectDevice: (platform: string) => Promise<void>;
+    disconnectDevice: (id: string) => Promise<void>;
+    provisionDevice: (spec: ProvisionSpec) => Promise<ProvisionResult>;
+    discoverDevices: (nodeId: string) => Promise<DiscoveredDevice[]>;
+    enrollDiscovered: (d: DiscoveredDevice) => Promise<void>;
+    updateTags: (deviceId: string, tags: string[]) => Promise<void>;
+    updateNote: (deviceId: string, note: string) => Promise<void>;
+}
+interface DevicesProviderProps {
+    children: ReactNode;
+    /** Fetch the list on mount (default true). */
+    autoFetch?: boolean;
+}
+declare function DevicesProvider({ children, autoFetch }: DevicesProviderProps): react.FunctionComponentElement<react.ProviderProps<DevicesView | null>>;
+/** Access the shared devices view. Must be inside a `<DevicesProvider>`. */
+declare function useDevicesView(): DevicesView;
+
+/** A node snapshot carried with a selected device for task-agent preflight. */
+interface TaskAgentNodeSnapshot {
+    id: string;
+    status: 'online' | 'offline' | 'unknown';
+    reported_caps?: Record<string, unknown> | null;
+}
+/** A device selected for a multi-device agent task. */
+interface TaskAgentDevice {
+    id: string;
+    name: string;
+    /**
+     * Optional on purpose: injected/custom runners may not have node registry data.
+     * `undefined` keeps those hosts backwards-compatible; `null` means the host
+     * explicitly knows that this device has no currently resolvable node.
+     */
+    node?: TaskAgentNodeSnapshot | null;
+}
+interface TaskAgentPreflightResult {
+    ok: boolean;
+    reason?: string;
+}
+/**
+ * Validate the node-advertised capability used by durable task-agent dispatch.
+ * Missing snapshots are intentionally accepted for custom runners that cannot
+ * access the node registry; callers that own the registry should pass `null`
+ * for an explicitly unknown node so it fails closed.
+ */
+declare function preflightTaskAgentDevice(device: TaskAgentDevice, agent: AgentKind, policyId?: string): TaskAgentPreflightResult;
+/** Request emitted by the portable multi-device agent UI. */
+interface TaskAgentRunRequest {
+    agent: AgentKind;
+    deviceIds: string[];
+    prompt: string;
+    /** Maximum number of device agents the host should run at once. */
+    concurrency: number;
+}
+/** The UI-facing target lifecycle. Only succeeded, failed, and cancelled are terminal. */
+type TaskAgentDeviceStatus = AgentTaskTargetStatus;
+/** A streamed, cursor-ordered event from a multi-device agent runner. */
+interface TaskAgentStreamEvent {
+    runId: string;
+    targetId?: string;
+    attemptId?: string;
+    deviceId?: string;
+    cursor?: number;
+    stream: 'stdout' | 'stderr' | 'status' | 'done' | 'evidence';
+    chunk?: string;
+    status?: TaskAgentDeviceStatus;
+    error?: string;
+    blocker?: AgentTaskBlocker | null;
+    /** Canonical display-safe reason for a blocked target. */
+    blockedReason?: string;
+    evidence?: AgentTaskEvidence[];
+}
+/** Stable target data returned with a newly submitted agent task. */
+interface TaskAgentTarget extends AgentTaskTarget {
+}
+/**
+ * Multi-device agent transport used by both web and desktop hosts. The task
+ * itself executes on the selected device node; the UI only submits and replays
+ * the durable backend task stream.
+ */
+interface TaskAgentRunner {
+    available: boolean;
+    defaults?: () => Promise<{
+        agent?: AgentKind;
+        concurrency?: number;
+    }>;
+    start: (request: TaskAgentRunRequest) => Promise<{
+        runId: string;
+        targets: TaskAgentTarget[];
+    }>;
+    /** Reloads a durable task after a host/page reload and resumes its event stream. */
+    resume?: (runId: string, devices: TaskAgentDevice[]) => Promise<{
+        runId: string;
+        targets: TaskAgentTarget[];
+        agent?: AgentKind;
+        concurrency?: number;
+    }>;
+    /** Atomically cancels the durable task and all of its targets. */
+    stop: (runId: string) => Promise<void>;
+    stopDevice: (runId: string, targetId: string) => Promise<void>;
+    retryDevice: (runId: string, targetId: string) => Promise<void>;
+    approveDevice: (runId: string, targetId: string) => Promise<void>;
+    subscribe: (on: (event: TaskAgentStreamEvent) => void) => () => void;
+}
+interface AgentTaskRunnerOptions {
+    /** API prefix for durable agent tasks. */
+    basePath?: string;
+    /** Backend policy identifier; CLI agent tasks only support the standard policy. */
+    policyId?: 'device_standard_v1';
+}
+/**
+ * Builds the portable agent-task runner from the shared SDK configuration.
+ * Events are deduplicated by their durable cursor. A reconnect resumes with
+ * `after=cursor`; a detected live-stream gap is filled from the REST event log
+ * before the newer frame is applied.
+ */
+declare function createAgentTaskRunner(cfg: AixConfig | ResolvedConfig, opts?: AgentTaskRunnerOptions): TaskAgentRunner;
+
+export { type AgentTaskRunnerOptions as A, type Device as D, type TaskAgentRunner as T, type TaskAgentDevice as a, type TaskAgentDeviceStatus as b, type TaskAgentNodeSnapshot as c, type TaskAgentPreflightResult as d, type TaskAgentRunRequest as e, type TaskAgentStreamEvent as f, type TaskAgentTarget as g, createAgentTaskRunner as h, DevicesProvider as i, type DevicesProviderProps as j, type DevicesView as k, mapDevice as m, preflightTaskAgentDevice as p, useDevicesView as u };