@aixnn/aixautots 0.0.0-stage → 0.5.2

package/dist/chunk-EHF2WQUR.js

@@ -0,0 +1,2042 @@
+import { MirrorSession, normalizeDevices, submitBatch } from './chunk-H7MHGYF3.js';
+import { useDevice, useAixConfig, useClient, useQuery } from './chunk-SUKFJ73W.js';
+import { FlowRun } from './chunk-GKEPMDXO.js';
+import { isFleetRunTerminal, resolveConfig, joinUrl, AixAuthError, AixError, detectEnvOs, EnvRun, summarizeEnv, ReconnectingSocket, executionWsTicketUrl } from './chunk-PCYERBNZ.js';
+import { createContext, useState, useRef, useEffect, useCallback, useMemo, createElement, useContext } from 'react';
+
+function useCommands(deviceId) {
+  const { channel, error: openError } = useDevice(deviceId);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [lastResult, setLastResult] = useState(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+    };
+  }, []);
+  const adb = useCallback(async (argv, opts) => {
+    if (!channel) throw new Error("device channel not ready");
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const r = await channel.adbExec(argv, opts);
+      if (mountedRef.current) {
+        setLastResult(r);
+        setLoading(false);
+      }
+      return r;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      if (mountedRef.current) {
+        setError(err);
+        setLoading(false);
+      }
+      throw err;
+    }
+  }, [channel]);
+  const wda = useCallback(async (method, path, body) => {
+    if (!channel) throw new Error("device channel not ready");
+    if (mountedRef.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const r = await channel.wdaReq(method, path, body);
+      if (mountedRef.current) {
+        setLastResult(r);
+        setLoading(false);
+      }
+      return r;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      if (mountedRef.current) {
+        setError(err);
+        setLoading(false);
+      }
+      throw err;
+    }
+  }, [channel]);
+  return { ready: channel !== null, loading, error: error ?? openError, lastResult, adb, wda };
+}
+function useFlowRun() {
+  const cfg = useAixConfig();
+  const [taskId, setTaskId] = useState(null);
+  const [events, setEvents] = useState([]);
+  const [done, setDone] = useState(false);
+  const [error, setError] = useState(null);
+  const runRef = useRef(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    return () => {
+      mountedRef.current = false;
+      runRef.current?.close();
+      runRef.current = null;
+    };
+  }, []);
+  const submit = useCallback(async (body) => {
+    runRef.current?.close();
+    if (mountedRef.current) {
+      setError(null);
+      setEvents([]);
+      setDone(false);
+      setTaskId(null);
+    }
+    try {
+      const fr = await FlowRun.submit(cfg, body);
+      runRef.current = fr;
+      fr.on("event", (e) => {
+        if (mountedRef.current) setEvents((prev) => [...prev, e]);
+      });
+      fr.on("done", () => {
+        if (mountedRef.current) setDone(true);
+      });
+      if (mountedRef.current) setTaskId(fr.taskId);
+      return { taskId: fr.taskId };
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      if (mountedRef.current) setError(err);
+      throw err;
+    }
+  }, [cfg]);
+  const close = useCallback(() => {
+    runRef.current?.close();
+    runRef.current = null;
+  }, []);
+  return { taskId, events, done, error, submit, close };
+}
+function useMirror(sessionId) {
+  const cfg = useAixConfig();
+  const [session, setSession] = useState(null);
+  const [stream, setStream] = useState(null);
+  const [error, setError] = useState(null);
+  const ref = useRef(null);
+  const mountedRef = useRef(true);
+  useEffect(() => {
+    mountedRef.current = true;
+    let cancelled = false;
+    setSession(null);
+    setStream(null);
+    setError(null);
+    if (!sessionId) return () => {
+      mountedRef.current = false;
+    };
+    MirrorSession.join(cfg, sessionId).then((ms) => {
+      if (cancelled) {
+        ms.leave();
+        return;
+      }
+      ref.current = ms;
+      setSession(ms);
+      ms.onStream((s) => {
+        if (mountedRef.current) setStream(s);
+      });
+      ms.onConnectionStateChange(() => {
+        if (mountedRef.current) setStream(ms.stream);
+      });
+    }).catch((e) => {
+      if (!cancelled) setError(e instanceof Error ? e : new Error(String(e)));
+    });
+    return () => {
+      cancelled = true;
+      mountedRef.current = false;
+      ref.current?.leave();
+      ref.current = null;
+    };
+  }, [cfg, sessionId]);
+  const sendInput = useCallback((msg) => {
+    ref.current?.sendInput(msg);
+  }, []);
+  const setQuality = useCallback((profile) => {
+    ref.current?.setQuality(profile);
+  }, []);
+  return { session, stream, error, sendInput, setQuality };
+}
+var GROUP_MIRROR_MAX = 9;
+function useGroupMirror(ids) {
+  const cfg = useAixConfig();
+  const [streams, setStreams] = useState(/* @__PURE__ */ new Map());
+  const [errors, setErrors] = useState(/* @__PURE__ */ new Map());
+  const [connected, setConnected] = useState(0);
+  const sessionsRef = useRef(/* @__PURE__ */ new Map());
+  const idsKey = ids.slice(0, GROUP_MIRROR_MAX).join("\n");
+  const truncated = ids.length > GROUP_MIRROR_MAX;
+  useEffect(() => {
+    let cancelled = false;
+    setStreams(/* @__PURE__ */ new Map());
+    setErrors(/* @__PURE__ */ new Map());
+    setConnected(0);
+    if (truncated) {
+      console.warn(`[aixautots] useGroupMirror: ${GROUP_MIRROR_MAX} \u53F0\u8F6F\u4E0A\u9650,\u8D85\u51FA\u90E8\u5206\u5DF2\u622A\u65AD`);
+    }
+    const take = idsKey ? idsKey.split("\n") : [];
+    for (const id of take) {
+      MirrorSession.join(cfg, id).then((ms) => {
+        if (cancelled) {
+          ms.leave();
+          return;
+        }
+        sessionsRef.current.set(id, ms);
+        setConnected(sessionsRef.current.size);
+        ms.onStream((s) => {
+          if (!cancelled) setStreams((prev) => new Map(prev).set(id, s));
+        });
+      }).catch((e) => {
+        if (!cancelled) setErrors((prev) => new Map(prev).set(id, e instanceof Error ? e : new Error(String(e))));
+      });
+    }
+    return () => {
+      cancelled = true;
+      for (const ms of sessionsRef.current.values()) ms.leave();
+      sessionsRef.current = /* @__PURE__ */ new Map();
+    };
+  }, [cfg, idsKey, truncated]);
+  const broadcastInput = useCallback((msg) => {
+    for (const ms of sessionsRef.current.values()) ms.sendInput(msg);
+  }, []);
+  const setQualityAll = useCallback((profile) => {
+    for (const ms of sessionsRef.current.values()) ms.setQuality(profile);
+  }, []);
+  return { streams, errors, connected, broadcastInput, setQualityAll };
+}
+function useAuth() {
+  const c = useClient();
+  return {
+    login: useCallback((e, p) => c.auth.login(e, p), [c]),
+    register: useCallback((e, p) => c.auth.register(e, p), [c]),
+    sendCode: useCallback((e) => c.auth.sendCode(e), [c]),
+    verifyCode: useCallback((e, code) => c.auth.verifyCode(e, code), [c]),
+    setPassword: useCallback((p) => c.auth.setPassword(p), [c]),
+    projectUser: useCallback((id) => c.auth.projectUser(id), [c])
+  };
+}
+function useProjects() {
+  const c = useClient();
+  const q = useQuery(() => c.projects.list(), [c]);
+  const { setData } = q;
+  const create = useCallback(async (input) => {
+    const r = await c.projects.create(input);
+    setData((prev) => [...prev ?? [], r.project]);
+    return r;
+  }, [c, setData]);
+  const remove = useCallback(async (id) => {
+    await c.projects.remove(id);
+    setData((prev) => (prev ?? []).filter((p) => p.id !== id));
+  }, [c, setData]);
+  const rotateSecret = useCallback(async (id) => (await c.projects.rotateSecret(id)).secret, [c]);
+  return { ...q, create, remove, rotateSecret };
+}
+function useDevices() {
+  const c = useClient();
+  return useQuery(() => c.devices.list(), [c]);
+}
+function useDeviceActions(deviceId) {
+  const c = useClient();
+  return {
+    power: useCallback((action, extra) => c.devices.power(deviceId, action, extra), [c, deviceId]),
+    control: useCallback((op) => c.devices.control(deviceId, op), [c, deviceId]),
+    installApkUrl: useCallback((url) => c.devices.installApkUrl(deviceId, url), [c, deviceId]),
+    lease: useCallback(() => c.devices.lease(deviceId), [c, deviceId]),
+    release: useCallback(() => c.devices.release(deviceId), [c, deviceId]),
+    claim: useCallback(() => c.devices.claim(deviceId), [c, deviceId]),
+    screenshot: useCallback(() => c.devices.screenshot(deviceId), [c, deviceId]),
+    captureUiTree: useCallback(() => c.devices.captureUiTree(deviceId), [c, deviceId])
+  };
+}
+function mapDevice(r) {
+  const meta = r.meta ?? {};
+  let platform = r.platform ?? meta.platform ?? r.kind ?? "android";
+  if (platform === "desktop") {
+    const os = String(meta.os ?? "");
+    if (os === "windows" || os === "macos") platform = os;
+  }
+  const online = r.online === true;
+  const provisioned = meta.provisioned === true;
+  const createdMs = r.created_at ? Date.parse(r.created_at) : 0;
+  const booting = !online && provisioned && createdMs > 0 && Date.now() - createdMs < 12e4;
+  return {
+    id: r.device_id,
+    name: r.name || meta.name || r.external_id,
+    platform,
+    status: online ? "connected" : booting ? "connecting" : "disconnected",
+    udid: r.external_id,
+    online,
+    meta,
+    tags: r.tags ?? [],
+    note: r.note ?? "",
+    nodeId: r.node_id ?? null,
+    nodeName: r.node_name ?? null,
+    transports: r.transports,
+    createdAt: createdMs
+  };
+}
+var DevicesContext = createContext(null);
+function DevicesProvider({ children, autoFetch = true }) {
+  const client = useClient();
+  const [devices, setDevices] = useState([]);
+  const [selectedDeviceId, setSelectedDeviceId] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const lastSoonRef = useRef(0);
+  const fetchDevices = useCallback(
+    async (opts) => {
+      const silent = opts?.silent === true;
+      if (!silent) {
+        setLoading(true);
+        setError(null);
+      }
+      try {
+        const rows = await client.devices.list();
+        setDevices(normalizeDevices(rows).map(mapDevice));
+        setLoading(false);
+      } catch (err) {
+        if (silent) setLoading(false);
+        else {
+          setError(String(err));
+          setLoading(false);
+        }
+      }
+    },
+    [client]
+  );
+  const refreshDevicesSoon = useCallback(() => {
+    const now = Date.now();
+    if (now - lastSoonRef.current < 5e3) return;
+    lastSoonRef.current = now;
+    void fetchDevices({ silent: true });
+  }, [fetchDevices]);
+  const selectDevice = useCallback((id) => setSelectedDeviceId(id), []);
+  const connectDevice = useCallback(
+    async (_platform) => {
+      await fetchDevices();
+    },
+    [fetchDevices]
+  );
+  const disconnectDevice = useCallback(async (id) => {
+    setDevices((prev) => prev.filter((d) => d.id !== id));
+    setSelectedDeviceId((sel) => sel === id ? null : sel);
+  }, []);
+  const provisionDevice = useCallback(
+    async (spec) => {
+      const res = await client.devices.provision(spec);
+      await fetchDevices();
+      return res;
+    },
+    [client, fetchDevices]
+  );
+  const discoverDevices = useCallback(
+    async (nodeId) => {
+      const { devices: ds } = await client.nodes.discoverDevices(nodeId);
+      return ds;
+    },
+    [client]
+  );
+  const enrollDiscovered = useCallback(
+    async (d) => {
+      if (d.status === "unregistered") {
+        await client.devices.register({
+          external_id: d.external_id,
+          kind: d.platform ?? void 0,
+          name: d.model ?? d.external_id
+        });
+      } else {
+        await client.devices.claim(d.external_id);
+      }
+      await fetchDevices();
+    },
+    [client, fetchDevices]
+  );
+  const updateTags = useCallback(
+    async (deviceId, tags) => {
+      await client.devices.update(deviceId, { tags });
+      await fetchDevices();
+    },
+    [client, fetchDevices]
+  );
+  const updateNote = useCallback(
+    async (deviceId, note) => {
+      await client.devices.update(deviceId, { note });
+      await fetchDevices();
+    },
+    [client, fetchDevices]
+  );
+  useEffect(() => {
+    if (autoFetch) void fetchDevices();
+  }, [autoFetch]);
+  const value = useMemo(
+    () => ({
+      devices,
+      selectedDeviceId,
+      loading,
+      error,
+      fetchDevices,
+      refreshDevicesSoon,
+      selectDevice,
+      connectDevice,
+      disconnectDevice,
+      provisionDevice,
+      discoverDevices,
+      enrollDiscovered,
+      updateTags,
+      updateNote
+    }),
+    [
+      devices,
+      selectedDeviceId,
+      loading,
+      error,
+      fetchDevices,
+      refreshDevicesSoon,
+      selectDevice,
+      connectDevice,
+      disconnectDevice,
+      provisionDevice,
+      discoverDevices,
+      enrollDiscovered,
+      updateTags,
+      updateNote
+    ]
+  );
+  return createElement(DevicesContext.Provider, { value }, children);
+}
+function useDevicesView() {
+  const ctx = useContext(DevicesContext);
+  if (!ctx) throw new Error("useDevicesView() must be used within <DevicesProvider>");
+  return ctx;
+}
+var NodesContext = createContext(null);
+function NodesProvider({ children, autoFetch = true }) {
+  const client = useClient();
+  const [nodes, setNodes] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const fetchNodes = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    try {
+      setNodes(await client.nodes.list());
+      setLoading(false);
+    } catch (err) {
+      setError(String(err));
+      setLoading(false);
+    }
+  }, [client]);
+  const refreshNodes = useCallback(async () => {
+    try {
+      setNodes(await client.nodes.list());
+    } catch {
+    }
+  }, [client]);
+  const createNode = useCallback(
+    async (name, scope, region) => {
+      const res = await client.nodes.register({ name, scope, region: region || null });
+      await fetchNodes();
+      return res;
+    },
+    [client, fetchNodes]
+  );
+  const updateNode = useCallback(
+    async (id, patch) => {
+      await client.nodes.update(id, patch);
+      await fetchNodes();
+    },
+    [client, fetchNodes]
+  );
+  const rotateToken = useCallback(
+    (id) => client.nodes.rotateToken(id),
+    [client]
+  );
+  const removeNode = useCallback(
+    async (id) => {
+      await client.nodes.remove(id);
+      await fetchNodes();
+    },
+    [client, fetchNodes]
+  );
+  useEffect(() => {
+    if (autoFetch) void fetchNodes();
+  }, [autoFetch]);
+  const value = useMemo(
+    () => ({
+      nodes,
+      loading,
+      error,
+      fetchNodes,
+      refreshNodes,
+      createNode,
+      updateNode,
+      rotateToken,
+      removeNode
+    }),
+    [nodes, loading, error, fetchNodes, refreshNodes, createNode, updateNode, rotateToken, removeNode]
+  );
+  return createElement(NodesContext.Provider, { value }, children);
+}
+function useNodesView() {
+  const ctx = useContext(NodesContext);
+  if (!ctx) throw new Error("useNodesView() must be used within <NodesProvider>");
+  return ctx;
+}
+function errMsg(reason) {
+  if (reason instanceof Error) return reason.message;
+  return String(reason);
+}
+var ShortcutsContext = createContext(null);
+function ShortcutsProvider({ children }) {
+  const client = useClient();
+  const [shortcuts, setShortcuts] = useState([]);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const fetch = useCallback(
+    async (platform) => {
+      setLoading(true);
+      setError(null);
+      try {
+        const rows = await client.shortcuts.list(platform);
+        setShortcuts(rows);
+        setLoading(false);
+      } catch (e) {
+        setError(String(e));
+        setLoading(false);
+      }
+    },
+    [client]
+  );
+  const create = useCallback(
+    async (body) => {
+      try {
+        const row = await client.shortcuts.create(body);
+        setShortcuts((prev) => [...prev, row]);
+        return row;
+      } catch (e) {
+        setError(String(e));
+        return null;
+      }
+    },
+    [client]
+  );
+  const update = useCallback(
+    async (id, body) => {
+      try {
+        const row = await client.shortcuts.update(id, body);
+        setShortcuts((prev) => prev.map((x) => x.id === id ? row : x));
+        return row;
+      } catch (e) {
+        setError(String(e));
+        return null;
+      }
+    },
+    [client]
+  );
+  const remove = useCallback(
+    async (id) => {
+      try {
+        await client.shortcuts.remove(id);
+        setShortcuts((prev) => prev.filter((x) => x.id !== id));
+      } catch (e) {
+        setError(String(e));
+      }
+    },
+    [client]
+  );
+  const runShortcut = useCallback(
+    async (shortcut, values, deviceIds) => {
+      if (deviceIds.length === 0) return null;
+      const { run_id } = await client.fleet.start({
+        script: {
+          name: shortcut.name,
+          platform: shortcut.platform === "ios" ? "iOS" : "Android",
+          language: shortcut.language,
+          code: shortcut.body,
+          variables: values
+        },
+        mode: "Broadcast",
+        device_ids: deviceIds
+      });
+      const detail = await client.fleet.waitForRun(run_id);
+      return { run_id, detail, timedOut: !isFleetRunTerminal(detail) };
+    },
+    [client]
+  );
+  const runPower = useCallback(
+    async (shortcut, deviceIds) => {
+      const settled = await Promise.allSettled(
+        deviceIds.map((id) => client.devices.power(id, shortcut.body))
+      );
+      return settled.map((s, i) => {
+        const device_id = deviceIds[i] ?? "";
+        return s.status === "fulfilled" ? { device_id, ok: true, result: s.value } : { device_id, ok: false, error: errMsg(s.reason) };
+      });
+    },
+    [client]
+  );
+  const value = useMemo(
+    () => ({ shortcuts, loading, error, fetch, create, update, remove, runShortcut, runPower }),
+    [shortcuts, loading, error, fetch, create, update, remove, runShortcut, runPower]
+  );
+  return createElement(ShortcutsContext.Provider, { value }, children);
+}
+function useShortcutsView() {
+  const ctx = useContext(ShortcutsContext);
+  if (!ctx) throw new Error("useShortcutsView() must be used within <ShortcutsProvider>");
+  return ctx;
+}
+function useScripts() {
+  const c = useClient();
+  const q = useQuery(() => c.scripts.list(), [c]);
+  const { setData, refetch } = q;
+  const get = useCallback((id) => c.scripts.get(id), [c]);
+  const save = useCallback(async (script) => {
+    const r = await c.scripts.save(script);
+    await refetch();
+    return r;
+  }, [c, refetch]);
+  const remove = useCallback(async (id) => {
+    await c.scripts.remove(id);
+    setData((prev) => (prev ?? []).filter((s) => s.id !== id));
+  }, [c, setData]);
+  const duplicate = useCallback(async (id) => {
+    const r = await c.scripts.duplicate(id);
+    setData((prev) => [...prev ?? [], r]);
+    return r;
+  }, [c, setData]);
+  const setVisibility = useCallback(async (id, visibility) => {
+    const r = await c.scripts.setVisibility(id, visibility);
+    setData((prev) => (prev ?? []).map((s) => s.id === id ? { ...s, ...r } : s));
+    return r;
+  }, [c, setData]);
+  return { ...q, get, save, remove, duplicate, setVisibility };
+}
+function useClusters() {
+  const c = useClient();
+  const q = useQuery(() => c.clusters.list(), [c]);
+  const { setData } = q;
+  const create = useCallback(async (input) => {
+    const cl = await c.clusters.create(input);
+    setData((prev) => [...prev ?? [], cl]);
+    return cl;
+  }, [c, setData]);
+  const remove = useCallback(async (id) => {
+    await c.clusters.remove(id);
+    setData((prev) => (prev ?? []).filter((x) => x.id !== id));
+  }, [c, setData]);
+  const setDevices = useCallback(async (id, deviceIds) => {
+    const cl = await c.clusters.setDevices(id, deviceIds);
+    setData((prev) => (prev ?? []).map((x) => x.id === id ? cl : x));
+    return cl;
+  }, [c, setData]);
+  const run = useCallback((id, flow) => c.clusters.run(id, flow), [c]);
+  return { ...q, create, remove, setDevices, run };
+}
+var TERMINAL = /* @__PURE__ */ new Set(["done", "failed", "cancelled"]);
+function useFleetRun(pollMs = 1e3) {
+  const c = useClient();
+  const [runId, setRunId] = useState(null);
+  const [status, setStatus] = useState("idle");
+  const [progress, setProgress] = useState(0);
+  const [detail, setDetail] = useState(null);
+  const [error, setError] = useState(null);
+  const timer = useRef(null);
+  const mounted = useRef(true);
+  const stopTimer = useCallback(() => {
+    if (timer.current) {
+      clearInterval(timer.current);
+      timer.current = null;
+    }
+  }, []);
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+      stopTimer();
+    };
+  }, [stopTimer]);
+  const start = useCallback(async (script, deviceIds, mode = "Broadcast") => {
+    stopTimer();
+    setStatus("running");
+    setProgress(0);
+    setDetail(null);
+    setError(null);
+    setRunId(null);
+    try {
+      const { run_id } = await c.fleet.start({ script, mode, device_ids: deviceIds });
+      setRunId(run_id);
+      timer.current = setInterval(async () => {
+        try {
+          const d = await c.fleet.get(run_id);
+          if (!mounted.current) return;
+          setDetail(d);
+          const rows = d.devices ?? [];
+          const total = rows.length;
+          const done = rows.filter((r) => TERMINAL.has(r.status)).length;
+          if (total > 0 && done === total) {
+            stopTimer();
+            const anyFailed = rows.some((r) => r.status === "failed" || r.status === "error");
+            setStatus(anyFailed ? "failed" : "completed");
+            setProgress(100);
+          } else {
+            setProgress(total > 0 ? Math.round(done / total * 100) : 0);
+          }
+        } catch (e) {
+          stopTimer();
+          if (mounted.current) {
+            setError(e instanceof Error ? e : new Error(String(e)));
+            setStatus("failed");
+          }
+        }
+      }, pollMs);
+      return run_id;
+    } catch (e) {
+      const err = e instanceof Error ? e : new Error(String(e));
+      if (mounted.current) {
+        setError(err);
+        setStatus("failed");
+      }
+      throw err;
+    }
+  }, [c, pollMs, stopTimer]);
+  const cancel = useCallback(async () => {
+    stopTimer();
+    if (runId) await c.fleet.cancel(runId);
+    if (mounted.current) setStatus("completed");
+  }, [c, runId, stopTimer]);
+  const pause = useCallback(async () => {
+    if (!runId) return;
+    await c.fleet.pause(runId);
+    if (mounted.current) setStatus("paused");
+  }, [c, runId]);
+  const resume = useCallback(async () => {
+    if (!runId) return;
+    await c.fleet.resume(runId);
+    if (mounted.current) setStatus("running");
+  }, [c, runId]);
+  const reset = useCallback(() => {
+    stopTimer();
+    setRunId(null);
+    setStatus("idle");
+    setProgress(0);
+    setDetail(null);
+    setError(null);
+  }, [stopTimer]);
+  return { runId, status, progress, detail, error, start, cancel, pause, resume, reset };
+}
+var TERMINAL_DEVICE_STATUSES = /* @__PURE__ */ new Set(["done", "failed", "cancelled"]);
+function levelForStatus(status) {
+  if (status === "failed" || status === "error") return "error";
+  if (status === "cancelled" || status === "paused") return "warn";
+  if (status === "done" || status === "completed") return "info";
+  return "debug";
+}
+function entry(level, msg, device, ts) {
+  return { ts: ts ?? (/* @__PURE__ */ new Date()).toISOString(), level, msg, device };
+}
+function useScriptRun(pollMs = 1e3) {
+  const c = useClient();
+  const [runId, setRunId] = useState(null);
+  const [status, setStatus] = useState("idle");
+  const [progress, setProgress] = useState(0);
+  const [steps] = useState([]);
+  const [logs, setLogs] = useState([]);
+  const [error, setError] = useState(null);
+  const timer = useRef(null);
+  const runIdRef = useRef(null);
+  const deviceStatus = useRef({});
+  const mounted = useRef(true);
+  const stopTimer = useCallback(() => {
+    if (timer.current) {
+      clearInterval(timer.current);
+      timer.current = null;
+    }
+  }, []);
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+      stopTimer();
+    };
+  }, [stopTimer]);
+  const appendLogs = useCallback((lines) => {
+    if (lines.length && mounted.current) setLogs((prev) => [...prev, ...lines]);
+  }, []);
+  const startWithBody = useCallback(
+    async (scriptBody, deviceIds) => {
+      stopTimer();
+      deviceStatus.current = {};
+      runIdRef.current = null;
+      if (!mounted.current) return;
+      setRunId(null);
+      setStatus("running");
+      setProgress(0);
+      setError(null);
+      setLogs([
+        entry(
+          "system",
+          `Starting run on ${deviceIds.length} device${deviceIds.length === 1 ? "" : "s"}\u2026`
+        )
+      ]);
+      try {
+        const { run_id } = await c.fleet.start({
+          script: scriptBody,
+          mode: "Broadcast",
+          device_ids: deviceIds
+        });
+        if (!mounted.current) return;
+        runIdRef.current = run_id;
+        setRunId(run_id);
+        appendLogs([entry("system", `Run submitted \xB7 ${run_id}`)]);
+        timer.current = setInterval(async () => {
+          try {
+            const detail = await c.fleet.get(run_id);
+            if (!mounted.current) return;
+            const rows = detail.devices ?? [];
+            const total = rows.length;
+            const done = rows.filter((r) => TERMINAL_DEVICE_STATUSES.has(r.status)).length;
+            const pct = total > 0 ? Math.round(done / total * 100) : 0;
+            const prev = deviceStatus.current;
+            const nextStatus = { ...prev };
+            const newLines = [];
+            for (const r of rows) {
+              if (prev[r.device_id] !== r.status) {
+                nextStatus[r.device_id] = r.status;
+                const suffix = r.last_error ? ` \u2014 ${r.last_error}` : "";
+                newLines.push(
+                  entry(levelForStatus(r.status), `${r.status}${suffix}`, r.device_id)
+                );
+                if (TERMINAL_DEVICE_STATUSES.has(r.status) && r.output) {
+                  for (const line of r.output.split("\n")) {
+                    if (line.trim()) newLines.push(entry("info", line, r.device_id));
+                  }
+                }
+              }
+            }
+            deviceStatus.current = nextStatus;
+            if (total > 0 && done === total) {
+              const anyFailed = rows.some(
+                (r) => r.status === "failed" || r.status === "error"
+              );
+              stopTimer();
+              newLines.push(
+                entry(
+                  anyFailed ? "error" : "system",
+                  anyFailed ? "Run failed." : "Run completed."
+                )
+              );
+              setStatus(anyFailed ? "failed" : "completed");
+              setProgress(100);
+            } else {
+              setProgress(pct);
+            }
+            appendLogs(newLines);
+          } catch (err) {
+            stopTimer();
+            if (!mounted.current) return;
+            setError(String(err));
+            setStatus("failed");
+            appendLogs([entry("error", `Poll failed: ${String(err)}`)]);
+          }
+        }, pollMs);
+      } catch (err) {
+        if (!mounted.current) return;
+        setError(String(err));
+        setStatus("failed");
+        appendLogs([entry("error", `Failed to start run: ${String(err)}`)]);
+      }
+    },
+    [c, pollMs, stopTimer, appendLogs]
+  );
+  const startRun = useCallback(
+    async (scriptId, deviceIds) => {
+      if (deviceIds.length === 0) {
+        setError("No device selected");
+        setStatus("failed");
+        return;
+      }
+      const flow = await c.scripts.get(scriptId);
+      await startWithBody(flow, deviceIds);
+    },
+    [c, startWithBody]
+  );
+  const runCode = useCallback(
+    async (code, language, variables, deviceIds, platform = "Android") => {
+      if (deviceIds.length === 0) {
+        setError("No device selected");
+        setStatus("failed");
+        return;
+      }
+      await startWithBody(
+        { name: "(selection)", platform, language, code, variables },
+        deviceIds
+      );
+    },
+    [startWithBody]
+  );
+  const stopRun = useCallback(async () => {
+    stopTimer();
+    const id = runIdRef.current;
+    try {
+      if (id) await c.fleet.cancel(id);
+      if (mounted.current) {
+        setStatus("completed");
+        appendLogs([entry("warn", "Run stopped by user.")]);
+      }
+    } catch (err) {
+      if (mounted.current) setError(String(err));
+    }
+  }, [c, stopTimer, appendLogs]);
+  const pauseRun = useCallback(async () => {
+    const id = runIdRef.current;
+    if (!id) return;
+    try {
+      await c.fleet.pause(id);
+      if (mounted.current) {
+        setStatus("paused");
+        appendLogs([entry("warn", "Run paused.")]);
+      }
+    } catch (err) {
+      if (mounted.current) setError(String(err));
+    }
+  }, [c, appendLogs]);
+  const resumeRun = useCallback(async () => {
+    const id = runIdRef.current;
+    if (!id) return;
+    try {
+      await c.fleet.resume(id);
+      if (mounted.current) {
+        setStatus("running");
+        appendLogs([entry("system", "Run resumed.")]);
+      }
+    } catch (err) {
+      if (mounted.current) setError(String(err));
+    }
+  }, [c, appendLogs]);
+  const clearLogs = useCallback(() => {
+    if (mounted.current) setLogs([]);
+  }, []);
+  const reset = useCallback(() => {
+    stopTimer();
+    runIdRef.current = null;
+    deviceStatus.current = {};
+    if (!mounted.current) return;
+    setRunId(null);
+    setStatus("idle");
+    setProgress(0);
+    setLogs([]);
+    setError(null);
+  }, [stopTimer]);
+  return {
+    runId,
+    status,
+    progress,
+    steps,
+    logs,
+    error,
+    startRun,
+    runCode,
+    stopRun,
+    pauseRun,
+    resumeRun,
+    clearLogs,
+    reset
+  };
+}
+function log(level, msg, device) {
+  return { ts: (/* @__PURE__ */ new Date()).toISOString(), level, msg, device };
+}
+function terminal(status) {
+  return status === "succeeded" || status === "failed" || status === "cancelled" || status === "expired";
+}
+function eventKey(event) {
+  if (event.cursor === void 0) return void 0;
+  return [
+    event.runId,
+    event.cursor,
+    event.targetId ?? event.deviceId ?? "",
+    event.attemptId ?? "",
+    event.stream
+  ].join("\\u001f");
+}
+function mapTarget(device, target) {
+  return {
+    ...device,
+    targetId: target?.target_id,
+    attemptId: target?.attempt_id ?? void 0,
+    status: target?.status ?? "queued",
+    error: target?.error ?? void 0,
+    blocker: target?.blocker ?? null,
+    evidence: target?.evidence ?? []
+  };
+}
+function useTaskAgentRun(runner) {
+  const [runId, setRunId] = useState(null);
+  const [agent, setAgent] = useState("claude");
+  const [concurrency, setConcurrency] = useState(1);
+  const [devices, setDevices] = useState([]);
+  const [logs, setLogs] = useState([]);
+  const [error, setError] = useState(null);
+  const runIdRef = useRef(null);
+  const eventKeysRef = useRef(/* @__PURE__ */ new Set());
+  const pendingEventsRef = useRef(/* @__PURE__ */ new Map());
+  const mountedRef = useRef(true);
+  const applyEvent = useCallback((event) => {
+    if (event.stream === "stdout" || event.stream === "stderr") {
+      if (event.chunk) {
+        setLogs((current) => [...current, log(event.stream === "stderr" ? "error" : "info", event.chunk, event.deviceId)]);
+      }
+      return;
+    }
+    if (event.stream === "evidence" && event.evidence?.length) {
+      setDevices((current) => current.map(
+        (device) => device.targetId === event.targetId || device.id === event.deviceId ? { ...device, evidence: [...device.evidence, ...event.evidence] } : device
+      ));
+      return;
+    }
+    if (!event.status) return;
+    const level = event.status === "failed" || event.status === "expired" ? "error" : event.status === "cancelled" || event.status === "cancel_requested" || event.status === "blocked" ? "warn" : "debug";
+    const message = event.error ?? event.blocker?.message ?? event.status;
+    setDevices((current) => current.map((device) => {
+      const matches = event.targetId && device.targetId === event.targetId || !event.targetId && device.id === event.deviceId;
+      if (!matches) return device;
+      return {
+        ...device,
+        attemptId: event.attemptId ?? device.attemptId,
+        status: event.status,
+        error: event.error,
+        blocker: event.blocker ?? (event.blockedReason ? { code: "blocked", message: event.blockedReason } : null),
+        evidence: event.evidence ? [...device.evidence, ...event.evidence] : device.evidence
+      };
+    }));
+    setLogs((current) => [...current, log(level, message, event.deviceId)]);
+    if (event.stream === "done" && event.error) {
+      setError(event.error);
+      setLogs((current) => [...current, log("error", event.error)]);
+    }
+  }, []);
+  const handleEvent = useCallback((event) => {
+    if (!mountedRef.current) return;
+    if (event.runId === runIdRef.current) {
+      const key = eventKey(event);
+      if (key !== void 0) {
+        if (eventKeysRef.current.has(key)) return;
+        eventKeysRef.current.add(key);
+      }
+      applyEvent(event);
+      return;
+    }
+    if (runIdRef.current === null) {
+      const pending = pendingEventsRef.current.get(event.runId) ?? [];
+      pending.push(event);
+      pendingEventsRef.current.set(event.runId, pending);
+    }
+  }, [applyEvent]);
+  useEffect(() => {
+    mountedRef.current = true;
+    if (!runner) return () => {
+      mountedRef.current = false;
+    };
+    const unsubscribe = runner.subscribe(handleEvent);
+    return () => {
+      mountedRef.current = false;
+      unsubscribe();
+    };
+  }, [runner, handleEvent]);
+  useEffect(() => {
+    if (!runner?.defaults) return;
+    void runner.defaults().then((defaults) => {
+      if (!mountedRef.current) return;
+      if (defaults.agent) setAgent(defaults.agent);
+      if (defaults.concurrency && defaults.concurrency > 0) setConcurrency(defaults.concurrency);
+    });
+  }, [runner]);
+  const start = useCallback(
+    async (input) => {
+      if (!runner?.available || input.devices.length === 0) return;
+      const selected = input.devices.map((device) => mapTarget(device));
+      setAgent(input.agent);
+      setConcurrency(input.concurrency);
+      setDevices(selected);
+      setLogs([log("system", `Starting ${input.agent} task on ${selected.length} device${selected.length === 1 ? "" : "s"}\u2026`)]);
+      setError(null);
+      runIdRef.current = null;
+      eventKeysRef.current.clear();
+      pendingEventsRef.current.clear();
+      setRunId(null);
+      try {
+        const started = await runner.start({
+          agent: input.agent,
+          deviceIds: selected.map((device) => device.id),
+          prompt: input.prompt,
+          concurrency: input.concurrency
+        });
+        if (!mountedRef.current) return;
+        const targetsByDevice = new Map(started.targets.map((target) => [target.device_id, target]));
+        setDevices(input.devices.map((device) => mapTarget(device, targetsByDevice.get(device.id))));
+        runIdRef.current = started.runId;
+        setRunId(started.runId);
+        const pending = pendingEventsRef.current.get(started.runId) ?? [];
+        pendingEventsRef.current.delete(started.runId);
+        for (const event of pending) handleEvent(event);
+        setLogs((current) => [...current, log("system", `Task started \xB7 ${started.runId}`)]);
+      } catch (reason) {
+        if (!mountedRef.current) return;
+        const message = String(reason);
+        setError(message);
+        setDevices((current) => current.map((device) => ({ ...device, status: "failed", error: message })));
+        setLogs((current) => [...current, log("error", `Failed to start task: ${message}`)]);
+      }
+    },
+    [runner, handleEvent]
+  );
+  const resume = useCallback(
+    async (id, inputDevices) => {
+      if (!runner?.available || !runner.resume || inputDevices.length === 0) return;
+      const selected = inputDevices.map((device) => mapTarget(device));
+      setDevices(selected);
+      setLogs([log("system", `Resuming agent task \xB7 ${id}\u2026`)]);
+      setError(null);
+      runIdRef.current = null;
+      eventKeysRef.current.clear();
+      pendingEventsRef.current.clear();
+      setRunId(null);
+      try {
+        const resumed = await runner.resume(id, inputDevices);
+        if (!mountedRef.current) return;
+        const targetsByDevice = new Map(resumed.targets.map((target) => [target.device_id, target]));
+        setDevices(inputDevices.map((device) => mapTarget(device, targetsByDevice.get(device.id))));
+        if (resumed.agent) setAgent(resumed.agent);
+        if (resumed.concurrency && resumed.concurrency > 0) setConcurrency(resumed.concurrency);
+        runIdRef.current = resumed.runId;
+        setRunId(resumed.runId);
+        const pending = pendingEventsRef.current.get(resumed.runId) ?? [];
+        pendingEventsRef.current.delete(resumed.runId);
+        for (const event of pending) handleEvent(event);
+        setLogs((current) => [...current, log("system", `Task resumed \xB7 ${resumed.runId}`)]);
+      } catch (reason) {
+        if (!mountedRef.current) return;
+        const message = String(reason);
+        setError(message);
+        setLogs((current) => [...current, log("error", `Failed to resume task: ${message}`)]);
+      }
+    },
+    [runner, handleEvent]
+  );
+  const cancelAll = useCallback(async () => {
+    const id = runIdRef.current;
+    if (!runner || !id) return;
+    try {
+      await runner.stop(id);
+    } catch (reason) {
+      if (mountedRef.current) setError(String(reason));
+    }
+  }, [runner]);
+  const targetFor = useCallback((deviceId) => devices.find((device) => device.id === deviceId)?.targetId, [devices]);
+  const withTarget = useCallback(async (deviceId, action) => {
+    const id = runIdRef.current;
+    const targetId = targetFor(deviceId);
+    if (!id || !targetId) return;
+    try {
+      await action(id, targetId);
+    } catch (reason) {
+      if (mountedRef.current) setError(String(reason));
+    }
+  }, [targetFor]);
+  const cancelDevice = useCallback(
+    (deviceId) => withTarget(deviceId, (taskId, targetId) => runner.stopDevice(taskId, targetId)),
+    [runner, withTarget]
+  );
+  const retryDevice = useCallback(
+    (deviceId) => withTarget(deviceId, (taskId, targetId) => runner.retryDevice(taskId, targetId)),
+    [runner, withTarget]
+  );
+  const approveDevice = useCallback(
+    (deviceId) => withTarget(deviceId, (taskId, targetId) => runner.approveDevice(taskId, targetId)),
+    [runner, withTarget]
+  );
+  const clearLogs = useCallback(() => setLogs([]), []);
+  const reset = useCallback(() => {
+    runIdRef.current = null;
+    eventKeysRef.current.clear();
+    pendingEventsRef.current.clear();
+    setRunId(null);
+    setDevices([]);
+    setLogs([]);
+    setError(null);
+  }, []);
+  const running = devices.some((device) => !terminal(device.status));
+  return {
+    runId,
+    agent,
+    concurrency,
+    devices,
+    logs,
+    error,
+    running,
+    start,
+    resume,
+    cancelAll,
+    cancelDevice,
+    retryDevice,
+    approveDevice,
+    clearLogs,
+    reset
+  };
+}
+
+// src/ui/devices/task-agent-runner.ts
+var MAX_TASK_AGENT_CAPACITY = 2147483647;
+function validTaskAgentCapacity(value) {
+  return typeof value === "number" && Number.isSafeInteger(value) && value > 0 && value <= MAX_TASK_AGENT_CAPACITY;
+}
+function preflightTaskAgentDevice(device, agent, policyId = "device_standard_v1") {
+  if (device.node === void 0) return { ok: true };
+  if (device.node === null || device.node.status === "unknown") {
+    return { ok: false, reason: "Node is unknown" };
+  }
+  if (device.node.status !== "online") return { ok: false, reason: "Node is offline" };
+  const caps = device.node.reported_caps;
+  if (!caps || typeof caps !== "object" || Array.isArray(caps)) {
+    return { ok: false, reason: "Node capabilities are unavailable" };
+  }
+  const taskAgent = caps.task_agent;
+  if (!taskAgent || typeof taskAgent !== "object" || Array.isArray(taskAgent)) {
+    return { ok: false, reason: "Task-agent v2 is unavailable" };
+  }
+  const taskAgentCaps = taskAgent;
+  if (typeof taskAgentCaps.version !== "number" || !Number.isSafeInteger(taskAgentCaps.version) || taskAgentCaps.version < 2) {
+    return { ok: false, reason: "Task-agent v2 is unavailable" };
+  }
+  const agents = taskAgentCaps.agents;
+  const agentCaps = agents && typeof agents === "object" && !Array.isArray(agents) ? agents[agent] : void 0;
+  if (!agentCaps || typeof agentCaps !== "object" || Array.isArray(agentCaps) || agentCaps.available !== true) {
+    return { ok: false, reason: `${agent === "claude" ? "Claude" : "Codex"} is unavailable on this node` };
+  }
+  const policyIds = agentCaps.policy_ids;
+  if (!Array.isArray(policyIds) || !policyIds.includes(policyId)) {
+    return { ok: false, reason: `${policyId} policy is unavailable` };
+  }
+  const maxWorkers = taskAgentCaps.max_workers;
+  if (!validTaskAgentCapacity(maxWorkers)) {
+    return { ok: false, reason: "Node reports no task-agent workers" };
+  }
+  const perDeviceSlots = taskAgentCaps.per_device_slots;
+  if (perDeviceSlots !== void 0 && perDeviceSlots !== null && !validTaskAgentCapacity(perDeviceSlots)) {
+    return { ok: false, reason: "Node reports no per-device task-agent slots" };
+  }
+  return { ok: true };
+}
+function normalizeBlocker(blocker) {
+  if (!blocker) return null;
+  if (typeof blocker === "string") return { code: "blocked", message: blocker };
+  if (typeof blocker !== "object") return null;
+  const value = blocker;
+  if (typeof value.code !== "string" || typeof value.message !== "string") return null;
+  return {
+    code: value.code,
+    message: value.message,
+    approval_id: value.approval_id ?? null,
+    data: value.data
+  };
+}
+function normalizeEvidence(evidence) {
+  if (!evidence) return [];
+  const items = Array.isArray(evidence) ? evidence : [evidence];
+  return items.flatMap((item) => {
+    if (typeof item !== "object" || item === null) return [];
+    if (typeof item.kind === "string") return [item];
+    return [{ kind: "task", data: item }];
+  });
+}
+var TERMINAL_STATUSES = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled", "expired"]);
+function statusOf(status) {
+  switch (status?.toLowerCase()) {
+    case "queued":
+    case "pending":
+      return "queued";
+    case "accepted":
+    case "authorizing":
+    case "preparing":
+    case "dispatching":
+      return "dispatching";
+    case "running":
+    case "started":
+      return "running";
+    case "verifying":
+      return "verifying";
+    case "blocked":
+      return "blocked";
+    case "cancel_requested":
+      return "cancel_requested";
+    case "cancelled":
+    case "canceled":
+      return "cancelled";
+    case "expired":
+      return "expired";
+    // `passed` is what the node SDK emits; `succeeded` is the durable v2 state.
+    case "passed":
+    case "completed":
+    case "complete":
+    case "success":
+    case "succeeded":
+    case "done":
+      return "succeeded";
+    case "failed":
+    case "error":
+      return "failed";
+    default:
+      return "running";
+  }
+}
+function logStream(event) {
+  return event.stream === "stderr" || event.level === "error" ? "stderr" : "stdout";
+}
+function logChunk(event) {
+  return event.chunk ?? event.line ?? event.message ?? event.output;
+}
+function eventTaskId(frame) {
+  return frame.task_id ?? frame.run_id;
+}
+function createAgentTaskRunner(cfg, opts = {}) {
+  const resolved = "auth" in cfg && typeof cfg.auth?.headers === "function" ? cfg : resolveConfig(cfg);
+  const basePath = (opts.basePath ?? "/api/agent-tasks").replace(/\/$/, "");
+  const policyId = opts.policyId ?? "device_standard_v1";
+  const subscribers = /* @__PURE__ */ new Set();
+  const targetsByRun = /* @__PURE__ */ new Map();
+  const emit = (event) => {
+    for (const subscriber of subscribers) subscriber(event);
+  };
+  const post = async (path) => {
+    const url = joinUrl(resolved.baseUrl, path);
+    const headers = { ...await resolved.auth.headers("caller"), "content-type": "application/json" };
+    const resp = await resolved.fetchFn(url, { method: "POST", headers, body: "{}" });
+    if (resp.ok) return;
+    const text = await resp.text().catch(() => "");
+    if (resp.status === 401 || resp.status === 403) throw new AixAuthError(`agent tasks ${resp.status}: ${text}`);
+    throw new AixError(`agent tasks ${resp.status}: ${text}`);
+  };
+  const targetPath = (runId, targetId, action) => `${basePath}/${encodeURIComponent(runId)}/targets/${encodeURIComponent(targetId)}/${action}`;
+  const attach = async (runId, initialTargets, initialCursor = 0) => {
+    const targets = new Map(initialTargets.map((target) => [target.target_id, target]));
+    targetsByRun.set(runId, targets);
+    let cursor = initialCursor;
+    let processing = Promise.resolve();
+    const appliedCursors = /* @__PURE__ */ new Set();
+    const deviceByTarget = new Map(initialTargets.map((target) => [target.target_id, target.device_id]));
+    const applyFrame = (frame) => {
+      const taskId = eventTaskId(frame);
+      const event = frame.event ?? (frame.kind ? { kind: frame.kind, ...frame.payload ?? {} } : void 0);
+      if (taskId !== runId || !event || !frame.target_id) return;
+      const targetId = frame.target_id;
+      const deviceId = frame.device_id ?? deviceByTarget.get(targetId);
+      const common = {
+        runId,
+        targetId,
+        attemptId: frame.attempt_id,
+        deviceId,
+        cursor: frame.cursor
+      };
+      const kind = event.kind?.toLowerCase();
+      const status = event.status === void 0 ? kind === "started" || kind === "running" ? "running" : kind === "accepted" ? "dispatching" : kind === "blocked" ? "blocked" : void 0 : statusOf(event.status);
+      if (kind === "log") {
+        const chunk = logChunk(event);
+        if (chunk) emit({ ...common, stream: logStream(event), chunk });
+        return;
+      }
+      if (kind === "evidence" || event.evidence?.length) {
+        if (event.evidence?.length) emit({ ...common, stream: "evidence", evidence: event.evidence });
+        if (kind === "evidence" && !status) return;
+      }
+      if (status) {
+        const stream = TERMINAL_STATUSES.has(status) || kind === "finished" ? "done" : "status";
+        if (event.output) emit({ ...common, stream: "stdout", chunk: event.output });
+        emit({
+          ...common,
+          stream,
+          status,
+          error: event.error,
+          blocker: event.blocker,
+          ...event.blocker?.message ? { blockedReason: event.blocker.message } : {},
+          evidence: event.evidence
+        });
+      }
+    };
+    let processFrame;
+    const fetchCatchup = async (after) => {
+      const headers = await resolved.auth.headers("caller");
+      const url = joinUrl(resolved.baseUrl, `${basePath}/${encodeURIComponent(runId)}/events?after=${encodeURIComponent(String(after))}`);
+      const resp = await resolved.fetchFn(url, { headers });
+      if (!resp.ok) {
+        const text = await resp.text().catch(() => "");
+        throw new AixError(`agent task events ${resp.status}: ${text}`);
+      }
+      const payload = await resp.json();
+      const events = Array.isArray(payload) ? payload : payload.events;
+      for (const frame of events) await processFrame(frame);
+      const nextCursor = Array.isArray(payload) ? void 0 : payload.next_cursor;
+      if (nextCursor !== void 0) cursor = Math.max(cursor, nextCursor);
+    };
+    processFrame = async (frame) => {
+      const frameCursor = frame.cursor;
+      if (frameCursor !== void 0) {
+        if (appliedCursors.has(frameCursor) || frameCursor <= cursor) return;
+        if (frameCursor > cursor + 1) {
+          await fetchCatchup(cursor);
+          return processFrame(frame);
+        }
+        appliedCursors.add(frameCursor);
+        cursor = frameCursor;
+      }
+      applyFrame(frame);
+    };
+    const socket = new ReconnectingSocket({
+      // Every reconnect mints a fresh one-time ticket; cursor remains in the URL
+      // but the caller's bearer token never does.
+      urlProvider: async () => executionWsTicketUrl(resolved, runId, cursor),
+      wsFactory: resolved.wsFactory,
+      onMessage: (text) => {
+        let frame;
+        try {
+          frame = JSON.parse(text);
+        } catch {
+          return;
+        }
+        processing = processing.then(() => processFrame(frame)).catch((error) => emit({
+          runId,
+          stream: "status",
+          status: "failed",
+          error: `Task event catch-up failed: ${String(error)}`
+        }));
+      }
+    });
+    await socket.start();
+  };
+  return {
+    available: true,
+    async start(request) {
+      const url = joinUrl(resolved.baseUrl, basePath);
+      const payload = {
+        agent: request.agent,
+        prompt: request.prompt,
+        device_ids: request.deviceIds,
+        max_concurrency: request.concurrency,
+        policy_id: policyId
+      };
+      const headers = { ...await resolved.auth.headers("caller"), "content-type": "application/json" };
+      const resp = await resolved.fetchFn(url, { method: "POST", headers, body: JSON.stringify(payload) });
+      if (!resp.ok) {
+        const text = await resp.text().catch(() => "");
+        if (resp.status === 401 || resp.status === 403) throw new AixAuthError(`agent tasks ${resp.status}: ${text}`);
+        throw new AixError(`agent tasks ${resp.status}: ${text}`);
+      }
+      const started = await resp.json();
+      if (!started.task_id || !Array.isArray(started.targets) || started.targets.some((target) => !target.target_id)) {
+        throw new AixError("agent task response is missing stable target ids");
+      }
+      await attach(started.task_id, started.targets);
+      return { runId: started.task_id, targets: started.targets };
+    },
+    async resume(runId, devices) {
+      const url = joinUrl(resolved.baseUrl, `${basePath}/${encodeURIComponent(runId)}`);
+      const headers = await resolved.auth.headers("caller");
+      const resp = await resolved.fetchFn(url, { headers });
+      if (!resp.ok) {
+        const text = await resp.text().catch(() => "");
+        if (resp.status === 401 || resp.status === 403) throw new AixAuthError(`agent tasks ${resp.status}: ${text}`);
+        throw new AixError(`agent tasks ${resp.status}: ${text}`);
+      }
+      const snapshot = await resp.json();
+      if (snapshot.task_id !== runId || !Array.isArray(snapshot.targets)) {
+        throw new AixError("agent task snapshot is missing stable target ids");
+      }
+      const deviceById = new Map(devices.map((device) => [device.id, device]));
+      const targets = snapshot.targets.map((target) => {
+        const attempt = target.current_attempt;
+        const evidence = normalizeEvidence(target.evidence ?? attempt?.result?.evidence);
+        return {
+          target_id: target.target_id,
+          device_id: target.device_id,
+          status: statusOf(target.status),
+          attempt_id: attempt?.attempt_id ?? null,
+          error: target.error ?? attempt?.error ?? null,
+          blocker: normalizeBlocker(target.blocker),
+          evidence
+        };
+      });
+      await attach(runId, targets);
+      return {
+        runId,
+        targets: targets.filter((target) => deviceById.has(target.device_id)),
+        agent: snapshot.agent === "claude" || snapshot.agent === "codex" ? snapshot.agent : void 0,
+        concurrency: snapshot.max_concurrency
+      };
+    },
+    async stop(runId) {
+      await post(`${basePath}/${encodeURIComponent(runId)}/cancel`);
+    },
+    async stopDevice(runId, targetId) {
+      await post(targetPath(runId, targetId, "cancel"));
+    },
+    async retryDevice(runId, targetId) {
+      await post(targetPath(runId, targetId, "retry"));
+    },
+    async approveDevice(runId, targetId) {
+      await post(targetPath(runId, targetId, "approve"));
+    },
+    subscribe(on) {
+      subscribers.add(on);
+      return () => subscribers.delete(on);
+    }
+  };
+}
+var TERMINAL2 = /* @__PURE__ */ new Set(["succeeded", "failed", "cancelled", "expired"]);
+function useTaskStatus(taskId, pollMs = 0) {
+  const c = useClient();
+  const [data, setData] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const mounted = useRef(true);
+  const timer = useRef(null);
+  const stop = useCallback(() => {
+    if (timer.current) {
+      clearInterval(timer.current);
+      timer.current = null;
+    }
+  }, []);
+  const fetchOnce = useCallback(async () => {
+    if (!taskId) return;
+    if (mounted.current) {
+      setLoading(true);
+      setError(null);
+    }
+    try {
+      const r = await c.tasks.get(taskId);
+      if (mounted.current) {
+        setData(r);
+        setLoading(false);
+      }
+      if (TERMINAL2.has(r.status)) stop();
+    } catch (e) {
+      if (mounted.current) {
+        setError(e instanceof Error ? e : new Error(String(e)));
+        setLoading(false);
+      }
+    }
+  }, [c, taskId, stop]);
+  const done = data ? TERMINAL2.has(data.status) : false;
+  useEffect(() => {
+    mounted.current = true;
+    setData(null);
+    if (!taskId) return () => {
+      mounted.current = false;
+    };
+    void fetchOnce();
+    if (pollMs > 0) timer.current = setInterval(() => {
+      void fetchOnce();
+    }, pollMs);
+    return () => {
+      mounted.current = false;
+      stop();
+    };
+  }, [taskId, pollMs, fetchOnce]);
+  return { data, loading, error, done, refetch: fetchOnce };
+}
+function useTasks(filter) {
+  const c = useClient();
+  const key = JSON.stringify(filter ?? {});
+  const q = useQuery(() => c.tasks.list(filter).then((r) => r.tasks), [c, key]);
+  const { refetch } = q;
+  const cancel = useCallback(async (id) => {
+    await c.tasks.cancel(id);
+    await refetch();
+  }, [c, refetch]);
+  return { ...q, cancel };
+}
+function useAutomationQueue(filter) {
+  const c = useClient();
+  const tasks = useTasks(filter);
+  const { refetch } = tasks;
+  const submit = useCallback(
+    async (config) => {
+      const ids = await submitBatch(c.cfg, config);
+      await refetch();
+      return ids;
+    },
+    [c, refetch]
+  );
+  const pause = useCallback(
+    async (id) => {
+      await c.tasks.pause(id);
+      await refetch();
+    },
+    [c, refetch]
+  );
+  const resume = useCallback(
+    async (id) => {
+      await c.tasks.resume(id);
+      await refetch();
+    },
+    [c, refetch]
+  );
+  return { ...tasks, submitBatch: submit, pause, resume };
+}
+function useInspector(deviceId) {
+  const c = useClient();
+  const [screenshot, setScreenshot] = useState(null);
+  const [tree, setTree] = useState(null);
+  const [selected, setSelected] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const mounted = useRef(true);
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  const captureScreenshot = useCallback(async () => {
+    if (!deviceId) {
+      setError(new Error("no device selected"));
+      return;
+    }
+    try {
+      const { png_base64 } = await c.devices.screenshot(deviceId);
+      if (mounted.current) setScreenshot(`data:image/png;base64,${png_base64}`);
+    } catch (e) {
+      if (mounted.current) setError(e instanceof Error ? e : new Error(String(e)));
+    }
+  }, [c, deviceId]);
+  const captureTree = useCallback(async () => {
+    if (!deviceId) {
+      setError(new Error("no device selected"));
+      return;
+    }
+    try {
+      const t = await c.devices.captureUiTree(deviceId);
+      if (mounted.current) setTree(t);
+    } catch (e) {
+      if (mounted.current) setError(e instanceof Error ? e : new Error(String(e)));
+    }
+  }, [c, deviceId]);
+  const refresh = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    await Promise.all([captureScreenshot(), captureTree()]);
+    if (mounted.current) setLoading(false);
+  }, [captureScreenshot, captureTree]);
+  const select = useCallback((el) => setSelected(el), []);
+  return { screenshot, tree, selected, loading, error, captureScreenshot, captureTree, refresh, select };
+}
+var InspectorContext = createContext(null);
+function InspectorProvider({ children }) {
+  const client = useClient();
+  const { selectedDeviceId } = useDevicesView();
+  const [screenshot, setScreenshot] = useState(null);
+  const [tree, setTree] = useState(null);
+  const [selectedElement, setSelectedElement] = useState(null);
+  const [loading, setLoading] = useState(false);
+  const [error, setError] = useState(null);
+  const [verifyLocator, setVerifyLocator] = useState(null);
+  const [matches, setMatches] = useState([]);
+  const [verifying, setVerifying] = useState(false);
+  const [recording, setRecording] = useState(false);
+  const [recordedLines, setRecordedLines] = useState([]);
+  const deviceIdRef = useRef(selectedDeviceId);
+  deviceIdRef.current = selectedDeviceId;
+  const deviceOp = useCallback(
+    async (op) => {
+      const id = deviceIdRef.current;
+      if (!id) throw new Error("No device selected");
+      return client.devices.op(id, op);
+    },
+    [client]
+  );
+  const captureScreenshot = useCallback(async () => {
+    const id = deviceIdRef.current;
+    if (!id) {
+      setError("No device selected");
+      return;
+    }
+    try {
+      const { png_base64 } = await client.devices.screenshot(id);
+      setScreenshot(`data:image/png;base64,${png_base64}`);
+    } catch (err) {
+      setError(String(err));
+    }
+  }, [client]);
+  const captureTree = useCallback(async () => {
+    const id = deviceIdRef.current;
+    if (!id) {
+      setError("No device selected");
+      return;
+    }
+    try {
+      const t = await client.devices.captureUiTree(id);
+      setTree(t);
+    } catch (err) {
+      setError(String(err));
+    }
+  }, [client]);
+  const verifyRef = useRef(async () => {
+  });
+  const refresh = useCallback(async () => {
+    setLoading(true);
+    setError(null);
+    await Promise.all([captureScreenshot(), captureTree()]);
+    setLoading(false);
+    setMatches([]);
+    setVerifyLocator((v) => {
+      if (v) void verifyRef.current(v.strategy, v.value);
+      return v;
+    });
+  }, [captureScreenshot, captureTree]);
+  const selectElement = useCallback((el) => setSelectedElement(el), []);
+  const reset = useCallback(() => {
+    setScreenshot(null);
+    setTree(null);
+    setSelectedElement(null);
+    setError(null);
+    setMatches([]);
+    setVerifyLocator(null);
+  }, []);
+  const tap = useCallback(
+    async (x, y) => {
+      try {
+        await deviceOp({ op: "tap", x, y });
+        await refresh();
+      } catch (err) {
+        setError(String(err));
+      }
+    },
+    [deviceOp, refresh]
+  );
+  const inputText = useCallback(
+    async (text) => {
+      try {
+        await deviceOp({ op: "input_text", text });
+        await refresh();
+      } catch (err) {
+        setError(String(err));
+      }
+    },
+    [deviceOp, refresh]
+  );
+  const pressKey = useCallback(
+    async (key) => {
+      try {
+        await deviceOp({ op: "press_key", key });
+        await refresh();
+      } catch (err) {
+        setError(String(err));
+      }
+    },
+    [deviceOp, refresh]
+  );
+  const swipe = useCallback(
+    async (x1, y1, x2, y2, duration = 0.3) => {
+      try {
+        await deviceOp({ op: "swipe", x1, y1, x2, y2, duration });
+        await refresh();
+      } catch (err) {
+        setError(String(err));
+      }
+    },
+    [deviceOp, refresh]
+  );
+  const longPress = useCallback(
+    async (x, y, durationSecs = 1) => {
+      try {
+        await deviceOp({ op: "swipe", x1: x, y1: y, x2: x, y2: y, duration: durationSecs });
+        await refresh();
+      } catch (err) {
+        setError(String(err));
+      }
+    },
+    [deviceOp, refresh]
+  );
+  const verify = useCallback(
+    async (strategy, value2) => {
+      if (!value2.trim()) {
+        setVerifyLocator(null);
+        setMatches([]);
+        return;
+      }
+      setVerifying(true);
+      setError(null);
+      setVerifyLocator({ strategy, value: value2 });
+      try {
+        const found = await deviceOp({
+          op: "find_elements",
+          locator: { strategy, value: value2 }
+        });
+        setMatches(found ?? []);
+        setVerifying(false);
+      } catch (err) {
+        setError(String(err));
+        setMatches([]);
+        setVerifying(false);
+      }
+    },
+    [deviceOp]
+  );
+  verifyRef.current = verify;
+  const clearMatches = useCallback(() => {
+    setMatches([]);
+    setVerifyLocator(null);
+  }, []);
+  const recordLine = useCallback(
+    (line) => setRecordedLines((prev) => recording ? [...prev, line] : prev),
+    [recording]
+  );
+  const removeLine = useCallback(
+    (index) => setRecordedLines((prev) => prev.filter((_, i) => i !== index)),
+    []
+  );
+  const clearRecording = useCallback(() => setRecordedLines([]), []);
+  const value = useMemo(
+    () => ({
+      screenshot,
+      tree,
+      selectedElement,
+      loading,
+      error,
+      verifyLocator,
+      matches,
+      verifying,
+      recording,
+      recordedLines,
+      captureScreenshot,
+      captureTree,
+      selectElement,
+      refresh,
+      reset,
+      tap,
+      inputText,
+      pressKey,
+      swipe,
+      longPress,
+      verify,
+      clearMatches,
+      setRecording,
+      recordLine,
+      removeLine,
+      clearRecording
+    }),
+    [
+      screenshot,
+      tree,
+      selectedElement,
+      loading,
+      error,
+      verifyLocator,
+      matches,
+      verifying,
+      recording,
+      recordedLines,
+      captureScreenshot,
+      captureTree,
+      selectElement,
+      refresh,
+      reset,
+      tap,
+      inputText,
+      pressKey,
+      swipe,
+      longPress,
+      verify,
+      clearMatches,
+      recordLine,
+      removeLine,
+      clearRecording
+    ]
+  );
+  return createElement(InspectorContext.Provider, { value }, children);
+}
+function useInspectorView() {
+  const ctx = useContext(InspectorContext);
+  if (!ctx) throw new Error("useInspectorView() must be used within <InspectorProvider>");
+  return ctx;
+}
+function useWebhooks() {
+  const c = useClient();
+  const q = useQuery(() => c.webhooks.list(), [c]);
+  const { setData } = q;
+  const create = useCallback(async (input) => {
+    await c.webhooks.create(input);
+    setData((prev) => [...prev ?? [], { id: input.id, url: input.url, events: input.events, enabled: input.enabled }]);
+  }, [c, setData]);
+  const setEnabled = useCallback(async (id, enabled) => {
+    const u = await c.webhooks.setEnabled(id, enabled);
+    setData((prev) => (prev ?? []).map((w) => w.id === id ? { ...w, ...u } : w));
+  }, [c, setData]);
+  const remove = useCallback(async (id) => {
+    await c.webhooks.remove(id);
+    setData((prev) => (prev ?? []).filter((w) => w.id !== id));
+  }, [c, setData]);
+  const trigger = useCallback(async (eventType, payload = { ping: true }) => {
+    await c.webhooks.trigger(eventType, payload);
+  }, [c]);
+  return { ...q, create, setEnabled, remove, trigger };
+}
+function useNodes() {
+  const c = useClient();
+  const q = useQuery(() => c.nodes.list(), [c]);
+  const { refetch } = q;
+  const register = useCallback(async (input) => {
+    const r = await c.nodes.register(input);
+    await refetch();
+    return r;
+  }, [c, refetch]);
+  return { ...q, register };
+}
+function useEnvGate(nodeId, opts) {
+  const cfg = useAixConfig();
+  const os = opts?.os !== void 0 ? opts.os : detectEnvOs();
+  const autoOpen = opts?.autoOpen ?? true;
+  const [needsSetup, setNeedsSetup] = useState(null);
+  const [ready, setReady] = useState(false);
+  const [probing, setProbing] = useState(false);
+  const [error, setError] = useState(null);
+  const [open, setOpen] = useState(false);
+  const [statusEvents, setStatusEvents] = useState([]);
+  const probedFor = useRef(null);
+  const mounted = useRef(true);
+  useEffect(() => {
+    mounted.current = true;
+    return () => {
+      mounted.current = false;
+    };
+  }, []);
+  const probe = useCallback(async (attempt = 0) => {
+    if (!nodeId || os !== "win" && os !== "mac") {
+      if (mounted.current) {
+        setNeedsSetup(false);
+        setReady(true);
+      }
+      return;
+    }
+    setProbing(true);
+    setError(null);
+    try {
+      const run = await EnvRun.start(cfg, nodeId, "status", { os });
+      const events = [];
+      run.on("event", (e) => events.push(e));
+      run.on("done", () => {
+        if (!mounted.current) return;
+        const sum = summarizeEnv(events);
+        setStatusEvents(events);
+        setReady(sum.ready);
+        setNeedsSetup(!sum.ready);
+        setProbing(false);
+        if (!sum.ready && autoOpen) setOpen(true);
+      });
+    } catch (e) {
+      if (!mounted.current) return;
+      if (attempt < 5) {
+        setTimeout(() => {
+          if (mounted.current) void probe(attempt + 1);
+        }, 3e3);
+        return;
+      }
+      setError(e instanceof Error ? e : new Error(String(e)));
+      setProbing(false);
+    }
+  }, [cfg, nodeId, os, autoOpen]);
+  useEffect(() => {
+    if (!nodeId || probedFor.current === nodeId) return;
+    probedFor.current = nodeId;
+    void probe();
+  }, [nodeId, probe]);
+  const refresh = useCallback(() => {
+    probedFor.current = null;
+    void probe();
+  }, [probe]);
+  return { os, needsSetup, ready, probing, error, open, setOpen, statusEvents, refresh };
+}
+function useLocators() {
+  const c = useClient();
+  const q = useQuery(() => c.locators.list(), [c]);
+  const { setData } = q;
+  const create = useCallback(async (input) => {
+    const l = await c.locators.create(input);
+    setData((prev) => [...prev ?? [], l]);
+    return l;
+  }, [c, setData]);
+  const remove = useCallback(async (id) => {
+    await c.locators.remove(id);
+    setData((prev) => (prev ?? []).filter((l) => l.id !== id));
+  }, [c, setData]);
+  return { ...q, create, remove };
+}
+function useImages() {
+  const c = useClient();
+  const q = useQuery(() => c.admin.listImages(), [c]);
+  const { setData, refetch } = q;
+  const upsert = useCallback(async (input) => {
+    const img = await c.admin.upsertImage(input);
+    await refetch();
+    return img;
+  }, [c, refetch]);
+  const setActive = useCallback(async (id, active) => {
+    const img = await c.admin.setImageActive(id, active);
+    setData((prev) => (prev ?? []).map((i) => i.id === id ? img : i));
+  }, [c, setData]);
+  const remove = useCallback(async (id) => {
+    await c.admin.deleteImage(id);
+    setData((prev) => (prev ?? []).filter((i) => i.id !== id));
+  }, [c, setData]);
+  return { ...q, upsert, setActive, remove };
+}
+function useLlm() {
+  const c = useClient();
+  return {
+    test: useCallback((opts) => c.llm.test(opts), [c])
+  };
+}
+function useAdmin() {
+  const c = useClient();
+  return useMemo(() => ({
+    listRates: () => c.admin.listRates(),
+    upsertRate: (b) => c.admin.upsertRate(b),
+    listPlans: () => c.admin.listPlans(),
+    createPlan: (b) => c.admin.createPlan(b),
+    usage: () => c.admin.usage(),
+    ledger: () => c.admin.ledger(),
+    setRebate: (id, ratio) => c.admin.setRebate(id, ratio),
+    setNodePlatform: (id, p) => c.admin.setNodePlatform(id, p)
+  }), [c]);
+}
+function useBilling() {
+  const c = useClient();
+  const q = useQuery(() => c.billing.balance(), [c]);
+  const { refetch } = q;
+  const topup = useCallback(async (input) => {
+    const r = await c.billing.topup(input);
+    await refetch();
+    return r;
+  }, [c, refetch]);
+  return { ...q, topup };
+}
+function useApiTokens() {
+  const c = useClient();
+  const q = useQuery(() => c.tokens.list(), [c]);
+  const { refetch } = q;
+  const create = useCallback(async (input) => {
+    const r = await c.tokens.create(input);
+    await refetch();
+    return r;
+  }, [c, refetch]);
+  const revoke = useCallback(async (id) => {
+    await c.tokens.revoke(id);
+    await refetch();
+  }, [c, refetch]);
+  const rotate = useCallback(async (id) => {
+    const r = await c.tokens.rotate(id);
+    await refetch();
+    return r;
+  }, [c, refetch]);
+  return { ...q, create, revoke, rotate };
+}
+
+export { DevicesProvider, GROUP_MIRROR_MAX, InspectorProvider, NodesProvider, ShortcutsProvider, createAgentTaskRunner, mapDevice, preflightTaskAgentDevice, useAdmin, useApiTokens, useAuth, useAutomationQueue, useBilling, useClusters, useCommands, useDeviceActions, useDevices, useDevicesView, useEnvGate, useFleetRun, useFlowRun, useGroupMirror, useImages, useInspector, useInspectorView, useLlm, useLocators, useMirror, useNodes, useNodesView, useProjects, useScriptRun, useScripts, useShortcutsView, useTaskAgentRun, useTaskStatus, useTasks, useWebhooks };