@aixnn/aixautots 0.0.0-stage → 0.5.2

package/dist/chunk-GKEPMDXO.js

@@ -0,0 +1,410 @@
+import { joinUrl, AixAuthError, AixLocked, AixError, resolveConfig, ReconnectingSocket, AixTimeout, parseIncoming, isRetFrame, errorFromRet, isFridaEventFrame, isScriptletEventFrame, isStatusFrame, executionWsTicketUrl, isExecutionFrame, executionStreamEventsAfter } from './chunk-PCYERBNZ.js';
+
+// src/core/ws-access.ts
+async function mintDeviceAccess(cfg, deviceId) {
+  const url = joinUrl(cfg.baseUrl, `/api/devices/${encodeURIComponent(deviceId)}/ws-access`);
+  const headers = { ...await cfg.auth.headers("caller"), "content-type": "application/json" };
+  const resp = await cfg.fetchFn(url, { method: "POST", headers });
+  if (!resp.ok) {
+    const body = await resp.text().catch(() => "");
+    if (resp.status === 401 || resp.status === 403) throw new AixAuthError(`ws-access ${resp.status}: ${body}`);
+    if (resp.status === 423) throw new AixLocked(`device locked: ${body}`);
+    throw new AixError(`ws-access ${resp.status}: ${body}`);
+  }
+  return await resp.json();
+}
+function wsUrlFromAccess(a, prefer = "direct") {
+  const base = prefer === "direct" && a.direct_ws ? a.direct_ws : a.relay_ws;
+  const sep = base.includes("?") ? "&" : "?";
+  return `${base}${sep}token=${encodeURIComponent(a.token)}`;
+}
+
+// src/core/device-channel.ts
+function bytesToB64(b) {
+  let bin = "";
+  for (let i = 0; i < b.length; i++) bin += String.fromCharCode(b[i]);
+  if (typeof btoa === "function") return btoa(bin);
+  return globalThis.Buffer?.from(b)?.toString("base64") ?? btoa(bin);
+}
+function b64ToBytes(s) {
+  const bin = typeof atob === "function" ? atob(s) : globalThis.Buffer?.from(s, "base64")?.toString("binary") ?? atob(s);
+  const out = new Uint8Array(bin.length);
+  for (let i = 0; i < bin.length; i++) out[i] = bin.charCodeAt(i);
+  return out;
+}
+function fallbackUuid() {
+  return "xxxxxxxx-xxxx-4xxx-yxxx-xxxxxxxxxxxx".replace(/[xy]/g, (c) => {
+    const r = Math.random() * 16 | 0;
+    const v = c === "x" ? r : r & 3 | 8;
+    return v.toString(16);
+  });
+}
+var DeviceTunnel = class {
+  constructor(streamId, sink) {
+    this.streamId = streamId;
+    this.sink = sink;
+    this.dataListeners = /* @__PURE__ */ new Set();
+  }
+  send(bytes) {
+    this.sink({ t: "data", stream: this.streamId, b64: bytesToB64(bytes) });
+  }
+  onData(cb) {
+    this.dataListeners.add(cb);
+    return () => this.dataListeners.delete(cb);
+  }
+  _deliver(b) {
+    for (const cb of this.dataListeners) cb(b);
+  }
+  close() {
+    this.sink({ t: "close", stream: this.streamId });
+  }
+};
+var DEFAULT_TIMEOUT_MS = 3e4;
+var DeviceChannel = class _DeviceChannel {
+  constructor(cfg, deviceId) {
+    this.cfg = cfg;
+    this.deviceId = deviceId;
+    this.pending = /* @__PURE__ */ new Map();
+    this.corr = 0;
+    this.channelClosed = false;
+    this.fridaListeners = /* @__PURE__ */ new Set();
+    this.scriptletListeners = /* @__PURE__ */ new Set();
+    this.statusListeners = /* @__PURE__ */ new Set();
+    this.tunnels = /* @__PURE__ */ new Map();
+  }
+  static async open(cfg, deviceId, opts) {
+    const resolved = "fetchFn" in cfg ? cfg : resolveConfig(cfg);
+    const prefer = opts?.prefer ?? "direct";
+    const ch = new _DeviceChannel(resolved, deviceId);
+    const socket = new ReconnectingSocket({
+      urlProvider: async () => {
+        const access = await mintDeviceAccess(resolved, deviceId);
+        return wsUrlFromAccess(access, prefer);
+      },
+      wsFactory: resolved.wsFactory,
+      onMessage: (text) => ch.onMessage(text)
+    });
+    ch.socketRef = socket;
+    await socket.start();
+    return ch;
+  }
+  nextId() {
+    return `c${++this.corr}`;
+  }
+  request(frame, timeoutMs = DEFAULT_TIMEOUT_MS) {
+    if (this.channelClosed) return Promise.reject(new AixError("channel is closed", "offline"));
+    const id = this.nextId();
+    const full = { ...frame, id };
+    return new Promise((resolve, reject) => {
+      const timer = setTimeout(() => {
+        this.pending.delete(id);
+        reject(new AixTimeout(`command ${full.t} timed out after ${timeoutMs}ms`));
+      }, timeoutMs);
+      this.pending.set(id, { resolve, reject, timer });
+      try {
+        this.socketRef.send(JSON.stringify(full));
+      } catch (e) {
+        clearTimeout(timer);
+        this.pending.delete(id);
+        reject(new AixError(String(e)));
+      }
+    });
+  }
+  on(event, cb) {
+    if (event === "frida_event") {
+      this.fridaListeners.add(cb);
+      return () => this.fridaListeners.delete(cb);
+    }
+    if (event === "scriptlet_event") {
+      this.scriptletListeners.add(cb);
+      return () => this.scriptletListeners.delete(cb);
+    }
+    this.statusListeners.add(cb);
+    return () => this.statusListeners.delete(cb);
+  }
+  fridaRun(script, target, spawn = false) {
+    return this.request({ t: "frida_run", script, target, spawn });
+  }
+  fridaCall(runId, method, args) {
+    return this.request({ t: "frida_call", run_id: runId, method, args });
+  }
+  fridaCancel(runId) {
+    return this.request({ t: "frida_cancel", run_id: runId });
+  }
+  scriptletRun(script, vars) {
+    return this.request({ t: "scriptlet_run", script, vars });
+  }
+  scriptletCall(runId, method, args) {
+    return this.request({ t: "scriptlet_call", run_id: runId, method, args });
+  }
+  scriptletCancel(runId) {
+    return this.request({ t: "scriptlet_cancel", run_id: runId });
+  }
+  onMessage(text) {
+    const frame = parseIncoming(text);
+    if (isRetFrame(frame) && typeof frame.id === "string") {
+      const p = this.pending.get(frame.id);
+      if (!p) return;
+      this.pending.delete(frame.id);
+      clearTimeout(p.timer);
+      if (frame.ok) p.resolve(frame.value);
+      else p.reject(errorFromRet(frame.error ?? "unknown error"));
+      return;
+    }
+    if (frame.t === "data") {
+      const raw = frame;
+      if (typeof raw.stream === "string") {
+        const b64 = typeof raw.b64 === "string" ? raw.b64 : "";
+        this.tunnels.get(raw.stream)?._deliver(b64ToBytes(b64));
+        return;
+      }
+    }
+    if (isFridaEventFrame(frame)) {
+      const { t: _t, ...payload } = frame;
+      for (const cb of this.fridaListeners) cb(payload);
+      return;
+    }
+    if (isScriptletEventFrame(frame)) {
+      const { t: _t, ...payload } = frame;
+      for (const cb of this.scriptletListeners) cb(payload);
+      return;
+    }
+    if (isStatusFrame(frame)) {
+      const { t: _t, ...payload } = frame;
+      for (const cb of this.statusListeners) cb(payload);
+      return;
+    }
+  }
+  openTunnel(kind, addr) {
+    if (this.channelClosed) throw new AixError("channel is closed", "offline");
+    if (!this.socketRef.isConnected()) throw new AixError("socket not connected", "offline");
+    const streamId = globalThis.crypto?.randomUUID?.() ?? fallbackUuid();
+    const send = (frame) => this.socketRef.send(JSON.stringify(frame));
+    const tun = new DeviceTunnel(streamId, send);
+    this.tunnels.set(streamId, tun);
+    send({ t: "open", stream: streamId, kind, addr });
+    return tun;
+  }
+  adbExec(argv, o) {
+    return this.request({ t: "adb_exec", argv, timeout_ms: o?.timeoutMs }, o?.timeoutMs ?? DEFAULT_TIMEOUT_MS);
+  }
+  wdaReq(method, path, body) {
+    return this.request({ t: "wda_req", method, path, body });
+  }
+  close() {
+    this.channelClosed = true;
+    for (const tun of this.tunnels.values()) {
+      try {
+        tun.close();
+      } catch {
+      }
+    }
+    this.tunnels.clear();
+    for (const [, p] of this.pending) {
+      clearTimeout(p.timer);
+      p.reject(new AixError("channel closed", "offline"));
+    }
+    this.pending.clear();
+    this.socketRef.close();
+  }
+};
+
+// src/core/flow-run.ts
+var FlowRun = class _FlowRun {
+  constructor(taskId, targets, socket) {
+    this.taskId = taskId;
+    this.targets = targets;
+    this.socket = socket;
+    this.eventListeners = /* @__PURE__ */ new Set();
+    this.doneListeners = /* @__PURE__ */ new Set();
+    this.finished = /* @__PURE__ */ new Set();
+    this.doneFired = false;
+    this.cursor = 0;
+  }
+  static async submit(cfg, body) {
+    const resolved = "fetchFn" in cfg ? cfg : resolveConfig(cfg);
+    const url = joinUrl(resolved.baseUrl, "/api/webhook/tasks");
+    const payload = { device_ids: body.deviceIds };
+    if (body.flow !== void 0) payload.flow = body.flow;
+    if (body.scriptId !== void 0) payload.script_id = body.scriptId;
+    if (body.params !== void 0) payload.params = body.params;
+    if (body.mode !== void 0) payload.mode = body.mode;
+    if (body.expiresIn !== void 0) payload.expires_in = body.expiresIn;
+    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 t = await resp.text().catch(() => "");
+      if (resp.status === 401 || resp.status === 403) throw new AixAuthError(`tasks ${resp.status}: ${t}`);
+      throw new AixError(`tasks ${resp.status}: ${t}`);
+    }
+    const data = await resp.json();
+    const targets = (data.targets ?? []).map((x) => x.device_id);
+    let fr = null;
+    let cursor = 0;
+    let processing = Promise.resolve();
+    let processFrame;
+    const fetchCatchup = async (after) => {
+      let nextAfter = after;
+      do {
+        const page = await executionStreamEventsAfter(resolved, data.task_id, nextAfter);
+        for (const event of page.events) await processFrame(event);
+        nextAfter = page.next_cursor ?? cursor;
+        if (!page.has_more) break;
+      } while (true);
+    };
+    processFrame = async (frame) => {
+      if (frame.run_id !== data.task_id) return;
+      if (typeof frame.cursor !== "number") {
+        fr?.onMessage(JSON.stringify({ run_id: frame.run_id, device_id: frame.device_id, event: frame.event }));
+        return;
+      }
+      if (frame.cursor <= cursor) return;
+      if (frame.cursor > cursor + 1) {
+        await fetchCatchup(cursor);
+        return processFrame(frame);
+      }
+      cursor = frame.cursor;
+      fr?.onMessage(JSON.stringify({ run_id: frame.run_id, device_id: frame.device_id, cursor: frame.cursor, event: frame.event }));
+    };
+    const socket = new ReconnectingSocket({
+      // urlProvider runs again after a close, minting a fresh one-time ticket
+      // and resuming after the latest durable event cursor.
+      urlProvider: async () => executionWsTicketUrl(resolved, data.task_id, cursor),
+      wsFactory: resolved.wsFactory,
+      onMessage: (text) => {
+        let frame;
+        try {
+          frame = JSON.parse(text);
+        } catch {
+          return;
+        }
+        if (typeof frame.cursor !== "number") {
+          fr?.onMessage(text);
+          return;
+        }
+        processing = processing.then(() => processFrame(frame)).catch(() => void 0);
+      }
+    });
+    fr = new _FlowRun(data.task_id, targets, socket);
+    await socket.start();
+    if (targets.length === 0) fr.fireDoneIfEmpty();
+    return fr;
+  }
+  on(event, cb) {
+    if (event === "event") {
+      this.eventListeners.add(cb);
+      return () => this.eventListeners.delete(cb);
+    }
+    const doneCb = cb;
+    this.doneListeners.add(doneCb);
+    if (this.doneFired) queueMicrotask(() => doneCb());
+    return () => this.doneListeners.delete(doneCb);
+  }
+  /** Called (via microtask) when submit() returns targets:[]. */
+  fireDoneIfEmpty() {
+    if (!this.doneFired && this.targets.length === 0) {
+      this.doneFired = true;
+      for (const cb of this.doneListeners) cb();
+    }
+  }
+  onMessage(text) {
+    let frame;
+    try {
+      frame = JSON.parse(text);
+    } catch {
+      return;
+    }
+    if (!isExecutionFrame(frame)) return;
+    const f = frame;
+    if (typeof f.cursor === "number") {
+      if (f.cursor <= this.cursor) return;
+      this.cursor = f.cursor;
+    }
+    for (const cb of this.eventListeners) cb({ deviceId: f.device_id, event: f.event });
+    if (f.event.kind === "finished") {
+      this.finished.add(f.device_id);
+      if (!this.doneFired && this.targets.length > 0 && this.finished.size >= this.targets.length) {
+        this.doneFired = true;
+        for (const cb of this.doneListeners) cb();
+      }
+    }
+  }
+  close() {
+    this.socket.close();
+  }
+};
+
+// src/core/script-debugger.ts
+var ScriptDebugger = class {
+  constructor(opts) {
+    this.opts = opts;
+    this.runId = null;
+    this.unsub = null;
+    this.flow = null;
+    this.listeners = /* @__PURE__ */ new Set();
+  }
+  get engine() {
+    return this.opts.engine;
+  }
+  get currentRunId() {
+    return this.runId;
+  }
+  on(_event, cb) {
+    this.listeners.add(cb);
+    return () => this.listeners.delete(cb);
+  }
+  async run(input) {
+    if (this.opts.engine === "flow") {
+      this.flow = await FlowRun.submit(this.opts.cfg, {
+        flow: input.flow,
+        scriptId: input.scriptId,
+        deviceIds: input.deviceIds ?? [],
+        params: input.params
+      });
+      this.runId = this.flow.taskId;
+      this.unsub = this.flow.on("event", (e) => {
+        for (const cb of this.listeners) cb({ runId: this.runId ?? this.flow.taskId, name: e.event.kind, data: { deviceId: e.deviceId, ...e.event } });
+      });
+      return { runId: this.flow.taskId };
+    }
+    const res = this.opts.engine === "frida" ? await this.opts.channel.fridaRun(input.script ?? "", input.target, input.spawn) : await this.opts.channel.scriptletRun(input.script ?? "", input.vars);
+    this.runId = res.run_id;
+    this.attachChannel();
+    return { runId: res.run_id };
+  }
+  async call(method, args) {
+    if (this.opts.engine === "flow") throw new AixError("flow engine has no call(); it runs a whole flow");
+    const id = this.runId;
+    if (!id) throw new AixError("no active run; call run() first");
+    return this.opts.engine === "frida" ? this.opts.channel.fridaCall(id, method, args) : this.opts.channel.scriptletCall(id, method, args);
+  }
+  async cancel() {
+    const id = this.runId;
+    this.detach();
+    this.runId = null;
+    if (this.opts.engine === "flow") {
+      this.flow?.close();
+      this.flow = null;
+      return;
+    }
+    if (!id) return;
+    if (this.opts.engine === "frida") await this.opts.channel.fridaCancel(id);
+    else await this.opts.channel.scriptletCancel(id);
+  }
+  attachChannel() {
+    if (this.opts.engine === "flow") return;
+    this.detach();
+    const handler = (e) => {
+      if (!this.runId || e.run_id !== this.runId) return;
+      for (const cb of this.listeners) cb({ runId: e.run_id, name: e.name, data: e.data });
+    };
+    if (this.opts.engine === "frida") this.unsub = this.opts.channel.on("frida_event", handler);
+    else this.unsub = this.opts.channel.on("scriptlet_event", handler);
+  }
+  detach() {
+    this.unsub?.();
+    this.unsub = null;
+  }
+};
+
+export { DeviceChannel, DeviceTunnel, FlowRun, ScriptDebugger, mintDeviceAccess, wsUrlFromAccess };