@deployfoundation/foundation-deploy 0.2.19 → 0.2.20

package/dist/bin/foundation-deploy.js

@@ -119,18 +119,132 @@ var GOOGLE_CALENDAR_EVENTS_SCOPE = [
 var GOOGLE_CALENDAR_JSON_MAX_BYTES = 2 * 1024 * 1024;
 // ../connectors/src/otter.ts
 var OTTER_MAX_RESPONSE_BYTES = 2 * 1024 * 1024;
+// ../connectors/src/remote-mcp.ts
+var REMOTE_MCP_PROTOCOL_VERSIONS = ["2025-11-25", "2025-06-18", "2025-03-26"];
+var REMOTE_MCP_MAX_RESPONSE_BYTES = 1024 * 1024;
+var REMOTE_MCP_MAX_REQUEST_BYTES = 256 * 1024;
+var MAX_URL_CHARS = 2048;
+var MAX_TOKEN_TTL_SECONDS = 31 * 24 * 60 * 60;
+class RemoteMcpResponseTooLargeError extends Error {
+  constructor() {
+    super(`remote MCP response exceeded ${REMOTE_MCP_MAX_RESPONSE_BYTES} bytes`);
+    this.name = "RemoteMcpResponseTooLargeError";
+  }
+}
+class RemoteMcpTimeoutError extends Error {
+  constructor() {
+    super("remote MCP did not answer in time");
+    this.name = "RemoteMcpTimeoutError";
+  }
+}
+function defineRemoteMcpProvider(input) {
+  const protocolVersions = [...input.protocolVersions ?? REMOTE_MCP_PROTOCOL_VERSIONS];
+  if (protocolVersions.length === 0 || new Set(protocolVersions).size !== protocolVersions.length || !protocolVersions.every((version) => /^\d{4}-\d{2}-\d{2}$/.test(version)))
+    throw new Error("remote MCP provider: invalid protocolVersions");
+  if (!/^[A-Za-z0-9_.-]{1,128}$/.test(input.clientName))
+    throw new Error("remote MCP provider: invalid clientName");
+  return Object.freeze({
+    endpoint: httpsUrl(input.endpoint, "remote MCP provider: endpoint"),
+    issuer: httpsUrl(input.issuer, "remote MCP provider: issuer"),
+    tokenUrl: httpsUrl(input.tokenUrl, "remote MCP provider: tokenUrl"),
+    clientName: input.clientName,
+    protocolVersions: Object.freeze(protocolVersions)
+  });
+}
+async function readBoundedRemoteMcpResponse(response, maxBytes = REMOTE_MCP_MAX_RESPONSE_BYTES, signal) {
+  const chunks = [];
+  let total = 0;
+  await consumeBody(response, maxBytes, signal, (chunk) => {
+    chunks.push(chunk);
+    total += chunk.byteLength;
+    return false;
+  });
+  const bytes = new Uint8Array(total);
+  let offset = 0;
+  for (const chunk of chunks) {
+    bytes.set(chunk, offset);
+    offset += chunk.byteLength;
+  }
+  return new TextDecoder().decode(bytes);
+}
+async function consumeBody(response, maxBytes, signal, onChunk) {
+  const declaredBytes = Number(response.headers.get("content-length") ?? "");
+  if (Number.isFinite(declaredBytes) && declaredBytes > maxBytes) {
+    await response.body?.cancel().catch(() => {
+      return;
+    });
+    throw new RemoteMcpResponseTooLargeError;
+  }
+  const reader = response.body?.getReader();
+  if (reader === undefined)
+    return 0;
+  const cancel = () => {
+    reader.cancel().catch(() => {
+      return;
+    });
+  };
+  const aborted = () => signal?.aborted === true;
+  if (aborted()) {
+    cancel();
+    throw new RemoteMcpTimeoutError;
+  }
+  signal?.addEventListener("abort", cancel, { once: true });
+  let total = 0;
+  try {
+    while (true) {
+      let next;
+      try {
+        next = await reader.read();
+      } catch {
+        if (aborted())
+          throw new RemoteMcpTimeoutError;
+        throw new Error("remote MCP response could not be read");
+      }
+      if (aborted())
+        throw new RemoteMcpTimeoutError;
+      if (next.done)
+        return total;
+      total += next.value.byteLength;
+      if (total > maxBytes) {
+        cancel();
+        throw new RemoteMcpResponseTooLargeError;
+      }
+      if (onChunk(next.value)) {
+        cancel();
+        return total;
+      }
+    }
+  } finally {
+    signal?.removeEventListener("abort", cancel);
+  }
+}
+function httpsUrl(value, label) {
+  let url;
+  try {
+    url = new URL(value);
+  } catch {
+    throw new Error(`${label} must be an HTTPS URL`);
+  }
+  if (value.length > MAX_URL_CHARS || url.protocol !== "https:" || url.username !== "" || url.password !== "" || url.hash !== "" || url.search !== "")
+    throw new Error(`${label} must be an HTTPS URL`);
+  return value;
+}
+
 // ../connectors/src/knock.ts
+var KNOCK_MCP_ENDPOINT = "https://mcp.knock.app/mcp";
+var KNOCK_OAUTH_ISSUER = "https://mcp.knock.app";
+var KNOCK_TOKEN_URL = "https://mcp.knock.app/token";
 var KNOCK_REGISTER_URL = "https://mcp.knock.app/register";
-var KNOCK_MAX_RESPONSE_BYTES = 1024 * 1024;
-var KNOCK_MAX_REQUEST_BYTES = 256 * 1024;
+var KNOCK_MCP_PROTOCOL_VERSION = "2025-06-18";
+var KNOCK_MCP_PROVIDER = defineRemoteMcpProvider({
+  endpoint: KNOCK_MCP_ENDPOINT,
+  issuer: KNOCK_OAUTH_ISSUER,
+  tokenUrl: KNOCK_TOKEN_URL,
+  clientName: "foundation-knock-proxy",
+  protocolVersions: [KNOCK_MCP_PROTOCOL_VERSION]
+});
 var MAX_CLIENT_ID_CHARS = 2048;
 var MAX_REDIRECT_URI_CHARS = 2048;
-class KnockResponseTooLargeError extends Error {
-  constructor() {
-    super(`Knock response exceeded ${KNOCK_MAX_RESPONSE_BYTES} bytes`);
-    this.name = "KnockResponseTooLargeError";
-  }
-}
 function parseKnockOAuthClient(raw) {
   const value = parseJsonObject(raw, "Knock OAuth client");
   const keys = Object.keys(value);
@@ -162,46 +276,12 @@ async function registerKnockPublicClient(args) {
   }
   if (!response.ok)
     throw new Error("Knock OAuth registration was rejected");
-  const body = parseJsonObject(await readBoundedKnockResponse(response), "Knock OAuth registration");
+  const body = parseJsonObject(await readBoundedRemoteMcpResponse(response), "Knock OAuth registration");
   return {
     client_id: requiredOpaqueString(body.client_id, "Knock OAuth registration: missing client_id", MAX_CLIENT_ID_CHARS),
     redirect_uri: redirectUri
   };
 }
-async function readBoundedKnockResponse(response, maxBytes = KNOCK_MAX_RESPONSE_BYTES) {
-  const declaredBytes = Number(response.headers.get("content-length") ?? "");
-  if (Number.isFinite(declaredBytes) && declaredBytes > maxBytes) {
-    await response.body?.cancel().catch(() => {
-      return;
-    });
-    throw new KnockResponseTooLargeError;
-  }
-  const reader = response.body?.getReader();
-  if (reader === undefined)
-    return "";
-  const chunks = [];
-  let total = 0;
-  while (true) {
-    const { done, value } = await reader.read();
-    if (done)
-      break;
-    total += value.byteLength;
-    if (total > maxBytes) {
-      await reader.cancel().catch(() => {
-        return;
-      });
-      throw new KnockResponseTooLargeError;
-    }
-    chunks.push(value);
-  }
-  const bytes = new Uint8Array(total);
-  let offset = 0;
-  for (const chunk of chunks) {
-    bytes.set(chunk, offset);
-    offset += chunk.byteLength;
-  }
-  return new TextDecoder().decode(bytes);
-}
 function parseJsonObject(raw, label) {
   let value;
   try {

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@deployfoundation/foundation-deploy",
-  "version": "0.2.19",
+  "version": "0.2.20",
   "description": "Deploys one Foundation instance from a published, signed release: the CDK app and the deploy tool.",
   "license": "UNLICENSED",
   "private": false,