tesseract-agent 0.2.0 → 0.2.2

package/dist-bundle/cli.js

@@ -6031,6 +6031,20 @@ function resolveUniqueName(dir, name) {
 }
 var OUTSIDE = (verb) => ({ ok: false, error: `Refusing to ${verb} outside the shared root.` });
 var validName = (n) => !!n && !n.includes("/") && !n.includes("\\") && n !== "." && n !== "..";
+async function readRemoteBytes(root, path) {
+  if (!isInsideRoot(path, root))
+    return { error: "Path is outside the shared root." };
+  try {
+    const s = statSync(path);
+    if (!s.isFile())
+      return { error: "Not a file" };
+    if (s.size > REMOTE_READ_CAP)
+      return { error: `File is too large to read whole over the network (${(s.size / 1024 / 1024).toFixed(1)} MB) \u2014 open it locally.` };
+    return { bytes: await readFile(path), size: s.size };
+  } catch (err) {
+    return { error: String(err.message) };
+  }
+}
 async function runRemoteFsOp(root, op, args) {
   const a = args ?? [];
   switch (op) {
@@ -6295,12 +6309,202 @@ function unwatchAllRemote() {
   remoteWatches.clear();
 }
 
+// ../../packages/host-core/dist/fs-datachannel-host.js
+var ndcPromise = null;
+function loadNdc() {
+  if (!ndcPromise) {
+    ndcPromise = (async () => {
+      try {
+        const m = await import("node-datachannel");
+        return m.default ?? m;
+      } catch {
+        return null;
+      }
+    })();
+  }
+  return ndcPromise;
+}
+function toNdcIceServers(configs) {
+  const out = [];
+  for (const c of configs ?? []) {
+    const urls = Array.isArray(c.urls) ? c.urls : [c.urls];
+    for (const url of urls) {
+      const m = /^(stun|stuns|turn|turns):([^:?]+)(?::(\d+))?(?:\?transport=(udp|tcp))?/i.exec(url);
+      if (!m)
+        continue;
+      const scheme = m[1].toLowerCase();
+      const hostname3 = m[2];
+      const port = m[3] ? parseInt(m[3], 10) : scheme.endsWith("s") ? 5349 : 3478;
+      if (scheme.startsWith("stun")) {
+        out.push({ hostname: hostname3, port });
+        continue;
+      }
+      const transport = (m[4] ?? "udp").toLowerCase();
+      const relayType = scheme === "turns" ? "TurnTls" : transport === "tcp" ? "TurnTcp" : "TurnUdp";
+      out.push({ hostname: hostname3, port, username: c.username, password: c.credential, relayType });
+    }
+  }
+  return out;
+}
+var peers = /* @__PURE__ */ new Map();
+var delay = (ms) => new Promise((r) => setTimeout(r, ms));
+var CHUNK = 16 * 1024;
+var HIGH_WATER = 4 * 1024 * 1024;
+async function serveGet(dc, id, path, root) {
+  const res = await readRemoteBytes(root, path);
+  if (!dc.isOpen())
+    return;
+  if (res.error || !res.bytes) {
+    try {
+      dc.sendMessage(JSON.stringify({ t: "err", id, error: res.error ?? "read failed" }));
+    } catch {
+    }
+    return;
+  }
+  const bytes = res.bytes;
+  try {
+    dc.sendMessage(JSON.stringify({ t: "meta", id, size: bytes.length }));
+  } catch {
+    return;
+  }
+  for (let off = 0, seq = 0; off < bytes.length; off += CHUNK, seq++) {
+    let guard = 0;
+    while (dc.isOpen() && dc.bufferedAmount() > HIGH_WATER && guard++ < 2e3)
+      await delay(15);
+    if (!dc.isOpen())
+      return;
+    const end = Math.min(off + CHUNK, bytes.length);
+    const frame = Buffer.allocUnsafe(8 + (end - off));
+    frame.writeUInt32LE(id >>> 0, 0);
+    frame.writeUInt32LE(seq >>> 0, 4);
+    bytes.copy(frame, 8, off, end);
+    try {
+      dc.sendMessageBinary(frame);
+    } catch {
+      return;
+    }
+  }
+  if (dc.isOpen()) {
+    try {
+      dc.sendMessage(JSON.stringify({ t: "end", id }));
+    } catch {
+    }
+  }
+}
+function wireServer(dc, root) {
+  try {
+    dc.setBufferedAmountLowThreshold(HIGH_WATER / 4);
+  } catch {
+  }
+  dc.onMessage((msg) => {
+    if (typeof msg !== "string")
+      return;
+    let req;
+    try {
+      req = JSON.parse(msg);
+    } catch {
+      return;
+    }
+    if (req.t === "get" && typeof req.id === "number" && typeof req.path === "string")
+      void serveGet(dc, req.id, req.path, root);
+  });
+}
+async function handleDcSignal(clientId, msg, root, ownHostId2, emit) {
+  if (msg.type === "signal:dc-ice") {
+    const peer2 = peers.get(clientId);
+    if (peer2 && peer2.remoteSet) {
+      try {
+        peer2.pc.addRemoteCandidate(msg.candidate, msg.mid);
+      } catch {
+      }
+    } else if (peer2)
+      peer2.pendingIce.push({ candidate: msg.candidate, mid: msg.mid });
+    return;
+  }
+  if (msg.type !== "signal:dc-offer")
+    return;
+  const ndc = await loadNdc();
+  if (!ndc) {
+    emit({ type: "signal:dc-unavailable", hostId: ownHostId2 });
+    return;
+  }
+  releaseDcClient(clientId);
+  let pc;
+  try {
+    pc = new ndc.PeerConnection("fsdc", { iceServers: toNdcIceServers(msg.iceServers) });
+  } catch {
+    emit({ type: "signal:dc-unavailable", hostId: ownHostId2 });
+    return;
+  }
+  const peer = { pc, pendingIce: [], remoteSet: false };
+  peers.set(clientId, peer);
+  pc.onLocalDescription((sdp, type) => emit({ type: "signal:dc-answer", sdp, sdpType: type, hostId: ownHostId2 }));
+  pc.onLocalCandidate((candidate, mid) => emit({ type: "signal:dc-ice", candidate, mid, hostId: ownHostId2 }));
+  pc.onDataChannel((dc) => wireServer(dc, root));
+  try {
+    pc.setRemoteDescription(msg.sdp, "offer");
+    peer.remoteSet = true;
+    for (const c of peer.pendingIce) {
+      try {
+        pc.addRemoteCandidate(c.candidate, c.mid);
+      } catch {
+      }
+    }
+    peer.pendingIce = [];
+  } catch {
+    releaseDcClient(clientId);
+    emit({ type: "signal:dc-unavailable", hostId: ownHostId2 });
+  }
+}
+function releaseDcClient(clientId) {
+  const peer = peers.get(clientId);
+  if (!peer)
+    return;
+  peers.delete(clientId);
+  try {
+    peer.pc.close();
+  } catch {
+  }
+}
+
+// ../../packages/host-core/dist/host-metrics.js
+import os from "node:os";
+function primaryIpv4(ifaces = os.networkInterfaces()) {
+  for (const name of Object.keys(ifaces)) {
+    for (const ni of ifaces[name] ?? []) {
+      if (ni.family === "IPv4" && !ni.internal)
+        return ni.address;
+    }
+  }
+  return void 0;
+}
+function staticMetrics(version) {
+  const cpus = os.cpus();
+  return {
+    version: version || void 0,
+    arch: os.arch(),
+    cpuModel: cpus[0]?.model?.trim() || void 0,
+    cpuCount: cpus.length || void 0,
+    totalMem: os.totalmem() || void 0,
+    ip: primaryIpv4()
+  };
+}
+function dynamicMetrics() {
+  const la = os.loadavg();
+  return {
+    load: la[0] > 0 ? Number(la[0].toFixed(2)) : void 0,
+    // loadavg is [0,0,0] on Windows
+    freeMem: os.freemem() || void 0,
+    uptime: Math.round(os.uptime()) || void 0
+  };
+}
+
 // ../../packages/host-core/dist/fs-transfer.js
 import { readdir as readdir2, lstat, mkdir as mkdir3, chmod, rm as rm2, readlink, symlink, stat as stat2 } from "node:fs/promises";
 import { openSync as openSync2, readSync as readSync2, closeSync as closeSync2, existsSync as existsSync3, createWriteStream } from "node:fs";
 import { dirname as dirname4, join as join4, relative as relative2, sep as sep2 } from "node:path";
-var CHUNK = 1024 * 1024;
-var MAX_INFLIGHT = 8 * CHUNK;
+var CHUNK2 = 1024 * 1024;
+var MAX_INFLIGHT = 8 * CHUNK2;
 var IDLE_MS = 6e4;
 var HEAVY_DIRS = /* @__PURE__ */ new Set([".git", "node_modules", "dist", "build", ".next", ".turbo", "out", "target", ".cache", "coverage"]);
 var ALWAYS_SKIP = /* @__PURE__ */ new Set([".DS_Store"]);
@@ -6433,11 +6637,11 @@ async function startOutboundTransfer(msg, controllerClientId, ownHostId2, hostRo
       if (f.size === 0) {
         send2({ type: "fs:transferChunk", transferId, toHost, fileIx, rel: f.rel, mode: f.mode, kind: "file", offset: 0, base64: "", eof: true }, { hostId: toHost });
       } else {
-        for (let offset = 0; offset < f.size && !state.cancelled; offset += CHUNK) {
+        for (let offset = 0; offset < f.size && !state.cancelled; offset += CHUNK2) {
           await waitWindow();
           if (state.cancelled)
             break;
-          const len = Math.min(CHUNK, f.size - offset);
+          const len = Math.min(CHUNK2, f.size - offset);
           const buf = Buffer.alloc(len);
           const read = readSync2(fd, buf, 0, len, offset);
           send2({ type: "fs:transferChunk", transferId, toHost, fileIx, rel: f.rel, mode: f.mode, kind: "file", offset, base64: buf.subarray(0, read).toString("base64"), eof: offset + len >= f.size }, { hostId: toHost });
@@ -6681,6 +6885,7 @@ var SERVER_HOST_ID = "server";
 var cfg = null;
 var deviceId = "";
 var backendOrigin = "";
+var hostVersion;
 function getToken() {
   return cfg ? cfg.tokenSource.getToken() : null;
 }
@@ -6750,7 +6955,17 @@ function ownHostId() {
 function presentedHosts() {
   const out = serverHosts.slice();
   if (!out.some((h) => h.hostId.endsWith(`:${deviceId}`))) {
-    out.unshift({ hostId: "local", name: hostname(), kind: "electron", platform: process.platform, online: true, caps: ["agent", "fs"] });
+    out.unshift({
+      hostId: "local",
+      name: hostname(),
+      kind: "electron",
+      platform: process.platform,
+      online: true,
+      caps: ["agent", "fs"],
+      ...staticMetrics(hostVersion),
+      ...dynamicMetrics(),
+      lastSeen: Date.now()
+    });
   }
   return out;
 }
@@ -6896,6 +7111,7 @@ async function serveInboundFs(requestId, op, args, driverClientId) {
 }
 function releaseDriver(clientId) {
   unwatchRemoteClient(clientId);
+  releaseDcClient(clientId);
   for (const [sid, cid] of [...driverBySession]) {
     if (cid !== clientId)
       continue;
@@ -6973,9 +7189,9 @@ function stopHeartbeat() {
   }
 }
 function registerAsHost() {
-  send("host", { type: "host:register", name: hostname(), platform: process.platform, deviceId, caps: ["agent", "fs"] });
+  send("host", { type: "host:register", name: hostname(), platform: process.platform, deviceId, caps: ["agent", "fs"], ...staticMetrics(hostVersion) });
   if (!heartbeat)
-    heartbeat = setInterval(() => send("host", { type: "host:heartbeat" }), 2e4);
+    heartbeat = setInterval(() => send("host", { type: "host:heartbeat", ...dynamicMetrics() }), 2e4);
 }
 function cleanup() {
   stopHeartbeat();
@@ -7093,6 +7309,13 @@ function connect() {
       }
       return;
     }
+    if (channel === "signal") {
+      const p = env.payload;
+      if (inbound && clientId && typeof p?.type === "string" && p.type.startsWith("signal:dc-")) {
+        void handleDcSignal(clientId, p, HOST_ROOT, ownHostId(), (payload) => send("signal", payload, { clientId, browserId: "fsdc" }));
+      }
+      return;
+    }
   };
   socket.onclose = () => {
     cleanup();
@@ -7106,6 +7329,7 @@ function startControlLink(config, h) {
   cfg = config;
   deviceId = config.deviceId;
   backendOrigin = config.tokenSource.backendOrigin;
+  hostVersion = config.version;
   hooks = h;
   stopped = false;
   hooks.pushHosts(presentedHosts());
@@ -7519,7 +7743,7 @@ async function runDaemon(opts = {}) {
     log2("local listener failed to start", e.message);
   }
   writeStatus({ deviceId: c.deviceId, connected: false });
-  startControlLink({ deviceId: c.deviceId, power: createNodePowerController(), tokenSource }, hooks2);
+  startControlLink({ deviceId: c.deviceId, power: createNodePowerController(), tokenSource, version: VERSION }, hooks2);
   log2(`started \u2014 device ${c.deviceId}, user ${c.userId}, relay ${c.backendOrigin}, local :${localInfo?.localPort ?? "off"}, version ${VERSION}`);
   await refresh();
   timer = setInterval(() => {
@@ -8079,7 +8303,7 @@ async function logs(instanceId, follow) {
 }
 
 // src/cli.ts
-var CLI_VERSION = process.env.CCB_DAEMON_VERSION ?? "0.2.0";
+var CLI_VERSION = process.env.CCB_DAEMON_VERSION ?? "0.2.1";
 function parseFlags(argv) {
   const out = {};
   for (let i = 0; i < argv.length; i++) {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "tesseract-agent",
-  "version": "0.2.0",
+  "version": "0.2.2",
   "license": "UNLICENSED",
   "publishConfig": {
     "access": "public"
@@ -33,6 +33,9 @@
   "dependencies": {
     "@anthropic-ai/claude-agent-sdk": "0.2.112"
   },
+  "optionalDependencies": {
+    "node-datachannel": "^0.32.0"
+  },
   "devDependencies": {
     "@fineguide-tesseract/agent-core": "*",
     "@fineguide-tesseract/host-core": "*",