@adapt-toolkit/a2adapt 0.11.3 → 0.11.5

package/.claude-plugin/plugin.json

@@ -3,7 +3,7 @@
   "name": "a2adapt",
   "displayName": "a2adapt",
   "description": "Secure agent-to-agent communication channel over ADAPT: self-sovereign pubkey identity, end-to-end encryption, plan-first execution.",
-  "version": "0.11.3",
+  "version": "0.11.5",
   "author": {
     "name": "Adapt Toolkit"
   },

package/dist/index.js

@@ -22429,7 +22429,7 @@ var StreamableHTTPServerTransport = class {
 // src/index.ts
 import { resolve as resolve2, join as join2, dirname as dirname2, isAbsolute } from "node:path";
 import { fileURLToPath } from "node:url";
-import { randomBytes, randomUUID } from "node:crypto";
+import { randomBytes, randomInt, randomUUID } from "node:crypto";
 import { createServer as createHttpServer } from "node:http";
 import * as fs2 from "node:fs";
 import { brotliCompressSync, brotliDecompressSync, constants as zlibConstants } from "node:zlib";
@@ -22512,7 +22512,7 @@ function writeIdentityFile(target, opts, overwrite = false) {
 }
 
 // src/index.ts
-var VERSION = true ? "0.11.3" : "0.0.0-dev";
+var VERSION = true ? "0.11.5" : "0.0.0-dev";
 var CONFIG = loadConfig();
 var STATE_DIR = CONFIG.stateDir;
 var BROKER_URL = CONFIG.brokerUrl;
@@ -22668,7 +22668,8 @@ function describeIdentity(id) {
     bio: v.Reduce("bio").Visualize(),
     roleId: v.Reduce("role_id").Visualize(),
     rootCid: v.Reduce("root_cid").Visualize(),
-    rootName: v.Reduce("root_name").Visualize()
+    rootName: v.Reduce("root_name").Visualize(),
+    monitoringEnabled: v.Reduce("monitoring_enabled").GetBoolean()
   };
 }
 async function delegateRole(root, role) {
@@ -22735,6 +22736,282 @@ async function sendViaLocalBook(id, contact, text) {
   });
   return `"${entry.name}" was not a contact yet \u2014 connected via the local contact book and sent the message with the introduction. If "${entry.name}" requires approval for local introductions, delivery completes once they approve.`;
 }
+function monitoringStatus(id) {
+  const v = readonlyTx(id, "::actor::get_monitoring_status");
+  return {
+    enabled: v.Reduce("monitoring_enabled").GetBoolean(),
+    proxyCid: v.Reduce("proxy_cid").Visualize(),
+    proxyPending: v.Reduce("proxy_pending").GetBoolean(),
+    copiesQueued: parseInt(v.Reduce("copies_queued").Visualize(), 10) || 0,
+    controlQueued: parseInt(v.Reduce("control_queued").Visualize(), 10) || 0
+  };
+}
+async function setAgentMonitoring(root, role, enabled) {
+  if (enabled) {
+    const rootAd = exportAdBlob(root);
+    await mutatingTx(role, "::actor::connect_sibling", {
+      name: root.name,
+      target_ad: role.pw.packet.NewBinaryFromBuffer(rootAd)
+    });
+  }
+  const roleAd = exportAdBlob(role);
+  const authData = await mutatingTx(root, "::actor::sign_monitoring_auth", {
+    role_ad: root.pw.packet.NewBinaryFromBuffer(roleAd),
+    enabled
+  });
+  const authBlob = Buffer.from(authData.Reduce("auth").GetBinary());
+  await mutatingTx(role, "::actor::set_monitoring", {
+    auth: role.pw.packet.NewBinaryFromBuffer(authBlob)
+  });
+  log(`[${role.name}] monitoring ${enabled ? "enabled" : "disabled"} (authorized by root "${root.name}")`);
+}
+async function sendControl(id, contactRef, payload) {
+  await mutatingTx(id, "::a2a_control::send_control", {
+    contact: contactRef,
+    payload: JSON.stringify(payload)
+  });
+}
+function renderCopies(v) {
+  const out = [];
+  if (v.IsNil()) return out;
+  for (let i = 0; ; i++) {
+    const m = v.Reduce(i);
+    if (m.IsNil()) break;
+    out.push({
+      source_cid: m.Reduce("source_cid").Visualize(),
+      source_name: m.Reduce("source_name").Visualize(),
+      direction: m.Reduce("direction").Visualize(),
+      peer_cid: m.Reduce("peer_cid").Visualize(),
+      peer_name: m.Reduce("peer_name").Visualize(),
+      date: m.Reduce("date").Visualize(),
+      body: m.Reduce("body").Visualize()
+    });
+  }
+  return out;
+}
+function renderControlRequests(v) {
+  const out = [];
+  if (v.IsNil()) return out;
+  for (let i = 0; ; i++) {
+    const m = v.Reduce(i);
+    if (m.IsNil()) break;
+    out.push({
+      senderCid: m.Reduce("sender_cid").Visualize(),
+      senderName: m.Reduce("sender_name").Visualize(),
+      payload: m.Reduce("payload").Visualize(),
+      date: m.Reduce("date").Visualize()
+    });
+  }
+  return out;
+}
+var forwardBusy = /* @__PURE__ */ new Set();
+async function forwardMonitoring(root) {
+  if (forwardBusy.has(root.name)) return;
+  forwardBusy.add(root.name);
+  try {
+    const st = monitoringStatus(root);
+    if (!st.proxyCid || st.copiesQueued === 0) return;
+    const data = await mutatingTx(root, "::actor::get_monitoring_copies", {});
+    const copies = renderCopies(data.Reduce("copies"));
+    if (copies.length === 0) return;
+    await sendControl(root, st.proxyCid, { v: 1, t: "monitoring", copies });
+  } catch (err) {
+    log(`[${root.name}] monitoring forward failed:`, String(err));
+  } finally {
+    forwardBusy.delete(root.name);
+  }
+}
+function listAgentsFor(root) {
+  const agents = [];
+  for (const id of identities.values()) {
+    if (id.name === root.name) continue;
+    const info = describeIdentity(id);
+    if (info.rootCid !== root.cid) continue;
+    agents.push({
+      name: id.name,
+      cid: id.cid,
+      role_id: info.roleId,
+      bio: info.bio,
+      monitoring: info.monitoringEnabled
+    });
+  }
+  return agents;
+}
+function findAgentOf(root, ref) {
+  const id = identities.get(ref) ?? [...identities.values()].find((i) => i.cid === ref);
+  if (!id || id.name === root.name) return null;
+  return describeIdentity(id).rootCid === root.cid ? id : null;
+}
+function deleteIdentityCompletely(id) {
+  try {
+    wrapper.remove_packet(id.cid);
+  } catch (err) {
+    log(`remove_packet(${id.cid}) failed:`, String(err));
+  }
+  identities.delete(id.name);
+  try {
+    unpublishFromBook(id.name);
+  } catch (err) {
+    log(`failed to unpublish "${id.name}" from the contact book:`, String(err));
+  }
+  const holder = bindingOwner.get(id.name);
+  if (holder) {
+    bindingOwner.delete(id.name);
+    sessionBinding.delete(holder);
+    persistBindings();
+  }
+  if (id.name === rootName) {
+    rootName = null;
+    clearRootMarker();
+  }
+  try {
+    fs2.rmSync(id.dir, { recursive: true, force: true });
+  } catch (err) {
+    return `deleting ${id.dir} failed: ${String(err)}`;
+  }
+  return null;
+}
+async function handleControlRequest(root, req) {
+  let msg;
+  try {
+    const parsed = JSON.parse(req.payload);
+    if (!parsed || typeof parsed !== "object") throw new Error("not an object");
+    msg = parsed;
+  } catch {
+    log(`[${root.name}] dropping unparseable control request from ${req.senderName}`);
+    return;
+  }
+  if (msg.v !== 1 || typeof msg.t !== "string") {
+    log(`[${root.name}] dropping control request with unknown envelope from ${req.senderName}`);
+    return;
+  }
+  const reply = async (data) => {
+    try {
+      await sendControl(root, req.senderCid, { v: 1, t: "res", id: msg.id ?? null, req: msg.t, ...data });
+    } catch (err) {
+      log(`[${root.name}] control reply to ${req.senderName} failed:`, String(err));
+    }
+  };
+  try {
+    if (msg.t === "bind") {
+      const data = await mutatingTx(root, "::actor::verify_proxy_code", {
+        code: String(msg.code ?? ""),
+        sender: req.senderCid
+      });
+      if (!data.Reduce("verified").GetBoolean()) {
+        const reason = data.Reduce("reason").Visualize();
+        log(`[${root.name}] proxy bind attempt from ${req.senderName} rejected (${reason})`);
+        await reply({ ok: false, error: reason });
+        return;
+      }
+      appendNotifyLog(root, { event: "monitoring_proxy_bound", from: req.senderName });
+      log(`[${root.name}] monitoring proxy bound: ${req.senderName} (${req.senderCid})`);
+      await reply({ ok: true, root: { name: root.name, cid: root.cid }, agents: listAgentsFor(root) });
+      await forwardMonitoring(root);
+      return;
+    }
+    const st = monitoringStatus(root);
+    if (!st.proxyCid || st.proxyCid !== req.senderCid) {
+      await reply({ ok: false, error: "not_authorized" });
+      return;
+    }
+    switch (msg.t) {
+      case "list_agents": {
+        await reply({ ok: true, root: { name: root.name, cid: root.cid }, agents: listAgentsFor(root) });
+        return;
+      }
+      case "create_agent": {
+        const name = String(msg.name ?? "").trim();
+        const bio = String(msg.bio ?? "");
+        const bad = validateName(name);
+        if (bad) {
+          await reply({ ok: false, error: bad });
+          return;
+        }
+        if (identities.has(name)) {
+          await reply({ ok: false, error: `an identity named "${name}" already exists` });
+          return;
+        }
+        const agent = await provisionIdentity(name);
+        if (bio) await mutatingTx(agent, "::a2a_messaging::set_my_bio", { bio });
+        await delegateRole(root, agent);
+        await reply({ ok: true, agents: listAgentsFor(root) });
+        return;
+      }
+      case "update_role": {
+        const agent = findAgentOf(root, String(msg.agent ?? ""));
+        if (!agent) {
+          await reply({ ok: false, error: "no such agent under this root" });
+          return;
+        }
+        await mutatingTx(agent, "::a2a_messaging::set_my_bio", { bio: String(msg.bio ?? "") });
+        await reply({ ok: true, agents: listAgentsFor(root) });
+        return;
+      }
+      case "set_monitoring": {
+        const agent = findAgentOf(root, String(msg.agent ?? ""));
+        if (!agent) {
+          await reply({ ok: false, error: "no such agent under this root" });
+          return;
+        }
+        await setAgentMonitoring(root, agent, Boolean(msg.enabled));
+        await reply({ ok: true, agents: listAgentsFor(root) });
+        return;
+      }
+      case "contact_agent": {
+        const agent = findAgentOf(root, String(msg.agent ?? ""));
+        if (!agent) {
+          await reply({ ok: false, error: "no such agent under this root" });
+          return;
+        }
+        const inv = await mutatingTx(agent, "::a2a_messaging::generate_invite", {});
+        const blob = packInvite(Buffer.from(inv.Reduce("invite").GetBinary()));
+        await reply({ ok: true, agent: agent.name, invite: blob });
+        return;
+      }
+      case "remove_agent": {
+        const agent = findAgentOf(root, String(msg.agent ?? ""));
+        if (!agent) {
+          await reply({ ok: false, error: "no such agent under this root" });
+          return;
+        }
+        const fail = deleteIdentityCompletely(agent);
+        if (fail) {
+          await reply({ ok: false, error: fail });
+          return;
+        }
+        await reply({ ok: true, agents: listAgentsFor(root) });
+        return;
+      }
+      default:
+        await reply({ ok: false, error: `unknown request type "${msg.t}"` });
+    }
+  } catch (err) {
+    await reply({ ok: false, error: String(err) });
+  }
+}
+var controlBusy = /* @__PURE__ */ new Set();
+async function processControlRequests(root) {
+  if (controlBusy.has(root.name)) return;
+  controlBusy.add(root.name);
+  try {
+    for (; ; ) {
+      const data = await mutatingTx(root, "::actor::get_control_requests", {});
+      const reqs = renderControlRequests(data.Reduce("requests"));
+      if (reqs.length === 0) return;
+      for (const req of reqs) {
+        await handleControlRequest(root, req);
+      }
+    }
+  } catch (err) {
+    log(`[${root.name}] control dispatch failed:`, String(err));
+  } finally {
+    controlBusy.delete(root.name);
+  }
+  if (identities.has(root.name) && monitoringStatus(root).controlQueued > 0) {
+    return processControlRequests(root);
+  }
+}
 async function ensureRegistrar() {
   fs2.mkdirSync(bookDir(), { recursive: true });
   let seed;
@@ -22897,6 +23174,12 @@ function wireHandlers(id) {
         process.nextTick(
           () => pushNotification(id.name, `[${id.name}] "${name}" queued a message awaiting introduction approval (${queued} queued).`)
         );
+      } else if (event === "control_request") {
+        const from = payload.Reduce("sender_name").Visualize();
+        log(`[${id.name}] control request queued by ${from}`);
+        process.nextTick(() => void processControlRequests(id));
+      } else if (event === "monitoring_copy") {
+        process.nextTick(() => void forwardMonitoring(id));
       }
       return;
     }
@@ -22962,7 +23245,7 @@ async function provisionIdentity(name, opts = { exposeLocal: true, localAutoAcce
   const seed = randomBytes(24).toString("hex");
   fs2.writeFileSync(seedPath(dir), seed, { mode: 384 });
   const id = await createPacket(name, seed, dir);
-  await mutatingTx(id, "::actor::set_my_name", { name });
+  await mutatingTx(id, "::a2a_messaging::set_my_name", { name });
   await pinRegistrar(id);
   if (!opts.localAutoAccept) {
     await mutatingTx(id, "::actor::set_local_policy", { auto_accept: false });
@@ -23034,6 +23317,16 @@ async function bootWrapper() {
     clearRootMarker();
   }
   if (rootName) log(`root identity: ${rootName}`);
+  const root = rootName ? identities.get(rootName) : void 0;
+  if (root) {
+    try {
+      const st = monitoringStatus(root);
+      if (st.controlQueued > 0) void processControlRequests(root);
+      else if (st.copiesQueued > 0) void forwardMonitoring(root);
+    } catch (err) {
+      log(`boot-time monitoring/control drain failed:`, String(err));
+    }
+  }
   persistBindings();
 }
 function resolveBound(sessionId) {
@@ -23174,7 +23467,7 @@ function createMcpServer(getSessionId) {
       if (identities.has(name)) return textResult(`create_identity failed: an identity named "${name}" already exists.`, true);
       try {
         const id = await provisionIdentity(name, { exposeLocal: expose_local, localAutoAccept: local_auto_accept });
-        if (bio) await mutatingTx(id, "::actor::set_my_bio", { bio });
+        if (bio) await mutatingTx(id, "::a2a_messaging::set_my_bio", { bio });
         let hierarchy = "";
         const root = rootName ? identities.get(rootName) : void 0;
         if (root) {
@@ -23216,7 +23509,7 @@ Ask the user: do you want to arm a message monitor for "${name}"? If yes, use: M
       }
       try {
         const id = await provisionIdentity(name, { exposeLocal: expose_local, localAutoAccept: local_auto_accept });
-        if (bio) await mutatingTx(id, "::actor::set_my_bio", { bio });
+        if (bio) await mutatingTx(id, "::a2a_messaging::set_my_bio", { bio });
         rootName = name;
         writeRootMarker(name);
         const adopted = [];
@@ -23391,31 +23684,9 @@ Bio: ${info.bio}` : "";
           );
         }
       }
-      try {
-        wrapper.remove_packet(id.cid);
-      } catch (err) {
-        log(`remove_packet(${id.cid}) failed:`, String(err));
-      }
-      identities.delete(name);
-      try {
-        unpublishFromBook(name);
-      } catch (err) {
-        log(`failed to unpublish "${name}" from the contact book:`, String(err));
-      }
-      const holder = bindingOwner.get(name);
-      if (holder) {
-        bindingOwner.delete(name);
-        sessionBinding.delete(holder);
-        persistBindings();
-      }
-      if (name === rootName) {
-        rootName = null;
-        clearRootMarker();
-      }
-      try {
-        fs2.rmSync(id.dir, { recursive: true, force: true });
-      } catch (err) {
-        return textResult(`Identity "${name}" removed from memory, but deleting ${id.dir} failed: ${String(err)}`, true);
+      const fail = deleteIdentityCompletely(id);
+      if (fail) {
+        return textResult(`Identity "${name}" removed from memory, but ${fail}`, true);
       }
       return textResult(`Removed identity "${name}" and its state.`);
     }
@@ -23444,7 +23715,7 @@ ${inbox.map((m) => fmtMsg(m)).join("\n")}`;
       try {
         const targ = {};
         if (name) targ.name = name;
-        const data = await mutatingTx(id, "::actor::generate_invite", targ);
+        const data = await mutatingTx(id, "::a2a_messaging::generate_invite", targ);
         const blob = packInvite(Buffer.from(data.Reduce("invite").GetBinary()));
         const heading = name ? `Invite for "${name}" created.` : "Invite created \u2014 the contact will be registered under the name the recipient announces when accepting.";
         return textResult(
@@ -23478,7 +23749,7 @@ ${blob}`
         const blobValue = id.pw.packet.NewBinaryFromBuffer(buf);
         const targ = { invite: blobValue };
         if (name) targ.name = name;
-        const data = await mutatingTx(id, "::actor::add_contact", targ);
+        const data = await mutatingTx(id, "::a2a_messaging::add_contact", targ);
         const added = data.Reduce("added").Visualize();
         const cid = data.Reduce("container_id").Visualize();
         const roleId = data.Reduce("role_id").Visualize();
@@ -23499,9 +23770,9 @@ ${blob}`
       const { id, err } = boundOr();
       if (err) return err;
       try {
-        const contacts = renderContacts(readonlyTx(id, "::actor::list_contacts"));
+        const contacts = renderContacts(readonlyTx(id, "::a2a_messaging::list_contacts"));
         const pending = renderPending(readonlyTx(id, "::actor::list_pending_introductions"));
-        const roots = renderContactRoots(readonlyTx(id, "::actor::list_contact_roots"));
+        const roots = renderContactRoots(readonlyTx(id, "::a2a_messaging::list_contact_roots"));
         const lines = [];
         lines.push(
           contacts.length === 0 ? "No contacts yet." : `Contacts (${contacts.length}):
@@ -23576,7 +23847,7 @@ ${lines.join("\n")}`);
       const { id, err } = boundOr();
       if (err) return err;
       try {
-        await mutatingTx(id, "::actor::set_my_bio", { bio });
+        await mutatingTx(id, "::a2a_messaging::set_my_bio", { bio });
         let refreshed = 0;
         if (id.name === rootName) {
           for (const other of identities.values()) {
@@ -23638,7 +23909,7 @@ ${lines.join("\n")}`);
       const { id, err } = boundOr();
       if (err) return err;
       try {
-        await mutatingTx(id, "::actor::send_message", { contact, text });
+        await mutatingTx(id, "::a2a_messaging::send_message", { contact, text });
         return textResult(`Message sent to "${contact}".`);
       } catch (e) {
         if (!/Unknown contact/.test(String(e))) {
@@ -23662,7 +23933,7 @@ ${lines.join("\n")}`);
       const { id, err } = boundOr();
       if (err) return err;
       try {
-        const data = await mutatingTx(id, "::actor::remove_contact", { contact });
+        const data = await mutatingTx(id, "::a2a_messaging::remove_contact", { contact });
         const name = data.Reduce("removed").Visualize();
         const cid = data.Reduce("container_id").Visualize();
         return textResult(`Removed contact "${name}" (${cid}).`);
@@ -23731,6 +24002,97 @@ These are now marked processed (auto-GC'd later). To hand any back to another se
       }
     }
   );
+  const rootOr = () => {
+    const root = rootName ? identities.get(rootName) : void 0;
+    if (!root) {
+      return { err: textResult("No root identity exists on this host \u2014 create one with create_root_identity first.", true) };
+    }
+    return { root };
+  };
+  server.tool(
+    "enable_monitoring",
+    "Enable monitoring on one of this host's agents (a role under the root identity): from now on the agent reports a copy of every message it sends or receives to the root, which forwards them to the bound browser proxy (see bind_monitoring_proxy). Authorized by a root-signed blob the role verifies against its delegation chain. Forward-only: past messages are never reported.",
+    { agent: external_exports.string().min(1).describe("Agent (role) name or container id.") },
+    async ({ agent }) => {
+      const { root, err } = rootOr();
+      if (err) return err;
+      const role = findAgentOf(root, agent);
+      if (!role) return textResult(`enable_monitoring failed: "${agent}" is not a role under root "${root.name}".`, true);
+      try {
+        await setAgentMonitoring(root, role, true);
+        return textResult(`Monitoring enabled on "${role.name}" \u2014 its message traffic now reports to root "${root.name}".`);
+      } catch (e) {
+        return textResult(`enable_monitoring failed: ${String(e)}`, true);
+      }
+    }
+  );
+  server.tool(
+    "disable_monitoring",
+    "Disable monitoring on one of this host's agents (see enable_monitoring).",
+    { agent: external_exports.string().min(1).describe("Agent (role) name or container id.") },
+    async ({ agent }) => {
+      const { root, err } = rootOr();
+      if (err) return err;
+      const role = findAgentOf(root, agent);
+      if (!role) return textResult(`disable_monitoring failed: "${agent}" is not a role under root "${root.name}".`, true);
+      try {
+        await setAgentMonitoring(root, role, false);
+        return textResult(`Monitoring disabled on "${role.name}".`);
+      } catch (e) {
+        return textResult(`disable_monitoring failed: ${String(e)}`, true);
+      }
+    }
+  );
+  server.tool(
+    "bind_monitoring_proxy",
+    "Start binding a browser (messenger) account as this host's monitoring & control proxy. PREREQUISITE: the browser account must already be a contact of the ROOT identity (invite exchange). This generates a 6-digit code (5-minute expiry, 3 attempts) bound to that contact and shows it HERE \u2014 read it to the user, who enters it in the messenger's Control Panel. On a successful code verification the contact becomes the monitoring proxy: it receives the monitoring feed and may manage agents (create, edit bios, toggle monitoring, request invites) through the root.",
+    { contact: external_exports.string().min(1).describe("The root's contact (name or container id) to bind as the proxy.") },
+    async ({ contact }) => {
+      const { root, err } = rootOr();
+      if (err) return err;
+      try {
+        const code = String(randomInt(0, 1e6)).padStart(6, "0");
+        const data = await mutatingTx(root, "::actor::set_proxy_pending", { code, proxy: contact });
+        const cid = data.Reduce("proxy_cid").Visualize();
+        return textResult(
+          `Proxy binding started for contact "${contact}" (${cid}).
+
+Verification code: ${code}
+
+Tell the user to enter this code in the messenger's Control Panel within 5 minutes (3 attempts). Do NOT send the code over a2adapt \u2014 it must travel out-of-band (this terminal counts).`
+        );
+      } catch (e) {
+        return textResult(`bind_monitoring_proxy failed: ${String(e)}`, true);
+      }
+    }
+  );
+  server.tool(
+    "get_monitoring_status",
+    "Report the monitoring & control state of this host: the root's bound proxy (if any), a pending proxy verification, queued copies/requests, and which agents have monitoring enabled.",
+    {},
+    async () => {
+      const { root, err } = rootOr();
+      if (err) return err;
+      try {
+        const st = monitoringStatus(root);
+        const lines = [];
+        lines.push(`Root "${root.name}" (${root.cid}):`);
+        lines.push(st.proxyCid ? `\u2022 monitoring proxy bound: ${st.proxyCid}` : "\u2022 no monitoring proxy bound");
+        if (st.proxyPending) lines.push("\u2022 a proxy code verification is pending");
+        if (st.copiesQueued > 0) lines.push(`\u2022 ${st.copiesQueued} monitoring cop${st.copiesQueued === 1 ? "y" : "ies"} queued for forwarding`);
+        if (st.controlQueued > 0) lines.push(`\u2022 ${st.controlQueued} control request(s) queued`);
+        const agents = listAgentsFor(root);
+        lines.push("");
+        lines.push(
+          agents.length === 0 ? "No agents (roles) under this root." : `Agents (${agents.length}):
+${agents.map((a) => `\u2022 ${a.name} \u2014 monitoring ${a.monitoring ? "ON" : "off"}${a.bio ? ` \u2014 ${a.bio}` : ""}`).join("\n")}`
+        );
+        return textResult(lines.join("\n"));
+      } catch (e) {
+        return textResult(`get_monitoring_status failed: ${String(e)}`, true);
+      }
+    }
+  );
   return server;
 }
 function readBody(req) {