@agentproto/acp 0.4.0 → 0.5.0

package/dist/tunnel/index.mjs

@@ -1,8 +1,8 @@
+import { createCipheriv, randomUUID, createDecipheriv } from 'crypto';
 import { spawn } from 'child_process';
 import { platform, hostname } from 'os';
 import { EventEmitter } from 'events';
 import { Readable, Writable } from 'stream';
-import { randomUUID } from 'crypto';
 
 /**
  * @agentproto/acp v0.1.0-alpha
@@ -32,7 +32,9 @@ var KNOWN_TYPES = /* @__PURE__ */ new Set([
   "stdout",
   "stderr",
   "exit",
-  "reconnect_soon"
+  "reconnect_soon",
+  "e2e",
+  "e2e_handshake"
 ]);
 function parseFrame(raw) {
   let parsed;
@@ -58,6 +60,321 @@ function encodeData(bytes) {
 function decodeData(data) {
   return Buffer.from(data, "base64");
 }
+var E2eError = class extends Error {
+  code;
+  constructor(code, message) {
+    super(message);
+    this.name = "E2eError";
+    this.code = code;
+  }
+};
+var DEFAULT_E2E_MAX_FRAMES = 4294967296;
+var TAG_LEN = 16;
+var NONCE_LEN = 12;
+function nonceFor(n) {
+  const nonce = Buffer.alloc(NONCE_LEN);
+  nonce.writeBigUInt64BE(BigInt(n), NONCE_LEN - 8);
+  return nonce;
+}
+function aadFor(n) {
+  const aad = Buffer.alloc(8);
+  aad.writeBigUInt64BE(BigInt(n));
+  return aad;
+}
+function wrapE2E(inner, keys, opts = {}) {
+  const maxFrames = opts.maxFrames ?? DEFAULT_E2E_MAX_FRAMES;
+  const sendKey = Buffer.from(keys.sendKey);
+  const recvKey = Buffer.from(keys.recvKey);
+  const frameHandlers = /* @__PURE__ */ new Set();
+  const closeHandlers = /* @__PURE__ */ new Set();
+  let sentCount = 0;
+  let recvExpected = 0;
+  let recvCount = 0;
+  let open = inner.isOpen;
+  let failed = false;
+  const fail = (err) => {
+    if (failed) return;
+    failed = true;
+    opts.onSecurityError?.(err);
+    closeChannel(err.message);
+  };
+  const closeChannel = (reason) => {
+    if (!open) return;
+    open = false;
+    inner.close(reason);
+    for (const h of closeHandlers) h(reason);
+    frameHandlers.clear();
+    closeHandlers.clear();
+  };
+  const onInner = (frame) => {
+    if (!open) return;
+    if (frame.t !== "e2e") {
+      fail(
+        new E2eError(
+          "not_e2e",
+          `expected an e2e envelope, received a plaintext "${frame.t}" frame`
+        )
+      );
+      return;
+    }
+    const n = frame.n;
+    if (typeof n !== "number" || !Number.isInteger(n) || n < 0) {
+      fail(new E2eError("decode", "e2e envelope has an invalid counter"));
+      return;
+    }
+    if (n < recvExpected) {
+      fail(new E2eError("replay", `replayed frame: counter ${n} < expected ${recvExpected}`));
+      return;
+    }
+    if (n > recvExpected) {
+      fail(new E2eError("reorder", `out-of-order or dropped frame: counter ${n} > expected ${recvExpected}`));
+      return;
+    }
+    let buf;
+    try {
+      buf = Buffer.from(frame.d, "base64");
+    } catch {
+      fail(new E2eError("decode", "e2e envelope payload is not valid base64"));
+      return;
+    }
+    if (buf.length < TAG_LEN) {
+      fail(new E2eError("decode", "e2e envelope payload is too short to hold a tag"));
+      return;
+    }
+    const ct = buf.subarray(0, buf.length - TAG_LEN);
+    const tag = buf.subarray(buf.length - TAG_LEN);
+    let plaintext;
+    try {
+      const decipher = createDecipheriv("aes-256-gcm", recvKey, nonceFor(n));
+      decipher.setAAD(aadFor(n));
+      decipher.setAuthTag(tag);
+      plaintext = Buffer.concat([decipher.update(ct), decipher.final()]);
+    } catch {
+      fail(new E2eError("auth", `frame ${n} failed authentication \u2014 tampered ciphertext or wrong key`));
+      return;
+    }
+    recvExpected = n + 1;
+    recvCount += 1;
+    const decoded = parseFrame(plaintext.toString("utf8"));
+    if (!decoded) {
+      fail(new E2eError("decode", "decrypted payload was not a valid tunnel frame"));
+      return;
+    }
+    for (const h of frameHandlers) h(decoded);
+  };
+  const unsubInner = inner.onFrame(onInner);
+  const unsubClose = inner.onClose((reason) => {
+    if (!open) return;
+    open = false;
+    for (const h of closeHandlers) h(reason);
+    frameHandlers.clear();
+    closeHandlers.clear();
+  });
+  return {
+    get isOpen() {
+      return open;
+    },
+    get sentCount() {
+      return sentCount;
+    },
+    get recvCount() {
+      return recvCount;
+    },
+    send(frame) {
+      if (!open || failed) return;
+      if (sentCount >= maxFrames) {
+        fail(
+          new E2eError(
+            "overflow",
+            `send counter reached the rekey limit (${maxFrames}); a rekey is required`
+          )
+        );
+        return;
+      }
+      const n = sentCount;
+      const plaintext = Buffer.from(encodeFrame(frame), "utf8");
+      const cipher = createCipheriv("aes-256-gcm", sendKey, nonceFor(n));
+      cipher.setAAD(aadFor(n));
+      const ct = Buffer.concat([cipher.update(plaintext), cipher.final()]);
+      const tag = cipher.getAuthTag();
+      sentCount += 1;
+      inner.send({ t: "e2e", n, d: Buffer.concat([ct, tag]).toString("base64") });
+    },
+    close(reason) {
+      unsubInner();
+      unsubClose();
+      closeChannel(reason);
+    },
+    onFrame(handler) {
+      frameHandlers.add(handler);
+      return () => frameHandlers.delete(handler);
+    },
+    onClose(handler) {
+      closeHandlers.add(handler);
+      return () => closeHandlers.delete(handler);
+    }
+  };
+}
+var DEFAULT_HANDSHAKE_TIMEOUT_MS = 1e4;
+function b64(bytes) {
+  return Buffer.from(bytes).toString("base64");
+}
+function awaitHandshakeFrame(sink, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      unsubFrame();
+      unsubClose();
+      fn();
+    };
+    const timer = setTimeout(
+      () => finish(() => reject(new E2eError("decode", "handshake timed out"))),
+      timeoutMs
+    );
+    const unsubFrame = sink.onFrame((frame) => {
+      if (frame.t !== "e2e_handshake") {
+        finish(
+          () => reject(
+            new E2eError(
+              "not_e2e",
+              `expected an e2e_handshake frame, received "${frame.t}"`
+            )
+          )
+        );
+        return;
+      }
+      finish(() => resolve(Buffer.from(frame.d, "base64")));
+    });
+    const unsubClose = sink.onClose(
+      (reason) => finish(
+        () => reject(new E2eError("decode", `transport closed during handshake: ${reason ?? "unknown"}`))
+      )
+    );
+  });
+}
+async function clientHandshakeOverSink(sink, hello, deriveKeys, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT_MS;
+  const replyPromise = awaitHandshakeFrame(sink, timeoutMs);
+  sink.send({ t: "e2e_handshake", d: b64(hello) });
+  const reply = await replyPromise;
+  let keys;
+  try {
+    keys = deriveKeys(reply);
+  } catch (err) {
+    sink.close("handshake failed");
+    throw err;
+  }
+  return wrapE2E(sink, keys, opts.wrap);
+}
+async function daemonHandshakeOverSink(sink, respond, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_HANDSHAKE_TIMEOUT_MS;
+  const hello = await awaitHandshakeFrame(sink, timeoutMs);
+  let result;
+  try {
+    result = respond(hello);
+  } catch (err) {
+    sink.close("handshake failed");
+    throw err;
+  }
+  sink.send({ t: "e2e_handshake", d: b64(result.reply) });
+  return wrapE2E(sink, result.keys, opts.wrap);
+}
+
+// src/tunnel/tunnel-e2e.ts
+var DEFAULT_TUNNEL_E2E_TIMEOUT_MS = 8e3;
+function b642(bytes) {
+  return Buffer.from(bytes).toString("base64");
+}
+function awaitFirstFrame(sink, timeoutMs) {
+  return new Promise((resolve, reject) => {
+    let settled = false;
+    const finish = (fn) => {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      unsubFrame();
+      unsubClose();
+      fn();
+    };
+    const timer = setTimeout(() => finish(() => resolve(null)), timeoutMs);
+    const unsubFrame = sink.onFrame((frame) => finish(() => resolve(frame)));
+    const unsubClose = sink.onClose(
+      (reason) => finish(
+        () => reject(new E2eError("decode", `transport closed during e2e negotiation: ${reason ?? "unknown"}`))
+      )
+    );
+  });
+}
+async function connectSinkE2E(sink, offer, deriveKeys, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TUNNEL_E2E_TIMEOUT_MS;
+  const firstPromise = awaitFirstFrame(sink, timeoutMs);
+  sink.send({ t: "e2e_handshake", d: b642(offer) });
+  const first = await firstPromise;
+  if (first === null) {
+    return null;
+  }
+  if (first.t !== "e2e_handshake") {
+    sink.close("e2e negotiation: unexpected frame");
+    throw new E2eError(
+      "not_e2e",
+      `expected an e2e_handshake accept, received "${first.t}"`
+    );
+  }
+  let keys;
+  try {
+    keys = deriveKeys(Buffer.from(first.d, "base64"));
+  } catch (err) {
+    sink.close("e2e handshake failed");
+    throw err;
+  }
+  return wrapE2E(sink, keys, opts.wrap);
+}
+async function acceptSinkE2E(sink, respond, opts = {}) {
+  const timeoutMs = opts.timeoutMs ?? DEFAULT_TUNNEL_E2E_TIMEOUT_MS;
+  const first = await awaitFirstFrame(sink, timeoutMs);
+  if (first === null) {
+    return { e2e: false, sink };
+  }
+  if (first.t !== "e2e_handshake") {
+    return { e2e: false, sink: prependFrame(sink, first) };
+  }
+  let result;
+  try {
+    result = respond(Buffer.from(first.d, "base64"));
+  } catch (err) {
+    sink.close("e2e handshake failed");
+    throw err;
+  }
+  sink.send({ t: "e2e_handshake", d: b642(result.reply) });
+  return { e2e: true, sink: wrapE2E(sink, result.keys, opts.wrap) };
+}
+function prependFrame(inner, frame) {
+  let replayed = false;
+  return {
+    get isOpen() {
+      return inner.isOpen;
+    },
+    send(f) {
+      inner.send(f);
+    },
+    close(reason) {
+      inner.close(reason);
+    },
+    onFrame(handler) {
+      if (!replayed) {
+        replayed = true;
+        handler(frame);
+      }
+      return inner.onFrame(handler);
+    },
+    onClose(handler) {
+      return inner.onClose(handler);
+    }
+  };
+}
 var DEFAULT_WS_DIAL_TIMEOUT_MS = 1e4;
 var DEFAULT_HTTP_FORWARD_TIMEOUT_MS = 3e4;
 function createTunnelServer(opts) {
@@ -71,7 +388,8 @@ function createTunnelServer(opts) {
     capabilities: {
       pty: opts.pty === true,
       wsForward: opts.dialUpstreamWs !== void 0 && !!opts.httpUpstream,
-      ...opts.tools && opts.tools.length ? { tools: opts.tools } : {}
+      ...opts.tools && opts.tools.length ? { tools: opts.tools } : {},
+      ...opts.e2e === true ? { e2e: true } : {}
     },
     label: opts.label,
     daemon: {
@@ -549,6 +867,15 @@ function createTunnelServer(opts) {
       if (HOP_BY_HOP.has(k.toLowerCase())) continue;
       headers[k] = v;
     }
+    if (opts.httpInjectHeaders) {
+      for (const [k, v] of Object.entries(opts.httpInjectHeaders)) {
+        const lower = k.toLowerCase();
+        for (const existing of Object.keys(headers)) {
+          if (existing.toLowerCase() === lower) delete headers[existing];
+        }
+        headers[k] = v;
+      }
+    }
     const url = `${opts.httpUpstream.replace(/\/$/, "")}${req.path}`;
     const controller = new AbortController();
     const timeoutMs = req.timeoutMs ?? opts.httpForwardTimeoutMs ?? DEFAULT_HTTP_FORWARD_TIMEOUT_MS;
@@ -1363,6 +1690,6 @@ function wrapWebSocket(ws) {
   };
 }
 
-export { DEFAULT_HTTP_FORWARD_TIMEOUT_MS, DEFAULT_WS_DIAL_TIMEOUT_MS, TUNNEL_VERSION, createTunnelClient, createTunnelServer, decodeData, encodeData, encodeFrame, parseFrame, wrapWebSocket };
+export { DEFAULT_E2E_MAX_FRAMES, DEFAULT_HTTP_FORWARD_TIMEOUT_MS, DEFAULT_TUNNEL_E2E_TIMEOUT_MS, DEFAULT_WS_DIAL_TIMEOUT_MS, E2eError, TUNNEL_VERSION, acceptSinkE2E, clientHandshakeOverSink, connectSinkE2E, createTunnelClient, createTunnelServer, daemonHandshakeOverSink, decodeData, encodeData, encodeFrame, parseFrame, wrapE2E, wrapWebSocket };
 //# sourceMappingURL=index.mjs.map
 //# sourceMappingURL=index.mjs.map