tesseract-agent 0.2.1 → 0.2.3

package/dist-bundle/cli.js

@@ -5840,9 +5840,10 @@ var require_main = __commonJS({
 });
 
 // src/cli.ts
+import { readFileSync as readFileSync4 } from "node:fs";
 import { fileURLToPath as fileURLToPath2 } from "node:url";
 import { homedir as homedir6 } from "node:os";
-import { join as join12 } from "node:path";
+import { dirname as dirname8, join as join12 } from "node:path";
 import { createInterface } from "node:readline/promises";
 
 // ../../packages/host-core/dist/control-link.js
@@ -6031,6 +6032,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,6 +6310,164 @@ 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()) {
@@ -6331,8 +6504,8 @@ function dynamicMetrics() {
 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"]);
@@ -6465,11 +6638,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 });
@@ -6939,6 +7112,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;
@@ -7136,6 +7310,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();
@@ -8123,7 +8304,15 @@ async function logs(instanceId, follow) {
 }
 
 // src/cli.ts
-var CLI_VERSION = process.env.CCB_DAEMON_VERSION ?? "0.2.1";
+function pkgVersion() {
+  try {
+    const p = join12(dirname8(fileURLToPath2(import.meta.url)), "..", "package.json");
+    return JSON.parse(readFileSync4(p, "utf8")).version ?? "0.0.0";
+  } catch {
+    return "0.0.0";
+  }
+}
+var CLI_VERSION = process.env.CCB_DAEMON_VERSION ?? pkgVersion();
 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.1",
+  "version": "0.2.3",
   "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": "*",