@aixnn/aixautots 0.0.0-stage → 0.5.2

package/dist/chunk-PUPVZRKZ.js

@@ -0,0 +1,668 @@
+import { joinUrl, AixAuthError, AixError, AixClient, resolveConfig, DevicesApi, RestClient, ReconnectingSocket } from './chunk-PCYERBNZ.js';
+
+// src/core/webrtc-rest.ts
+async function getIceServers(cfg) {
+  const url = joinUrl(cfg.baseUrl, "/api/ice");
+  const resp = await cfg.fetchFn(url, { headers: { ...await cfg.auth.headers("caller") } });
+  if (!resp.ok) {
+    if (resp.status === 401 || resp.status === 403) throw new AixAuthError(`ice ${resp.status}`);
+    throw new AixError(`ice ${resp.status}`);
+  }
+  const data = await resp.json();
+  return data.iceServers ?? [];
+}
+async function mintViewerToken(cfg, session) {
+  const url = joinUrl(cfg.baseUrl, "/api/signal/tokens");
+  const headers = { ...await cfg.auth.headers("caller"), "content-type": "application/json" };
+  const resp = await cfg.fetchFn(url, { method: "POST", headers, body: JSON.stringify({ session }) });
+  if (!resp.ok) {
+    if (resp.status === 401 || resp.status === 403) throw new AixAuthError(`signal token ${resp.status}`);
+    throw new AixError(`signal token ${resp.status}`);
+  }
+  return (await resp.json()).token;
+}
+
+// src/core/device-session.ts
+var CHUNK_SIZE = 64 * 1024;
+var BUFFER_HIGH = 4 * 1024 * 1024;
+var BUFFER_LOW = 1 * 1024 * 1024;
+var DC_CONNECT_TIMEOUT_MS = 15e3;
+function toCtx(source) {
+  if (source instanceof AixClient) {
+    return { cfg: source.cfg, devices: source.devices };
+  }
+  const cfg = "fetchFn" in source && typeof source.fetchFn === "function" ? source : resolveConfig(source);
+  return { cfg, devices: new DevicesApi(new RestClient(cfg)) };
+}
+function asBytes(data) {
+  return data instanceof Uint8Array ? data : new Uint8Array(data);
+}
+function asArrayBuffer(bytes) {
+  if (bytes.byteOffset === 0 && bytes.byteLength === bytes.buffer.byteLength) {
+    return bytes.buffer;
+  }
+  return bytes.slice().buffer;
+}
+async function sha256Hex(bytes) {
+  const subtle = globalThis.crypto?.subtle;
+  if (!subtle) throw new AixError("crypto.subtle unavailable: cannot hash file (need browser or Node 18+)");
+  const digest = await subtle.digest("SHA-256", asArrayBuffer(bytes));
+  return Array.from(new Uint8Array(digest)).map((b) => b.toString(16).padStart(2, "0")).join("");
+}
+var B64_CHARS = "ABCDEFGHIJKLMNOPQRSTUVWXYZabcdefghijklmnopqrstuvwxyz0123456789+/";
+function bytesToBase64(bytes) {
+  const B = globalThis.Buffer;
+  if (B) return B.from(bytes).toString("base64");
+  const c = (n) => B64_CHARS[n & 63];
+  let out = "";
+  let i = 0;
+  for (; i + 2 < bytes.length; i += 3) {
+    const n = bytes[i] << 16 | bytes[i + 1] << 8 | bytes[i + 2];
+    out += c(n >> 18) + c(n >> 12) + c(n >> 6) + c(n);
+  }
+  const rem = bytes.length - i;
+  if (rem === 1) {
+    const n = bytes[i] << 16;
+    out += c(n >> 18) + c(n >> 12) + "==";
+  } else if (rem === 2) {
+    const n = bytes[i] << 16 | bytes[i + 1] << 8;
+    out += c(n >> 18) + c(n >> 12) + c(n >> 6) + "=";
+  }
+  return out;
+}
+var B64_LOOKUP = (() => {
+  const t = new Int16Array(256).fill(-1);
+  for (let i = 0; i < B64_CHARS.length; i++) t[B64_CHARS.charCodeAt(i)] = i;
+  return t;
+})();
+function base64ToBytes(b64) {
+  const B = globalThis.Buffer;
+  if (B) return Uint8Array.from(B.from(b64, "base64"));
+  let len = b64.length;
+  while (len > 0 && b64[len - 1] === "=") len--;
+  const outLen = len * 3 >> 2;
+  const out = new Uint8Array(outLen);
+  let acc = 0;
+  let bits = 0;
+  let o = 0;
+  for (let i = 0; i < len; i++) {
+    const v = B64_LOOKUP[b64.charCodeAt(i)] ?? -1;
+    if (v < 0) continue;
+    acc = acc << 6 | v;
+    bits += 6;
+    if (bits >= 8) {
+      bits -= 8;
+      out[o++] = acc >> bits & 255;
+    }
+  }
+  return out;
+}
+function waitForDrain(dc) {
+  const cur = dc.bufferedAmount;
+  if (cur == null || cur <= BUFFER_LOW) return Promise.resolve();
+  if (!("onbufferedamountlow" in dc)) return Promise.resolve();
+  return new Promise((resolve) => {
+    dc.bufferedAmountLowThreshold = BUFFER_LOW;
+    dc.onbufferedamountlow = () => {
+      dc.onbufferedamountlow = null;
+      resolve();
+    };
+  });
+}
+async function openCtrlChannel(cfg, session, timeoutMs) {
+  const iceServers = await getIceServers(cfg);
+  const token = await mintViewerToken(cfg, session);
+  const pc = cfg.rtcFactory({ iceServers });
+  let selfPeer = null;
+  let remotePeer = null;
+  let ctrl = null;
+  let remoteDescriptionReady = false;
+  const pendingIce = [];
+  const signalUrl = joinUrl(cfg.baseUrl, "/ws/signal").replace(/^http/, "ws");
+  let socket;
+  const send = (msg) => {
+    try {
+      socket.send(JSON.stringify(msg));
+    } catch {
+    }
+  };
+  pc.onicecandidate = (ev) => {
+    if (ev.candidate && remotePeer) send({ type: "ice", session, to: remotePeer, candidate: ev.candidate });
+  };
+  pc.ondatachannel = (ev) => {
+    if (ev.channel.label === "ctrl" || !ctrl) {
+      ctrl = ev.channel;
+      ctrl.binaryType = "arraybuffer";
+    }
+  };
+  const onSignal = async (text) => {
+    let m;
+    try {
+      m = JSON.parse(text);
+    } catch {
+      return;
+    }
+    switch (m.type) {
+      case "welcome":
+        selfPeer = m.peer_id ?? null;
+        break;
+      case "peers": {
+        const node = (m.members ?? []).find((p) => p !== selfPeer);
+        if (node && !remotePeer) remotePeer = node;
+        break;
+      }
+      case "offer":
+        if (m.sdp && m.from) {
+          remotePeer = m.from;
+          await pc.setRemoteDescription({ type: "offer", sdp: m.sdp });
+          remoteDescriptionReady = true;
+          for (const candidate of pendingIce.splice(0)) await pc.addIceCandidate(candidate);
+          const answer = await pc.createAnswer();
+          await pc.setLocalDescription(answer);
+          send({ type: "answer", session, to: m.from, sdp: answer.sdp });
+        }
+        break;
+      case "ice":
+        if (m.candidate) {
+          if (!remoteDescriptionReady) pendingIce.push(m.candidate);
+          else await pc.addIceCandidate(m.candidate);
+        }
+        break;
+    }
+  };
+  socket = new ReconnectingSocket({
+    urlProvider: async () => signalUrl,
+    wsFactory: cfg.wsFactory,
+    onOpen: () => send({ type: "join", session, role: "viewer", token }),
+    onMessage: (t) => void onSignal(t)
+  });
+  const dispose = () => {
+    try {
+      socket.send(JSON.stringify({ type: "leave", session }));
+    } catch {
+    }
+    try {
+      ctrl?.close();
+    } catch {
+    }
+    try {
+      pc.close();
+    } catch {
+    }
+    socket.close();
+  };
+  await socket.start();
+  try {
+    const opened = await new Promise((resolve, reject) => {
+      let settled = false;
+      const finish = (dc, err) => {
+        if (settled) return;
+        settled = true;
+        clearTimeout(timer);
+        clearInterval(poll);
+        if (err) reject(err);
+        else resolve(dc);
+      };
+      const timer = setTimeout(() => finish(void 0, new Error("DataChannel \u5EFA\u94FE\u8D85\u65F6")), timeoutMs);
+      const poll = setInterval(() => {
+        if (!ctrl) return;
+        const dc = ctrl;
+        if (dc.readyState === "open") return finish(dc);
+        dc.onopen = () => finish(dc);
+      }, 30);
+      pc.onconnectionstatechange = () => {
+        if (pc.connectionState === "failed" || pc.connectionState === "closed") {
+          finish(void 0, new Error(`PeerConnection ${pc.connectionState}`));
+        }
+      };
+    });
+    return { dc: opened, dispose };
+  } catch (err) {
+    dispose();
+    throw err;
+  }
+}
+var DeviceSession = class _DeviceSession {
+  constructor(session, dc, dispose) {
+    this.session = session;
+    this.dc = dc;
+    this.dispose = dispose;
+    this.nextId = 1;
+    /** id → 该操作的响应路由回调(多路复用核心)。 */
+    this.pending = /* @__PURE__ */ new Map();
+    this.closed = false;
+    this.dc.onmessage = (ev) => {
+      if (typeof ev.data !== "string") return;
+      let m;
+      try {
+        m = JSON.parse(ev.data);
+      } catch {
+        return;
+      }
+      const h = this.pending.get(String(m.id));
+      if (h) h(m);
+    };
+  }
+  /**
+   * 打开一个设备会话:dcSession 握手 → answerer 建链 → 等 "ctrl" 通道 open。
+   * @param source   `AixClient` 或 `AixConfig | ResolvedConfig`
+   * @param deviceId 设备 id
+   * @param opts.dcTimeoutMs 建链超时(ms),默认 15000
+   */
+  static async open(source, deviceId, opts = {}) {
+    const ctx = toCtx(source);
+    const timeoutMs = opts.dcTimeoutMs ?? DC_CONNECT_TIMEOUT_MS;
+    const { session_id } = await ctx.devices.dcSession(deviceId);
+    const { dc, dispose } = await openCtrlChannel(ctx.cfg, session_id, timeoutMs);
+    return new _DeviceSession(session_id, dc, dispose);
+  }
+  allocId() {
+    return String(this.nextId++);
+  }
+  ensureOpen() {
+    if (this.closed) throw new AixError("DeviceSession already closed");
+    if (this.dc.readyState !== "open") throw new AixError(`DeviceSession DataChannel not open (${this.dc.readyState})`);
+  }
+  sendReq(req) {
+    this.dc.send(JSON.stringify(req));
+  }
+  // ---- 文件管理 ----------------------------------------------------------
+  /** 列目录:返回 entries。节点 `ls -la` 解析后回 `list_ok`。 */
+  listFiles(path) {
+    this.ensureOpen();
+    const id = this.allocId();
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, (m) => {
+        if (m.t === "list_ok") {
+          this.pending.delete(id);
+          resolve(m.entries);
+        } else if (m.t === "err") {
+          this.pending.delete(id);
+          reject(new AixError(m.message));
+        }
+      });
+      this.sendReq({ id, t: "list", path });
+    });
+  }
+  /** 删除文件/目录(recursive=true 走 `rm -rf`)。 */
+  deleteFile(path, recursive = false) {
+    return this.simpleOk((id) => ({ id, t: "delete", path, recursive }));
+  }
+  /** 新建目录(`mkdir -p`)。 */
+  mkdir(path) {
+    return this.simpleOk((id) => ({ id, t: "mkdir", path }));
+  }
+  /** 重命名/移动(`mv from to`)。 */
+  rename(from, to) {
+    return this.simpleOk((id) => ({ id, t: "rename", from, to }));
+  }
+  /** 共享:发一条请求(由 id 构造完整帧),等节点回 `ok` / `err`。 */
+  simpleOk(makeReq) {
+    this.ensureOpen();
+    const id = this.allocId();
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, (m) => {
+        if (m.t === "ok") {
+          this.pending.delete(id);
+          resolve();
+        } else if (m.t === "err") {
+          this.pending.delete(id);
+          reject(new AixError(m.message));
+        }
+      });
+      this.sendReq(makeReq(id));
+    });
+  }
+  // ---- 终端 --------------------------------------------------------------
+  /** 执行命令并收齐输出:返回 `{stdout, stderr, exitCode}`。 */
+  async exec(cmd) {
+    let stdout = "";
+    let stderr = "";
+    const code = await this.execStream(cmd, {
+      onStdout: (d) => {
+        stdout += d;
+      },
+      onStderr: (d) => {
+        stderr += d;
+      }
+    });
+    return { stdout, stderr, exitCode: code };
+  }
+  /** 流式执行命令:stdout/stderr 分块回调,resolve 退出码。 */
+  execStream(cmd, hooks = {}) {
+    this.ensureOpen();
+    const id = this.allocId();
+    return new Promise((resolve, reject) => {
+      this.pending.set(id, (m) => {
+        switch (m.t) {
+          case "stdout":
+            hooks.onStdout?.(m.data);
+            break;
+          case "stderr":
+            hooks.onStderr?.(m.data);
+            break;
+          case "exit":
+            this.pending.delete(id);
+            resolve(m.code);
+            break;
+          case "err":
+            this.pending.delete(id);
+            reject(new AixError(m.message));
+            break;
+        }
+      });
+      this.sendReq({ id, t: "exec", cmd });
+    });
+  }
+  // ---- 文件传输 ----------------------------------------------------------
+  /** 推字节到设备 `dest`:put → chunk... → eof,节点逐块回 `ack` 推进进度。 */
+  async pushFile(input, onProgress) {
+    this.ensureOpen();
+    const id = this.allocId();
+    const bytes = asBytes(input.data);
+    const total = bytes.length;
+    const sha256 = await sha256Hex(bytes);
+    let ackResolve = null;
+    let failed = null;
+    this.pending.set(id, (m) => {
+      if (m.t === "ack") {
+        onProgress?.({ loaded: Math.min(m.offset, total), total, channel: "dc" });
+        ackResolve?.();
+      } else if (m.t === "done" || m.t === "ok") {
+        this.pending.delete(id);
+        ackResolve?.();
+      } else if (m.t === "err") {
+        failed = new AixError(m.message);
+        this.pending.delete(id);
+        ackResolve?.();
+      }
+    });
+    try {
+      this.sendReq({ id, t: "put", name: input.filename, size: total, sha256, dest: input.dest });
+      for (let offset = 0; offset < total; offset += CHUNK_SIZE) {
+        if (failed) throw failed;
+        const slice = bytes.subarray(offset, Math.min(offset + CHUNK_SIZE, total));
+        this.sendReq({ id, t: "chunk", offset, bytes: bytesToBase64(slice) });
+        if ((this.dc.bufferedAmount ?? 0) > BUFFER_HIGH) await waitForDrain(this.dc);
+      }
+      this.sendReq({ id, t: "eof" });
+      await new Promise((resolve) => {
+        ackResolve = resolve;
+        setTimeout(resolve, 1e4);
+      });
+      if (failed) throw failed;
+      onProgress?.({ loaded: total, total, channel: "dc" });
+    } finally {
+      this.pending.delete(id);
+    }
+  }
+  /** 从设备 `src` 拉字节,收齐后返回 Uint8Array。节点流式回 chunk + done。 */
+  pullFile(src, onProgress) {
+    this.ensureOpen();
+    const id = this.allocId();
+    return new Promise((resolve, reject) => {
+      const chunks = [];
+      let total = 0;
+      let loaded = 0;
+      this.pending.set(id, (m) => {
+        switch (m.t) {
+          case "chunk": {
+            const b = base64ToBytes(m.bytes);
+            chunks.push(b);
+            loaded += b.length;
+            if (m.size && !total) total = m.size;
+            onProgress?.({ loaded, total: total || loaded, channel: "dc" });
+            break;
+          }
+          case "done": {
+            this.pending.delete(id);
+            const out = new Uint8Array(loaded);
+            let off = 0;
+            for (const c of chunks) {
+              out.set(c, off);
+              off += c.length;
+            }
+            onProgress?.({ loaded, total: m.size || total || loaded, channel: "dc" });
+            resolve(out);
+            break;
+          }
+          case "err":
+            this.pending.delete(id);
+            reject(new AixError(m.message));
+            break;
+        }
+      });
+      this.sendReq({ id, t: "get", src });
+    });
+  }
+  // ---- 通用流:openStream / shell / 端口转发 ------------------------------
+  /**
+   * 打开一条通用双工字节流(多路复用,沿用同一 DC)。
+   *   - `{kind:'tcp',host,port}`:节点 `TcpStream::connect(host:port)`,host 是
+   *     **节点可达**的地址(设备 adb-forward 出的端口、节点本机/局域网服务等)。
+   *   - `{kind:'exec',cmd}`:节点 spawn `adb shell <cmd>`(交互式:write→stdin,
+   *     stdout/stderr 合并→onData)。
+   * 返回的 `DcStream` 在收到节点 `opened` 后即可用;若节点回 `err` 则 reject。
+   */
+  openStream(target) {
+    this.ensureOpen();
+    const id = this.allocId();
+    return new Promise((resolve, reject) => {
+      let opened = false;
+      const dataCbs = [];
+      const closeCbs = [];
+      let streamClosed = false;
+      const finalize = () => {
+        if (streamClosed) return;
+        streamClosed = true;
+        this.pending.delete(id);
+        for (const cb of closeCbs) {
+          try {
+            cb();
+          } catch {
+          }
+        }
+      };
+      const stream = {
+        write: (bytes) => {
+          if (streamClosed) return;
+          this.sendReq({ id, t: "data", bytes: bytesToBase64(asBytes(bytes)) });
+        },
+        onData: (cb) => {
+          dataCbs.push(cb);
+        },
+        onClose: (cb) => {
+          if (streamClosed) {
+            try {
+              cb();
+            } catch {
+            }
+          } else {
+            closeCbs.push(cb);
+          }
+        },
+        close: () => {
+          if (streamClosed) return;
+          try {
+            this.sendReq({ id, t: "close" });
+          } catch {
+          }
+          finalize();
+        }
+      };
+      this.pending.set(id, (m) => {
+        switch (m.t) {
+          case "opened":
+            if (!opened) {
+              opened = true;
+              resolve(stream);
+            }
+            break;
+          case "data": {
+            const b = base64ToBytes(m.bytes);
+            for (const cb of dataCbs) {
+              try {
+                cb(b);
+              } catch {
+              }
+            }
+            break;
+          }
+          case "close":
+            finalize();
+            break;
+          case "err":
+            if (!opened) {
+              this.pending.delete(id);
+              reject(new AixError(m.message));
+            } else {
+              finalize();
+            }
+            break;
+        }
+      });
+      this.sendReq(
+        target.kind === "tcp" ? { id, t: "open", kind: "tcp", host: target.host, port: target.port } : { id, t: "open", kind: "exec", cmd: target.cmd }
+      );
+    });
+  }
+  /** 交互式终端:`= openStream({kind:'exec',cmd})`,cmd 默认 `sh`(交互式 shell)。 */
+  shell(cmd = "sh") {
+    return this.openStream({ kind: "exec", cmd });
+  }
+  /**
+   * 本地端口转发(**仅 Node 环境**):用 `node:net` 监听 `localPort`,每个进来的
+   * 连接都开一条 `openStream({kind:'tcp',host,port})` 并双向 pipe。返回停止函数
+   * (关闭监听 + 现有连接)。浏览器环境无 `node:net`,调用会抛"仅 node 可用"。
+   *
+   * 用动态 import('node:net') + try,避免把 node:net 打进浏览器 bundle
+   * (frontend 不会调用本方法)。
+   */
+  async forwardLocalPort(localPort, remote) {
+    this.ensureOpen();
+    let net;
+    try {
+      const mod = "node:net";
+      net = await import(
+        /* @vite-ignore */
+        /* webpackIgnore: true */
+        mod
+      );
+    } catch {
+      throw new AixError("forwardLocalPort \u4EC5 node \u53EF\u7528(\u5F53\u524D\u73AF\u5883\u65E0 node:net)");
+    }
+    const sockets = /* @__PURE__ */ new Set();
+    const server = net.createServer((socket) => {
+      sockets.add(socket);
+      void (async () => {
+        let stream;
+        try {
+          stream = await this.openStream({ kind: "tcp", host: remote.host, port: remote.port });
+        } catch {
+          socket.destroy();
+          sockets.delete(socket);
+          return;
+        }
+        stream.onData((b) => {
+          socket.write(b.slice());
+        });
+        stream.onClose(() => {
+          socket.end();
+        });
+        socket.on("data", (chunk) => {
+          stream.write(new Uint8Array(chunk.buffer, chunk.byteOffset, chunk.byteLength));
+        });
+        socket.on("close", () => {
+          stream.close();
+          sockets.delete(socket);
+        });
+        socket.on("error", () => {
+          stream.close();
+          sockets.delete(socket);
+        });
+      })();
+    });
+    await new Promise((resolve, reject) => {
+      server.once("error", reject);
+      server.listen(localPort, () => {
+        server.off?.("error", reject);
+        resolve();
+      });
+    });
+    return () => {
+      try {
+        server.close();
+      } catch {
+      }
+      for (const s of sockets) {
+        try {
+          s.destroy();
+        } catch {
+        }
+      }
+      sockets.clear();
+    };
+  }
+  /** 关闭会话:断开 DC + pc + 信令 socket,清空 pending。 */
+  close() {
+    if (this.closed) return;
+    this.closed = true;
+    this.pending.clear();
+    this.dispose();
+  }
+};
+async function pushViaR2(ctx, deviceId, input, onProgress) {
+  const bytes = asBytes(input.data);
+  const total = bytes.length;
+  onProgress?.({ loaded: 0, total, channel: "r2" });
+  const { key, upload_url } = await ctx.devices.filesUploadUrl(deviceId, input.filename);
+  const put = await ctx.cfg.fetchFn(upload_url, { method: "PUT", body: asArrayBuffer(bytes) });
+  if (!put.ok) throw new AixError(`R2 \u4E0A\u4F20\u5931\u8D25 ${put.status}`);
+  onProgress?.({ loaded: total, total, channel: "r2" });
+  await ctx.devices.filesPush(deviceId, key, input.dest);
+}
+async function pullViaR2(ctx, deviceId, src, onProgress) {
+  const filename = src.split("/").pop() || "download.bin";
+  onProgress?.({ loaded: 0, total: 0, channel: "r2" });
+  const { download_url } = await ctx.devices.filesPull(deviceId, src, filename);
+  const resp = await ctx.cfg.fetchFn(download_url);
+  if (!resp.ok) throw new AixError(`R2 \u4E0B\u8F7D\u5931\u8D25 ${resp.status}`);
+  const data = new Uint8Array(await resp.arrayBuffer());
+  onProgress?.({ loaded: data.length, total: data.length, channel: "r2" });
+  return { data, filename };
+}
+async function pushFile(source, deviceId, input, opts = {}) {
+  const ctx = toCtx(source);
+  try {
+    const s = await DeviceSession.open(ctx.cfg, deviceId, { dcTimeoutMs: opts.dcTimeoutMs });
+    try {
+      await s.pushFile(input, opts.onProgress);
+    } finally {
+      s.close();
+    }
+    return { channel: "dc", fellBack: false };
+  } catch (err) {
+    if (typeof console !== "undefined") console.warn("[device-session] push \u901A\u9053 A \u5931\u8D25,\u56DE\u9000 R2:", err);
+    await pushViaR2(ctx, deviceId, input, opts.onProgress);
+    return { channel: "r2", fellBack: true };
+  }
+}
+async function pullFile(source, deviceId, src, opts = {}) {
+  const ctx = toCtx(source);
+  const filename = src.split("/").pop() || "download.bin";
+  try {
+    const s = await DeviceSession.open(ctx.cfg, deviceId, { dcTimeoutMs: opts.dcTimeoutMs });
+    try {
+      const data = await s.pullFile(src, opts.onProgress);
+      return { channel: "dc", fellBack: false, data, filename };
+    } finally {
+      s.close();
+    }
+  } catch (err) {
+    if (typeof console !== "undefined") console.warn("[device-session] pull \u901A\u9053 A \u5931\u8D25,\u56DE\u9000 R2:", err);
+    const r = await pullViaR2(ctx, deviceId, src, opts.onProgress);
+    return { channel: "r2", fellBack: true, data: r.data, filename: r.filename };
+  }
+}
+
+export { DeviceSession, getIceServers, mintViewerToken, pullFile, pushFile };