@byok-sdk/client 0.10.2 → 0.12.0

package/dist/bin/byok-agent-team-mcp.js

@@ -0,0 +1,765 @@
+#!/usr/bin/env node
+import { promises, constants } from 'fs';
+import net from 'net';
+import { randomBytes, createHash, timingSafeEqual, createHmac } from 'crypto';
+import path from 'path';
+import { createInterface } from 'readline';
+
+var CONTROL_PROTOCOL_VERSION = 1;
+var HANDSHAKE_TIMEOUT_MS = 3e3;
+var UNIX_SOCKET_PATH_SOFT_LIMIT = 100;
+var CONTROL_SOCKET_FALLBACK_ROOT = "/tmp";
+function shortHash(input) {
+  return createHash("sha256").update(input, "utf8").digest("hex").slice(0, 16);
+}
+function controlSocketPath(storeDir) {
+  const candidate = path.join(storeDir, "control.sock");
+  if (Buffer.byteLength(candidate, "utf8") <= UNIX_SOCKET_PATH_SOFT_LIMIT) return candidate;
+  return path.join(CONTROL_SOCKET_FALLBACK_ROOT, `byok-${shortHash(storeDir)}`, "sock");
+}
+function controlPipeName(productId, storeDir) {
+  const id = shortHash(`${productId}|${path.resolve(storeDir)}`);
+  return `\\\\.\\pipe\\byok-${id}`;
+}
+function controlEndpointPath(productId, storeDir, platform = process.platform) {
+  return platform === "win32" ? controlPipeName(productId, storeDir) : controlSocketPath(storeDir);
+}
+function controlTokenPath(storeDir) {
+  return path.join(storeDir, "control.token");
+}
+var SERVER_PROOF_LABEL = "byok-control-server|";
+var CLIENT_AUTH_LABEL = "byok-control-client|";
+function randomNonceHex() {
+  return randomBytes(32).toString("hex");
+}
+function hmacHex(token, message) {
+  return createHmac("sha256", token).update(message, "utf8").digest("hex");
+}
+function computeServerProof(token, clientNonce) {
+  return hmacHex(token, SERVER_PROOF_LABEL + clientNonce);
+}
+function computeClientAuth(token, serverNonce) {
+  return hmacHex(token, CLIENT_AUTH_LABEL + serverNonce);
+}
+function timingSafeEqualHex(a, b) {
+  const bufA = Buffer.from(a, "hex");
+  const bufB = Buffer.from(b, "hex");
+  if (bufA.length !== bufB.length) return false;
+  return timingSafeEqual(bufA, bufB);
+}
+function isRecord(value) {
+  return typeof value === "object" && value !== null;
+}
+function parseServerHello(value) {
+  if (!isRecord(value)) return void 0;
+  if (value.v !== CONTROL_PROTOCOL_VERSION || value.hello !== "server" || typeof value.proof !== "string" || typeof value.nonce !== "string") {
+    return void 0;
+  }
+  return { v: CONTROL_PROTOCOL_VERSION, hello: "server", proof: value.proof, nonce: value.nonce };
+}
+function parseServerReady(value) {
+  if (!isRecord(value)) return void 0;
+  if (value.v !== CONTROL_PROTOCOL_VERSION || value.ready !== true) return void 0;
+  return { v: CONTROL_PROTOCOL_VERSION, ready: true };
+}
+function encodeFrame(frame) {
+  return `${JSON.stringify(frame)}
+`;
+}
+var ControlError = class extends Error {
+  constructor(code, message) {
+    super(message);
+    this.code = code;
+    this.name = "ControlError";
+  }
+  code;
+};
+var MAX_LINE_BYTES = 64 * 1024;
+var NdjsonLineReader = class {
+  pending = Buffer.alloc(0);
+  /** @throws if the still-unterminated remainder exceeds {@link MAX_LINE_BYTES} — see that constant's own doc comment. */
+  push(chunk) {
+    this.pending = this.pending.length > 0 ? Buffer.concat([this.pending, chunk]) : chunk;
+    const lines = [];
+    let newlineIndex;
+    while ((newlineIndex = this.pending.indexOf(10)) !== -1) {
+      const line = this.pending.subarray(0, newlineIndex).toString("utf8");
+      this.pending = this.pending.subarray(newlineIndex + 1);
+      if (line.length > 0) lines.push(line);
+    }
+    if (this.pending.length > MAX_LINE_BYTES) {
+      throw new Error(`NDJSON line exceeded ${MAX_LINE_BYTES} bytes without a terminating newline`);
+    }
+    return lines;
+  }
+};
+
+// src/bin/control-client.ts
+var MAX_CONTROL_TOKEN_BYTES = 256;
+function errorMessage(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function sameFileState(left, right) {
+  return left.dev === right.dev && left.ino === right.ino && left.size === right.size && left.mtimeNs === right.mtimeNs && left.ctimeNs === right.ctimeNs;
+}
+async function readControlToken(tokenPath) {
+  let namedBefore;
+  try {
+    namedBefore = await promises.lstat(tokenPath, { bigint: true });
+  } catch (err) {
+    if (err.code === "ENOENT") return void 0;
+    throw err;
+  }
+  if (!namedBefore.isFile() || namedBefore.isSymbolicLink()) {
+    throw new Error("control token is not a real regular file");
+  }
+  const handle = await promises.open(
+    tokenPath,
+    constants.O_RDONLY | (constants.O_NONBLOCK ?? 0) | (constants.O_NOFOLLOW ?? 0)
+  );
+  try {
+    const opened = await handle.stat({ bigint: true });
+    const namedAfterOpen = await promises.lstat(tokenPath, { bigint: true });
+    if (!opened.isFile() || !namedAfterOpen.isFile() || namedAfterOpen.isSymbolicLink() || !sameFileState(namedBefore, opened) || !sameFileState(opened, namedAfterOpen)) {
+      throw new Error("control token pathname changed before safe open");
+    }
+    if (opened.size < 0 || opened.size > BigInt(MAX_CONTROL_TOKEN_BYTES)) {
+      throw new Error("control token exceeds the bounded read limit");
+    }
+    const size = Number(opened.size);
+    const bytes = Buffer.alloc(size);
+    const { bytesRead } = await handle.read(bytes, 0, size, 0);
+    const afterRead = await handle.stat({ bigint: true });
+    const namedAfterRead = await promises.lstat(tokenPath, { bigint: true });
+    if (bytesRead !== size || namedAfterRead.isSymbolicLink() || !sameFileState(opened, afterRead) || !sameFileState(afterRead, namedAfterRead)) {
+      throw new Error("control token changed during bounded read");
+    }
+    return bytes.toString("utf8").trim();
+  } finally {
+    await handle.close();
+  }
+}
+async function connectControlClient(opts) {
+  const tokenPath = controlTokenPath(opts.storeDir);
+  let token;
+  try {
+    const read = await readControlToken(tokenPath);
+    if (read === void 0) {
+      return { ok: false, reason: "daemon is not running (no control.token found)" };
+    }
+    token = read;
+  } catch (err) {
+    return { ok: false, reason: `could not read the control token: ${errorMessage(err)}` };
+  }
+  if (!token) {
+    return { ok: false, reason: "control token file is empty" };
+  }
+  const endpoint = controlEndpointPath(opts.productId, opts.storeDir);
+  try {
+    const client = await connectAndHandshake(endpoint, token, opts);
+    return { ok: true, client };
+  } catch (err) {
+    return { ok: false, reason: `daemon control socket not reachable: ${errorMessage(err)}` };
+  }
+}
+function connectAndHandshake(endpoint, token, opts) {
+  return new Promise((resolve, reject) => {
+    const socket = net.createConnection(endpoint);
+    const reader = new NdjsonLineReader();
+    let phase = "server-hello";
+    let settled = false;
+    const clientNonce = randomNonceHex();
+    const timer = setTimeout(() => {
+      fail(new Error("handshake timed out"));
+    }, opts.handshakeTimeoutMs ?? HANDSHAKE_TIMEOUT_MS);
+    timer.unref?.();
+    function fail(err) {
+      if (settled) return;
+      settled = true;
+      clearTimeout(timer);
+      socket.removeAllListeners();
+      socket.destroy();
+      reject(err instanceof Error ? err : new Error(String(err)));
+    }
+    function succeed() {
+      settled = true;
+      clearTimeout(timer);
+      socket.removeListener("error", onError);
+      socket.removeListener("data", onData);
+      resolve(createControlClient(socket, reader, opts));
+    }
+    function onData(chunk) {
+      let lines;
+      try {
+        lines = reader.push(chunk);
+      } catch (err) {
+        fail(err);
+        return;
+      }
+      for (const line of lines) {
+        let parsed;
+        try {
+          parsed = JSON.parse(line);
+        } catch {
+          fail(new Error("malformed handshake frame"));
+          return;
+        }
+        if (phase === "server-hello") {
+          const hello = parseServerHello(parsed);
+          if (!hello) {
+            fail(new Error("malformed or unexpected server hello"));
+            return;
+          }
+          if (!timingSafeEqualHex(hello.proof, computeServerProof(token, clientNonce))) {
+            fail(new Error("server failed to prove it holds the control token"));
+            return;
+          }
+          socket.write(encodeFrame({ v: CONTROL_PROTOCOL_VERSION, auth: computeClientAuth(token, hello.nonce) }));
+          phase = "ready";
+          continue;
+        }
+        if (!parseServerReady(parsed)) {
+          fail(new Error("server did not confirm readiness"));
+          return;
+        }
+        succeed();
+        return;
+      }
+    }
+    function onError(err) {
+      fail(err);
+    }
+    socket.once("error", onError);
+    socket.once("connect", () => {
+      socket.write(encodeFrame({ v: CONTROL_PROTOCOL_VERSION, hello: "client", nonce: clientNonce }));
+      socket.on("data", onData);
+    });
+  });
+}
+function withTimeout(promise, ms, message) {
+  return new Promise((resolve, reject) => {
+    const timer = setTimeout(() => reject(new Error(message)), ms);
+    timer.unref?.();
+    promise.then(
+      (value) => {
+        clearTimeout(timer);
+        resolve(value);
+      },
+      (err) => {
+        clearTimeout(timer);
+        reject(err);
+      }
+    );
+  });
+}
+function createControlClient(socket, reader, opts) {
+  const pending = /* @__PURE__ */ new Map();
+  let idSeq = 0;
+  let closed = false;
+  function handleFrame(parsed) {
+    if (!isRecord(parsed) || typeof parsed.id !== "string") return;
+    const entry = pending.get(parsed.id);
+    if (!entry) return;
+    if ("event" in parsed) {
+      entry.onEvent?.(parsed.event);
+      return;
+    }
+    if (parsed.ok === true) {
+      pending.delete(parsed.id);
+      entry.resolve(parsed.done === true ? void 0 : parsed.result);
+      return;
+    }
+    pending.delete(parsed.id);
+    const shape = parsed.error;
+    entry.reject(
+      new ControlError(
+        typeof shape?.code === "string" ? shape.code : "internal_error",
+        typeof shape?.message === "string" ? shape.message : "unknown control error"
+      )
+    );
+  }
+  socket.on("data", (chunk) => {
+    let lines;
+    try {
+      lines = reader.push(chunk);
+    } catch {
+      socket.destroy();
+      return;
+    }
+    for (const line of lines) {
+      let parsed;
+      try {
+        parsed = JSON.parse(line);
+      } catch {
+        continue;
+      }
+      handleFrame(parsed);
+    }
+  });
+  socket.on("close", () => {
+    closed = true;
+    for (const entry of pending.values()) entry.reject(new Error("control connection closed"));
+    pending.clear();
+  });
+  socket.on("error", () => {
+  });
+  function send(method, params, onEvent) {
+    const id = `c${++idSeq}`;
+    const promise = new Promise((resolve, reject) => {
+      pending.set(id, { resolve, reject, onEvent });
+    });
+    socket.write(encodeFrame({ v: CONTROL_PROTOCOL_VERSION, id, method, params }));
+    return { id, promise };
+  }
+  return {
+    async request(method, params) {
+      if (closed) throw new Error("control connection is closed");
+      const { promise } = send(method, params);
+      const result = await withTimeout(promise, opts.requestTimeoutMs ?? 1e4, `control request "${method}" timed out`);
+      return result;
+    },
+    subscribe(method, params, onEvent) {
+      const { id, promise } = send(method, params, onEvent);
+      promise.catch(() => {
+      });
+      return {
+        close: () => {
+          pending.delete(id);
+          socket.destroy();
+        }
+      };
+    },
+    close() {
+      socket.destroy();
+    }
+  };
+}
+var AGENT_MESSAGE_TOOL_NAME = "send_agent_message";
+
+// src/bin/agent-message-mcp-server.ts
+async function handleAgentMessageMcpRequest(request, deps) {
+  const id = request.id;
+  if (request.method === "initialize") {
+    const params = request.params ?? {};
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: typeof params.protocolVersion === "string" ? params.protocolVersion : "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "byok-agent-message-mcp", version: "0.0.1" }
+      }
+    };
+  }
+  if (request.method === "notifications/initialized") return void 0;
+  if (request.method === "tools/list") {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: { tools: [{
+        name: AGENT_MESSAGE_TOOL_NAME,
+        description: "Send the single user-visible Agent reply for this exact task. Routing identity is supplied by the authenticated task context.",
+        inputSchema: {
+          type: "object",
+          additionalProperties: false,
+          required: ["body"],
+          properties: {
+            body: { type: "string", minLength: 1 },
+            contentType: { type: "string", enum: ["text/plain", "text/markdown"] }
+          }
+        }
+      }] }
+    };
+  }
+  if (request.method === "tools/call") {
+    const params = request.params ?? {};
+    if (params.name !== AGENT_MESSAGE_TOOL_NAME) return { jsonrpc: "2.0", id, error: { code: -32602, message: "unknown Agent message tool" } };
+    const args = params.arguments;
+    if (args === null || typeof args !== "object" || Array.isArray(args)) return { jsonrpc: "2.0", id, error: { code: -32602, message: "message input must be an object" } };
+    const record3 = args;
+    if (Object.keys(record3).some((key) => key !== "body" && key !== "contentType") || typeof record3.body !== "string" || record3.body.length === 0) {
+      return { jsonrpc: "2.0", id, error: { code: -32602, message: "message input accepts only non-empty body and optional contentType" } };
+    }
+    const contentType = record3.contentType ?? "text/markdown";
+    if (contentType !== "text/plain" && contentType !== "text/markdown") return { jsonrpc: "2.0", id, error: { code: -32602, message: "unsupported contentType" } };
+    try {
+      const receipt = await deps.publish({ contentType, body: record3.body });
+      return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(receipt) }] } };
+    } catch (error) {
+      return { jsonrpc: "2.0", id, error: { code: -32e3, message: error instanceof Error ? error.message : String(error) } };
+    }
+  }
+  return id === void 0 ? void 0 : { jsonrpc: "2.0", id, error: { code: -32601, message: `unknown method: ${String(request.method)}` } };
+}
+function serveAgentMessageMcpOverStdio(input) {
+  const reader = createInterface({ input: input.stdin ?? process.stdin, terminal: false });
+  const output = input.stdout ?? process.stdout;
+  reader.on("line", (line) => {
+    const trimmed = line.trim();
+    if (trimmed.length === 0) return;
+    void (async () => {
+      let request;
+      try {
+        request = JSON.parse(trimmed);
+      } catch {
+        return;
+      }
+      const response = await handleAgentMessageMcpRequest(request, input.deps);
+      if (response !== void 0) output.write(`${JSON.stringify(response)}
+`);
+    })();
+  });
+}
+var AGENT_MEMORY_RECALL_TOOL_NAME = "memory_recall";
+var AGENT_MEMORY_SAVE_TOOL_NAME = "memory_save";
+function record(value) {
+  return value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+}
+function invalid(id, message) {
+  return { jsonrpc: "2.0", id, error: { code: -32602, message } };
+}
+function success(id, value) {
+  return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(value) }] } };
+}
+async function handleAgentMemoryMcpRequest(request, deps) {
+  const id = request.id;
+  if (request.method === "initialize") {
+    const params2 = record(request.params) ?? {};
+    return { jsonrpc: "2.0", id, result: { protocolVersion: typeof params2.protocolVersion === "string" ? params2.protocolVersion : "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "byok-agent-memory-mcp", version: "0.0.1" } } };
+  }
+  if (request.method === "notifications/initialized") return void 0;
+  if (request.method === "tools/list") return {
+    jsonrpc: "2.0",
+    id,
+    result: { tools: [
+      { name: AGENT_MEMORY_RECALL_TOOL_NAME, description: "Recall one SDK-owned memory file for this exact active Agent task. Identity and memory root are never model parameters.", inputSchema: { type: "object", additionalProperties: false, required: ["path"], properties: { path: { type: "string" }, ifRevision: { type: "string", pattern: "^sha256:[a-f0-9]{64}$" } } } },
+      { name: AGENT_MEMORY_SAVE_TOOL_NAME, description: "Atomically replace or delete one SDK-owned memory file with exact sha256 compare-and-swap.", inputSchema: { type: "object", additionalProperties: false, required: ["op", "path", "expectedRevision"], properties: { op: { type: "string", enum: ["replace", "delete"] }, path: { type: "string" }, expectedRevision: { type: "string", pattern: "^sha256:[a-f0-9]{64}$" }, content: { type: "string" } } } }
+    ] }
+  };
+  if (request.method !== "tools/call") return id === void 0 ? void 0 : { jsonrpc: "2.0", id, error: { code: -32601, message: `unknown method: ${String(request.method)}` } };
+  const params = record(request.params);
+  const args = record(params?.arguments);
+  if (!params || !args || typeof params.name !== "string") return invalid(id, "memory tool input must be an object");
+  try {
+    if (params.name === AGENT_MEMORY_RECALL_TOOL_NAME) {
+      if (Object.keys(args).some((key) => key !== "path" && key !== "ifRevision") || typeof args.path !== "string" || args.ifRevision !== void 0 && typeof args.ifRevision !== "string") return invalid(id, "memory_recall accepts only path and optional ifRevision");
+      return success(id, await deps.recall({ path: args.path, ...args.ifRevision === void 0 ? {} : { ifRevision: args.ifRevision } }));
+    }
+    if (params.name === AGENT_MEMORY_SAVE_TOOL_NAME) {
+      if (Object.keys(args).some((key) => key !== "op" && key !== "path" && key !== "expectedRevision" && key !== "content") || args.op !== "replace" && args.op !== "delete" || typeof args.path !== "string" || typeof args.expectedRevision !== "string" || args.op === "replace" && typeof args.content !== "string" || args.op === "delete" && args.content !== void 0) return invalid(id, "memory_save requires replace|delete, path, expectedRevision, and content only for replace");
+      const content = args.content;
+      return success(id, await deps.save({ op: args.op, path: args.path, expectedRevision: args.expectedRevision, ...typeof content === "string" ? { content } : {} }));
+    }
+    return invalid(id, "unknown Agent memory tool");
+  } catch (error) {
+    return { jsonrpc: "2.0", id, error: { code: -32e3, message: error instanceof Error ? error.message : String(error) } };
+  }
+}
+function serveAgentMemoryMcpOverStdio(input) {
+  const reader = createInterface({ input: input.stdin ?? process.stdin, terminal: false });
+  const output = input.stdout ?? process.stdout;
+  reader.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    void (async () => {
+      let request;
+      try {
+        request = JSON.parse(trimmed);
+      } catch {
+        return;
+      }
+      const response = await handleAgentMemoryMcpRequest(request, input.deps);
+      if (response !== void 0) output.write(`${JSON.stringify(response)}
+`);
+    })();
+  });
+}
+var TEAM_POST_TOOL_NAME = "post_team_message";
+var TEAM_READ_TOOL_NAME = "read_team_messages";
+var TEAM_ACK_TOOL_NAME = "ack_team_messages";
+var record2 = (value) => value !== null && typeof value === "object" && !Array.isArray(value) ? value : void 0;
+var invalid2 = (id, message) => ({ jsonrpc: "2.0", id, error: { code: -32602, message } });
+var success2 = (id, value) => ({ jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(value) }] } });
+async function handleTeamMcpRequest(request, deps) {
+  const { id } = request;
+  if (request.method === "initialize") {
+    const params2 = record2(request.params) ?? {};
+    return { jsonrpc: "2.0", id, result: { protocolVersion: typeof params2.protocolVersion === "string" ? params2.protocolVersion : "2024-11-05", capabilities: { tools: {} }, serverInfo: { name: "byok-agent-team-mcp", version: "0.0.1" } } };
+  }
+  if (request.method === "notifications/initialized") return void 0;
+  if (request.method === "tools/list") return { jsonrpc: "2.0", id, result: { tools: [
+    { name: TEAM_POST_TOOL_NAME, description: "Post one broadcast message as this exact leased team member. Sender and workspace are daemon-owned.", inputSchema: { type: "object", additionalProperties: false, required: ["body"], properties: { body: { type: "string" }, contentType: { type: "string" } } } },
+    { name: TEAM_READ_TOOL_NAME, description: "Read ordered team messages visible to this exact leased member.", inputSchema: { type: "object", additionalProperties: false, properties: { afterSeq: { type: "integer", minimum: 0 } } } },
+    { name: TEAM_ACK_TOOL_NAME, description: "Durably acknowledge messages through an already delivered sequence for this exact leased member.", inputSchema: { type: "object", additionalProperties: false, required: ["throughSeq"], properties: { throughSeq: { type: "integer", minimum: 0 } } } }
+  ] } };
+  if (request.method !== "tools/call") return id === void 0 ? void 0 : { jsonrpc: "2.0", id, error: { code: -32601, message: `unknown method: ${String(request.method)}` } };
+  const params = record2(request.params);
+  const args = record2(params?.arguments);
+  if (!params || !args || typeof params.name !== "string") return invalid2(id, "team tool input must be an object");
+  try {
+    if (params.name === TEAM_POST_TOOL_NAME) {
+      if (Object.keys(args).some((key) => key !== "body" && key !== "contentType") || typeof args.body !== "string" || args.contentType !== void 0 && typeof args.contentType !== "string") return invalid2(id, "post_team_message accepts body and optional contentType only");
+      return success2(id, await deps.post({ body: args.body, ...typeof args.contentType === "string" ? { contentType: args.contentType } : {} }));
+    }
+    if (params.name === TEAM_READ_TOOL_NAME) {
+      if (Object.keys(args).some((key) => key !== "afterSeq") || args.afterSeq !== void 0 && (!Number.isSafeInteger(args.afterSeq) || Number(args.afterSeq) < 0)) return invalid2(id, "read_team_messages accepts optional non-negative integer afterSeq only");
+      return success2(id, await deps.read(args.afterSeq === void 0 ? {} : { afterSeq: Number(args.afterSeq) }));
+    }
+    if (params.name === TEAM_ACK_TOOL_NAME) {
+      if (Object.keys(args).some((key) => key !== "throughSeq") || !Number.isSafeInteger(args.throughSeq) || Number(args.throughSeq) < 0) return invalid2(id, "ack_team_messages requires non-negative integer throughSeq only");
+      return success2(id, await deps.ack({ throughSeq: Number(args.throughSeq) }));
+    }
+    return invalid2(id, "unknown team tool");
+  } catch (error) {
+    return { jsonrpc: "2.0", id, error: { code: -32e3, message: error instanceof Error ? error.message : String(error) } };
+  }
+}
+function serveTeamMcpOverStdio(input) {
+  const reader = createInterface({ input: input.stdin ?? process.stdin, terminal: false });
+  const output = input.stdout ?? process.stdout;
+  reader.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    void (async () => {
+      let request;
+      try {
+        request = JSON.parse(trimmed);
+      } catch {
+        return;
+      }
+      const response = await handleTeamMcpRequest(request, input.deps);
+      if (response !== void 0) output.write(`${JSON.stringify(response)}
+`);
+    })();
+  });
+}
+var APPROVAL_TOOL_NAME = "approval_prompt";
+var APPROVAL_SUMMARY_MAX_CHARS = 500;
+function errorMessage2(err) {
+  return err instanceof Error ? err.message : String(err);
+}
+function summarizeToolCall(toolName, input) {
+  let inputStr;
+  try {
+    inputStr = JSON.stringify(input);
+  } catch (err) {
+    inputStr = `<unserializable input: ${errorMessage2(err)}>`;
+  }
+  const bounded = inputStr.length > APPROVAL_SUMMARY_MAX_CHARS ? `${inputStr.slice(0, APPROVAL_SUMMARY_MAX_CHARS)}\u2026 [truncated]` : inputStr;
+  return `${toolName}: ${bounded}`;
+}
+async function handleMcpRequest(req, deps, taskId) {
+  const id = req.id;
+  if (req.method === "initialize") {
+    const params = req.params ?? {};
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        protocolVersion: typeof params.protocolVersion === "string" ? params.protocolVersion : "2024-11-05",
+        capabilities: { tools: {} },
+        serverInfo: { name: "byok-approval-mcp", version: "0.0.1" }
+      }
+    };
+  }
+  if (req.method === "notifications/initialized") {
+    return void 0;
+  }
+  if (req.method === "tools/list") {
+    return {
+      jsonrpc: "2.0",
+      id,
+      result: {
+        tools: [
+          {
+            name: APPROVAL_TOOL_NAME,
+            description: "Requests operator approval for a pending tool call. Blocks until a human (or this device's daemon) decides, or the configured timeout elapses (fail-closed deny on timeout).",
+            inputSchema: {
+              type: "object",
+              properties: {
+                tool_name: { type: "string" },
+                input: { type: "object" }
+              }
+            }
+          }
+        ]
+      }
+    };
+  }
+  if (req.method === "tools/call") {
+    const params = req.params ?? {};
+    if (params.name !== APPROVAL_TOOL_NAME) {
+      return { jsonrpc: "2.0", id, error: { code: -32602, message: `unknown tool "${String(params.name)}"` } };
+    }
+    const args = params.arguments ?? {};
+    const toolName = typeof args.tool_name === "string" ? args.tool_name : "unknown tool";
+    const input = args.input ?? {};
+    const summary = summarizeToolCall(toolName, input);
+    let outcome;
+    try {
+      outcome = await deps.requestApproval(taskId, summary);
+    } catch (err) {
+      outcome = { approved: false, reason: `could not reach the approving device: ${errorMessage2(err)}` };
+    }
+    const payload = outcome.approved ? { behavior: "allow", updatedInput: input } : { behavior: "deny", message: outcome.reason ?? "denied" };
+    return { jsonrpc: "2.0", id, result: { content: [{ type: "text", text: JSON.stringify(payload) }] } };
+  }
+  if (id !== void 0) {
+    return { jsonrpc: "2.0", id, error: { code: -32601, message: `unknown method: ${String(req.method)}` } };
+  }
+  return void 0;
+}
+function serveApprovalMcpOverStdio(opts) {
+  const input = opts.input ?? process.stdin;
+  const output = opts.output ?? process.stdout;
+  const rl = createInterface({ input, terminal: false });
+  rl.on("line", (line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return;
+    let parsed;
+    try {
+      parsed = JSON.parse(trimmed);
+    } catch {
+      return;
+    }
+    void handleMcpRequest(parsed, opts.deps, opts.taskId).then((response) => {
+      if (response !== void 0) output.write(`${JSON.stringify(response)}
+`);
+    });
+  });
+}
+
+// src/bin/sdk-reserved-helper-runners.ts
+var APPROVAL_REQUEST_TIMEOUT_SLOP_MS = 5e3;
+function required(name) {
+  const value = process.env[name];
+  if (!value) throw new Error(`missing required environment variable ${name}`);
+  return value;
+}
+function waitForInputClose(input = process.stdin) {
+  if (input.readableEnded || input.destroyed) return Promise.resolve();
+  return new Promise((resolve) => {
+    const done = () => {
+      input.off("end", done);
+      input.off("close", done);
+      resolve();
+    };
+    input.once("end", done);
+    input.once("close", done);
+  });
+}
+async function runAgentMessageMcp() {
+  const storeDir = required("BYOK_STORE_DIR");
+  const productId = required("BYOK_PRODUCT_ID");
+  const contextToken = required("BYOK_AGENT_MESSAGE_CONTEXT");
+  let clientPromise;
+  const client = async () => {
+    if (!clientPromise) clientPromise = connectControlClient({ storeDir, productId }).then((result) => {
+      if (!result.ok) throw new Error(result.reason);
+      return result.client;
+    });
+    return clientPromise;
+  };
+  const deps = {
+    publish: async (input) => (await client()).request("agent_messages.publish", { contextToken, ...input })
+  };
+  serveAgentMessageMcpOverStdio({ deps });
+  await waitForInputClose();
+}
+async function runAgentMemoryMcp() {
+  const storeDir = required("BYOK_STORE_DIR");
+  const productId = required("BYOK_PRODUCT_ID");
+  const contextToken = required("BYOK_AGENT_MEMORY_CONTEXT");
+  let clientPromise;
+  const client = async () => {
+    if (!clientPromise) clientPromise = connectControlClient({ storeDir, productId }).then((result) => {
+      if (!result.ok) throw new Error(result.reason);
+      return result.client;
+    });
+    return clientPromise;
+  };
+  const deps = {
+    recall: async (input) => (await client()).request("agent_memory.recall", { contextToken, ...input }),
+    save: async (input) => (await client()).request("agent_memory.save", { contextToken, ...input })
+  };
+  serveAgentMemoryMcpOverStdio({ deps });
+  await waitForInputClose();
+}
+async function runApprovalMcp() {
+  const storeDir = required("BYOK_STORE_DIR");
+  const productId = required("BYOK_PRODUCT_ID");
+  const taskId = required("BYOK_TASK_ID");
+  const timeoutMs = Number(process.env.BYOK_APPROVAL_TIMEOUT_MS ?? "600000");
+  if (!Number.isFinite(timeoutMs) || timeoutMs <= 0) {
+    throw new Error("invalid BYOK_APPROVAL_TIMEOUT_MS environment variable");
+  }
+  let clientPromise;
+  const client = async () => {
+    if (!clientPromise) clientPromise = connectControlClient({
+      storeDir,
+      productId,
+      requestTimeoutMs: timeoutMs + APPROVAL_REQUEST_TIMEOUT_SLOP_MS
+    }).then((result) => {
+      if (!result.ok) throw new Error(result.reason);
+      return result.client;
+    });
+    return clientPromise;
+  };
+  const deps = {
+    requestApproval: async (requestedTaskId, summary) => {
+      try {
+        return await (await client()).request("approvals.request", { taskId: requestedTaskId, summary });
+      } catch (error) {
+        clientPromise = void 0;
+        throw error;
+      }
+    }
+  };
+  serveApprovalMcpOverStdio({ taskId, deps });
+  await waitForInputClose();
+}
+async function runAgentTeamMcp() {
+  const storeDir = required("BYOK_STORE_DIR");
+  const productId = required("BYOK_PRODUCT_ID");
+  const lease = required("BYOK_TEAM_MEMBER_CONTEXT");
+  let clientPromise;
+  const client = async () => {
+    if (!clientPromise) clientPromise = connectControlClient({ storeDir, productId }).then((result) => {
+      if (!result.ok) throw new Error(result.reason);
+      return result.client;
+    });
+    return clientPromise;
+  };
+  const deps = {
+    post: async (input) => (await client()).request("team_messages.post", { context: lease, ...input }),
+    read: async (input) => (await client()).request("team_messages.read", { context: lease, ...input }),
+    ack: async (input) => (await client()).request("team_messages.ack", { context: lease, ...input })
+  };
+  serveTeamMcpOverStdio({ deps });
+  await waitForInputClose();
+}
+async function runSdkReservedHelper(kind) {
+  switch (kind) {
+    case "agent-message-mcp":
+      await runAgentMessageMcp();
+      return;
+    case "agent-memory-mcp":
+      await runAgentMemoryMcp();
+      return;
+    case "approval-mcp":
+      await runApprovalMcp();
+      return;
+    case "agent-team-mcp":
+      await runAgentTeamMcp();
+      return;
+  }
+}
+
+// src/bin/byok-agent-team-mcp.ts
+runSdkReservedHelper("agent-team-mcp").catch((error) => {
+  process.stderr.write(`byok-agent-team-mcp: ${error instanceof Error ? error.message : String(error)}
+`);
+  process.exit(1);
+});
+//# sourceMappingURL=byok-agent-team-mcp.js.map
+//# sourceMappingURL=byok-agent-team-mcp.js.map