@aixnn/aixautots 0.0.0-stage → 0.5.2

package/dist/chunk-H7MHGYF3.js

@@ -0,0 +1,341 @@
+import { getIceServers, mintViewerToken } from './chunk-PUPVZRKZ.js';
+import { FlowRun } from './chunk-GKEPMDXO.js';
+import { resolveConfig, ReconnectingSocket, joinUrl } from './chunk-PCYERBNZ.js';
+
+// src/core/automation-queue.ts
+async function submitBatch(cfg, config) {
+  const { script, flow, deviceIds, expiresIn } = config;
+  const mode = config.mode ?? "round-robin";
+  if (script && flow !== void 0) {
+    throw new Error("submitBatch: pass exactly one of script or flow");
+  }
+  if (!script && flow === void 0) {
+    throw new Error("submitBatch: script or flow required");
+  }
+  if (deviceIds.length === 0) {
+    throw new Error("submitBatch: deviceIds required");
+  }
+  const rows = config.rows.length > 0 ? config.rows : [{}];
+  const taskIds = [];
+  for (let i = 0; i < rows.length; i++) {
+    const row = rows[i];
+    const targetIds = mode === "broadcast" ? deviceIds : [deviceIds[i % deviceIds.length]];
+    const fr = await FlowRun.submit(cfg, {
+      scriptId: script?.id,
+      flow,
+      deviceIds: targetIds,
+      params: row,
+      // 全量模式下后端按 Broadcast 在每台设备各跑一遍;轮询模式单目标无需 mode。
+      mode: mode === "broadcast" ? "Broadcast" : void 0,
+      expiresIn
+    });
+    fr.close();
+    taskIds.push(fr.taskId);
+  }
+  return taskIds;
+}
+var AutomationQueue = class {
+  constructor(cfg) {
+    this.cfg = cfg;
+  }
+  /** 展开并提交一个批次,返回 task id 数组。见 [`submitBatch`]。 */
+  submit(config) {
+    return submitBatch(this.cfg, config);
+  }
+};
+
+// src/core/script-params.ts
+var SCHEMA_KEY = "__schema__";
+var VALID_TYPES = /* @__PURE__ */ new Set([
+  "text",
+  "textarea",
+  "number",
+  "select",
+  "boolean"
+]);
+function coerceParam(raw) {
+  if (!raw || typeof raw !== "object") return null;
+  const o = raw;
+  const key = typeof o.key === "string" ? o.key : "";
+  if (!key || key.startsWith("__")) return null;
+  const type = typeof o.type === "string" && VALID_TYPES.has(o.type) ? o.type : "text";
+  const p = { key, type };
+  if (typeof o.label === "string") p.label = o.label;
+  if (o.default != null) p.default = String(o.default);
+  if (Array.isArray(o.options)) p.options = o.options.map((x) => String(x));
+  if (o.randomable === true) p.randomable = true;
+  if (o.isTarget === true) p.isTarget = true;
+  return p;
+}
+function variablesToSchema(variables) {
+  const vars = variables ?? {};
+  const rawSchema = vars[SCHEMA_KEY];
+  if (Array.isArray(rawSchema)) {
+    const params = rawSchema.map(coerceParam).filter((p) => p !== null);
+    let seenTarget = false;
+    for (const p of params) {
+      if (p.isTarget) {
+        if (seenTarget) delete p.isTarget;
+        else seenTarget = true;
+      }
+    }
+    return params;
+  }
+  return Object.entries(vars).filter(([k]) => !k.startsWith("__")).map(([k, v]) => ({ key: k, type: "text", default: String(v) }));
+}
+function schemaToVariables(schema, base) {
+  const out = {};
+  for (const [k, v] of Object.entries(base ?? {})) {
+    if (k === SCHEMA_KEY) continue;
+    if (k.startsWith("__")) out[k] = v;
+  }
+  out[SCHEMA_KEY] = schema;
+  for (const p of schema) out[p.key] = p.default ?? "";
+  return out;
+}
+function targetParam(schema) {
+  return schema.find((p) => p.isTarget);
+}
+function schemaDefaults(schema) {
+  return Object.fromEntries(schema.map((p) => [p.key, p.default ?? ""]));
+}
+
+// src/core/mirror-session.ts
+var SCRCPY_PROFILES = {
+  balanced: { max_size: 1280, bitrate: 6e6, fps: 60 },
+  low_latency: { max_size: 1024, bitrate: 4e6, fps: 30 },
+  high_quality: { max_size: 0, bitrate: 8e6, fps: 60 }
+};
+function qualityMessage(profile) {
+  return { t: "quality", ...SCRCPY_PROFILES[profile] };
+}
+function signalWsUrl(baseUrl) {
+  return joinUrl(baseUrl, "/ws/signal").replace(/^http/, "ws");
+}
+var MirrorSession = class _MirrorSession {
+  constructor(cfg, session, socket, iceServers, token) {
+    this.cfg = cfg;
+    this.session = session;
+    this.socket = socket;
+    this.iceServers = iceServers;
+    this.token = token;
+    this.pc = null;
+    this.input = null;
+    this._stream = null;
+    this.peerId = null;
+    this.remotePeer = null;
+    this.remoteDescriptionReady = false;
+    this.pendingIce = [];
+    this.stateListeners = /* @__PURE__ */ new Set();
+    this.streamListeners = /* @__PURE__ */ new Set();
+  }
+  /** Start a viewer session. On WebSocket reconnect the socket re-joins
+   *  automatically; the node then sends a fresh offer, which is paired with a
+   *  fresh RTCPeerConnection (see the `offer` handler) — no consumer action
+   *  needed to restore the video track. */
+  static async join(cfg, session) {
+    const resolved = "fetchFn" in cfg ? cfg : resolveConfig(cfg);
+    const iceServers = await getIceServers(resolved);
+    const token = await mintViewerToken(resolved, session);
+    let ms;
+    const socket = new ReconnectingSocket({
+      urlProvider: async () => signalWsUrl(resolved.baseUrl),
+      wsFactory: resolved.wsFactory,
+      onOpen: () => ms.sendSignal({ type: "join", session, role: "viewer", token }),
+      onMessage: (text) => ms.onSignal(text)
+    });
+    ms = new _MirrorSession(resolved, session, socket, iceServers, token);
+    await socket.start();
+    return ms;
+  }
+  get stream() {
+    return this._stream;
+  }
+  onConnectionStateChange(cb) {
+    this.stateListeners.add(cb);
+    return () => this.stateListeners.delete(cb);
+  }
+  onStream(cb) {
+    this.streamListeners.add(cb);
+    return () => this.streamListeners.delete(cb);
+  }
+  sendInput(msg) {
+    if (this.input && this.input.readyState === "open") this.input.send(JSON.stringify(msg));
+  }
+  /** Ask the node to switch this device's encode profile (restarts its capture
+   *  pipeline; the video blanks briefly while it re-syncs on a keyframe). */
+  setQuality(profile) {
+    this.sendInput(qualityMessage(profile));
+  }
+  /** Current round-trip time (seconds) from the active ICE candidate pair, or
+   *  null when stats are unavailable (no pc yet / mock without getStats). Used
+   *  by the auto quality heuristic. */
+  async currentRtt() {
+    const pc = this.pc;
+    if (!pc?.getStats) return null;
+    try {
+      const report = await pc.getStats();
+      let rtt = null;
+      const visit = (s) => {
+        const stat = s;
+        if (stat?.type === "candidate-pair" && (stat.nominated || stat.state === "succeeded") && typeof stat.currentRoundTripTime === "number") rtt = stat.currentRoundTripTime;
+      };
+      const r = report;
+      if (typeof r?.forEach === "function") r.forEach(visit);
+      else if (Symbol.iterator in Object(report)) for (const s of report) visit(s);
+      return rtt;
+    } catch {
+      return null;
+    }
+  }
+  sendSignal(msg) {
+    try {
+      this.socket.send(JSON.stringify(msg));
+    } catch {
+    }
+  }
+  ensurePc() {
+    if (this.pc) return this.pc;
+    const pc = this.cfg.rtcFactory({ iceServers: this.iceServers });
+    pc.ontrack = (ev) => {
+      if (ev.receiver && "playoutDelayHint" in ev.receiver) ev.receiver.playoutDelayHint = 0;
+      if (ev.streams && ev.streams[0]) {
+        this._stream = ev.streams[0];
+        for (const cb of this.streamListeners) cb(this._stream);
+      }
+    };
+    pc.onicecandidate = (ev) => {
+      if (ev.candidate && this.remotePeer) this.sendSignal({ type: "ice", session: this.session, to: this.remotePeer, candidate: ev.candidate });
+    };
+    pc.ondatachannel = (ev) => {
+      if (ev.channel.label === "control") this.attachInput(ev.channel);
+    };
+    pc.onconnectionstatechange = () => {
+      for (const cb of this.stateListeners) cb(pc.connectionState);
+    };
+    this.pc = pc;
+    return pc;
+  }
+  attachInput(dc) {
+    this.input = dc;
+  }
+  /** Drop the current peer connection (keeps the last frame on screen until
+   *  the replacement track arrives). */
+  resetPeer() {
+    try {
+      this.input?.close();
+    } catch {
+    }
+    try {
+      this.pc?.close();
+    } catch {
+    }
+    this.input = null;
+    this.pc = null;
+    this.remoteDescriptionReady = false;
+    this.pendingIce = [];
+  }
+  async onSignal(text) {
+    let m;
+    try {
+      m = JSON.parse(text);
+    } catch {
+      return;
+    }
+    switch (m.type) {
+      case "welcome":
+        this.peerId = m.peer_id ?? null;
+        break;
+      case "peers":
+        break;
+      // node initiates the offer; viewer waits
+      case "offer":
+        if (m.sdp && m.from) {
+          if (this.pc) this.resetPeer();
+          this.remotePeer = m.from;
+          const pc = this.ensurePc();
+          await pc.setRemoteDescription({ type: "offer", sdp: m.sdp });
+          this.remoteDescriptionReady = true;
+          for (const candidate of this.pendingIce.splice(0)) await pc.addIceCandidate(candidate);
+          const answer = await pc.createAnswer();
+          await pc.setLocalDescription(answer);
+          this.sendSignal({ type: "answer", session: this.session, to: m.from, sdp: answer.sdp });
+        }
+        break;
+      case "ice":
+        if (m.candidate) {
+          if (!this.pc || !this.remoteDescriptionReady) this.pendingIce.push(m.candidate);
+          else await this.pc.addIceCandidate(m.candidate);
+        }
+        break;
+    }
+  }
+  leave() {
+    this.sendSignal({ type: "leave", session: this.session });
+    this.input?.close();
+    this.pc?.close();
+    this.pendingIce = [];
+    this.socket.close();
+  }
+};
+
+// src/core/resources/device-normalize.ts
+function metaStr(r, key) {
+  const v = r.meta?.[key];
+  return typeof v === "string" && v ? v : null;
+}
+function seenMs(r) {
+  return r.last_seen_at ? Date.parse(r.last_seen_at) || 0 : 0;
+}
+function toTransport(r) {
+  return {
+    external_id: r.external_id,
+    transport: metaStr(r, "transport"),
+    online: r.online === true,
+    node_id: r.node_id ?? null,
+    node_name: r.node_name ?? null,
+    last_seen_at: r.last_seen_at
+  };
+}
+function pickPrimary(group) {
+  const mostRecent = (rows) => rows.reduce((best, r) => seenMs(r) > seenMs(best) ? r : best);
+  const online = group.filter((r) => r.online === true);
+  if (!online.length) return mostRecent(group);
+  const provisioned = group.filter((r) => r.meta?.provisioned === true);
+  if (provisioned.length) return mostRecent(provisioned);
+  const usb = online.filter((r) => metaStr(r, "transport") === "usb");
+  return mostRecent(usb.length ? usb : online);
+}
+function normalizeDevices(rows) {
+  const serialnoSet = /* @__PURE__ */ new Set();
+  for (const r of rows) {
+    const sn = metaStr(r, "serialno");
+    if (sn) serialnoSet.add(sn);
+  }
+  const groups = /* @__PURE__ */ new Map();
+  for (const r of rows) {
+    const serialno = metaStr(r, "serialno");
+    let key;
+    if (serialno) {
+      key = `sn:${serialno}`;
+    } else if (serialnoSet.has(r.external_id)) {
+      key = `sn:${r.external_id}`;
+    } else {
+      key = `ext:${r.external_id}`;
+    }
+    const g = groups.get(key);
+    if (g) g.push(r);
+    else groups.set(key, [r]);
+  }
+  return [...groups.values()].map((group) => {
+    const primary = pickPrimary(group);
+    return {
+      ...primary,
+      online: group.some((r) => r.online === true),
+      device_id: primary.external_id,
+      transports: group.map(toTransport)
+    };
+  });
+}
+
+export { AutomationQueue, MirrorSession, SCHEMA_KEY, SCRCPY_PROFILES, normalizeDevices, qualityMessage, schemaDefaults, schemaToVariables, submitBatch, targetParam, variablesToSchema };