@cosmonic-labs/openapi2mcp 0.10.0 → 0.10.2

package/node_modules/@bytecodealliance/preview2-shim/lib/io/calls.js

@@ -0,0 +1,128 @@
+let call_id = 0;
+
+// Call is a 32 bit integer, leading 8 bits are call number, trailing 24 bits allow custom call types
+export const CALL_MASK = 0xff000000;
+export const CALL_TYPE_MASK = 0x00ffffff;
+export const CALL_SHIFT = 24;
+
+// Type indiciator for generic Stream, Future, and Poll calls
+let cnt = 0;
+export const STDIN = ++cnt;
+export const STDOUT = ++cnt;
+export const STDERR = ++cnt;
+export const FILE = ++cnt;
+export const HTTP = ++cnt;
+export const SOCKET_TCP = ++cnt;
+export const SOCKET_UDP = ++cnt;
+export const CLOCKS = ++cnt;
+
+// Io Input Stream
+export const INPUT_STREAM_CREATE = ++call_id << CALL_SHIFT;
+export const INPUT_STREAM_READ = ++call_id << CALL_SHIFT;
+export const INPUT_STREAM_BLOCKING_READ = ++call_id << CALL_SHIFT;
+export const INPUT_STREAM_SKIP = ++call_id << CALL_SHIFT;
+export const INPUT_STREAM_BLOCKING_SKIP = ++call_id << CALL_SHIFT;
+export const INPUT_STREAM_SUBSCRIBE = ++call_id << CALL_SHIFT;
+export const INPUT_STREAM_DISPOSE = ++call_id << CALL_SHIFT;
+
+// Io Output Stream
+export const OUTPUT_STREAM_CREATE = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_CHECK_WRITE = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_WRITE = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_BLOCKING_WRITE_AND_FLUSH = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_FLUSH = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_BLOCKING_FLUSH = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_WRITE_ZEROES = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_BLOCKING_WRITE_ZEROES_AND_FLUSH = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_SPLICE = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_BLOCKING_SPLICE = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_SUBSCRIBE = ++call_id << CALL_SHIFT;
+export const OUTPUT_STREAM_DISPOSE = ++call_id << CALL_SHIFT;
+
+export const OUTPUT_STREAM_GET_TOTAL_BYTES = ++call_id << CALL_SHIFT;
+
+// Io Poll
+export const POLL_POLLABLE_READY = ++call_id << CALL_SHIFT;
+export const POLL_POLLABLE_BLOCK = ++call_id << CALL_SHIFT;
+export const POLL_POLLABLE_DISPOSE = ++call_id << CALL_SHIFT;
+export const POLL_POLL_LIST = ++call_id << CALL_SHIFT;
+
+// Futures
+export const FUTURE_DISPOSE = ++call_id << CALL_SHIFT;
+export const FUTURE_TAKE_VALUE = ++call_id << CALL_SHIFT;
+export const FUTURE_SUBSCRIBE = ++call_id << CALL_SHIFT;
+
+// Http
+export const HTTP_CREATE_REQUEST = ++call_id << 24;
+export const HTTP_OUTPUT_STREAM_FINISH = ++call_id << CALL_SHIFT;
+// Http server
+export const HTTP_SERVER_START = ++call_id << CALL_SHIFT;
+export const HTTP_SERVER_STOP = ++call_id << CALL_SHIFT;
+export const HTTP_SERVER_INCOMING_HANDLER = ++call_id << CALL_SHIFT;
+export const HTTP_SERVER_SET_OUTGOING_RESPONSE = ++call_id << CALL_SHIFT;
+export const HTTP_SERVER_CLEAR_OUTGOING_RESPONSE = ++call_id << CALL_SHIFT;
+export const HTTP_SERVER_GET_ADDRESS = ++call_id << CALL_SHIFT;
+export const HTTP_OUTGOING_BODY_DISPOSE = ++call_id << CALL_SHIFT;
+
+// Clocks
+export const CLOCKS_DURATION_SUBSCRIBE = ++call_id << CALL_SHIFT;
+export const CLOCKS_INSTANT_SUBSCRIBE = ++call_id << CALL_SHIFT;
+
+// Sockets
+// Tcp
+export const SOCKET_TCP_CREATE_HANDLE = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_BIND_START = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_BIND_FINISH = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_CONNECT_START = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_CONNECT_FINISH = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_SUBSCRIBE = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_LISTEN_START = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_LISTEN_FINISH = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_IS_LISTENING = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_ACCEPT = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_GET_LOCAL_ADDRESS = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_GET_REMOTE_ADDRESS = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_SET_KEEP_ALIVE = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_SET_LISTEN_BACKLOG_SIZE = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_SHUTDOWN = ++call_id << CALL_SHIFT;
+export const SOCKET_TCP_DISPOSE = ++call_id << CALL_SHIFT;
+// Udp
+export const SOCKET_UDP_CREATE_HANDLE = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_BIND_START = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_BIND_FINISH = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_STREAM = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_SUBSCRIBE = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_DISPOSE = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_GET_LOCAL_ADDRESS = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_GET_RECEIVE_BUFFER_SIZE = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_GET_REMOTE_ADDRESS = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_GET_SEND_BUFFER_SIZE = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_GET_UNICAST_HOP_LIMIT = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_SET_RECEIVE_BUFFER_SIZE = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_SET_SEND_BUFFER_SIZE = ++call_id << CALL_SHIFT;
+export const SOCKET_UDP_SET_UNICAST_HOP_LIMIT = ++call_id << CALL_SHIFT;
+export const SOCKET_INCOMING_DATAGRAM_STREAM_RECEIVE = ++call_id << CALL_SHIFT;
+export const SOCKET_OUTGOING_DATAGRAM_STREAM_CHECK_SEND = ++call_id << CALL_SHIFT;
+export const SOCKET_OUTGOING_DATAGRAM_STREAM_SEND = ++call_id << CALL_SHIFT;
+export const SOCKET_DATAGRAM_STREAM_SUBSCRIBE = ++call_id << CALL_SHIFT;
+export const SOCKET_DATAGRAM_STREAM_DISPOSE = ++call_id << CALL_SHIFT;
+
+export const SOCKET_GET_DEFAULT_SEND_BUFFER_SIZE = ++call_id << CALL_SHIFT;
+export const SOCKET_GET_DEFAULT_RECEIVE_BUFFER_SIZE = ++call_id << CALL_SHIFT;
+
+// Name lookup
+export const SOCKET_RESOLVE_ADDRESS_CREATE_REQUEST = ++call_id << CALL_SHIFT;
+export const SOCKET_RESOLVE_ADDRESS_TAKE_REQUEST = ++call_id << CALL_SHIFT;
+export const SOCKET_RESOLVE_ADDRESS_SUBSCRIBE_REQUEST = ++call_id << CALL_SHIFT;
+export const SOCKET_RESOLVE_ADDRESS_DISPOSE_REQUEST = ++call_id << CALL_SHIFT;
+
+export const reverseMap = {};
+
+import * as calls from "./calls.js";
+
+for (const name of Object.getOwnPropertyNames(calls)) {
+  if (name === "reverseMap") {
+    continue;
+  }
+  reverseMap[calls[name]] = name;
+}

package/node_modules/@bytecodealliance/preview2-shim/lib/io/worker-http.js

@@ -0,0 +1,206 @@
+import { createReadableStream, getStreamOrThrow } from "./worker-thread.js";
+import { createServer, request as httpRequest, Agent as HttpAgent } from "node:http";
+import { request as httpsRequest, Agent as HttpsAgent } from "node:https";
+import { parentPort } from "node:worker_threads";
+import { HTTP_SERVER_INCOMING_HANDLER } from "./calls.js";
+
+const agentOptions = {
+  keepAlive: true,
+};
+const httpAgent = new HttpAgent(agentOptions);
+const httpsAgent = new HttpsAgent(agentOptions);
+
+const servers = new Map();
+
+let responseCnt = 0;
+const responses = new Map();
+
+export async function stopHttpServer(id) {
+  await new Promise((resolve) => servers.get(id).close(resolve));
+}
+
+export function clearOutgoingResponse(id) {
+  responses.delete(id);
+}
+
+export async function getHttpServerAddress(id) {
+  return servers.get(id).address();
+}
+
+export async function setOutgoingResponse(id, { statusCode, headers, streamId }) {
+  const response = responses.get(id);
+  const textDecoder = new TextDecoder();
+  response.writeHead(
+    statusCode,
+    Object.fromEntries(headers.map(([key, val]) => [key, textDecoder.decode(val)])),
+  );
+  response.flushHeaders();
+  const { stream } = getStreamOrThrow(streamId);
+  stream.pipe(response);
+  responses.delete(id);
+}
+
+export async function startHttpServer(id, { port, host }) {
+  const server = createServer((req, res) => {
+    // create the streams and their ids
+    const streamId = createReadableStream(req);
+    const responseId = ++responseCnt;
+    parentPort.postMessage({
+      type: HTTP_SERVER_INCOMING_HANDLER,
+      id,
+      payload: {
+        responseId,
+        method: req.method,
+        host: req.headers.host || host || "localhost",
+        pathWithQuery: req.url,
+        headers: Object.entries(req.headersDistinct).flatMap(([key, val]) =>
+          val.map((val) => [key, val]),
+        ),
+        streamId,
+      },
+    });
+    responses.set(responseId, res);
+  });
+  await new Promise((resolve, reject) => {
+    server.listen(port, host, resolve);
+    server.on("error", reject);
+  });
+  servers.set(id, server);
+}
+
+export async function createHttpRequest(
+  method,
+  scheme,
+  authority,
+  pathWithQuery,
+  headers,
+  bodyId,
+  connectTimeout,
+  betweenBytesTimeout,
+  firstByteTimeout,
+) {
+  let stream = null;
+  if (bodyId) {
+    try {
+      ({ stream } = getStreamOrThrow(bodyId));
+    } catch (e) {
+      if (e.tag === "closed") {
+        throw {
+          tag: "internal-error",
+          val: "Unexpected closed body stream",
+        };
+      }
+      // it should never be possible for the body stream to already
+      // be closed, or for there to be a write error
+      // we therefore just throw internal error here
+      if (e.tag === "last-operation-failed") {
+        throw {
+          tag: "internal-error",
+          val: e.val,
+        };
+      }
+      // entirely unknown error -> trap
+      throw e;
+    }
+  }
+  try {
+    // Make a request
+    let req;
+    switch (scheme) {
+      case "http:":
+        req = httpRequest({
+          agent: httpAgent,
+          method,
+          host: authority.split(":")[0],
+          port: authority.split(":")[1],
+          path: pathWithQuery,
+          timeout: connectTimeout && Number(connectTimeout / 1_000_000n),
+        });
+        break;
+      case "https:":
+        req = httpsRequest({
+          agent: httpsAgent,
+          method,
+          host: authority.split(":")[0],
+          port: authority.split(":")[1],
+          path: pathWithQuery,
+          timeout: connectTimeout && Number(connectTimeout / 1_000_000n),
+        });
+        break;
+      default:
+        throw { tag: "HTTP-protocol-error" };
+    }
+    for (const [key, value] of headers) {
+      req.appendHeader(key, value);
+    }
+    req.flushHeaders();
+    if (stream) {
+      stream.pipe(req);
+    } else {
+      req.end();
+    }
+    const res = await new Promise((resolve, reject) => {
+      req.once("timeout", () => {
+        reject({
+          tag: "connection-timeout",
+        });
+        req.destroy();
+      });
+      req.once("response", resolve);
+      req.once("close", () => reject);
+      req.once("error", reject);
+    });
+    if (firstByteTimeout) {
+      res.setTimeout(Number(firstByteTimeout / 1_000_000n));
+    }
+    if (betweenBytesTimeout) {
+      res.once("readable", () => {
+        res.setTimeout(Number(betweenBytesTimeout / 1_000_000n));
+      });
+    }
+    const bodyStreamId = createReadableStream(res);
+    return {
+      status: res.statusCode,
+      headers: Array.from(Object.entries(res.headers)),
+      bodyStreamId,
+    };
+  } catch (e) {
+    if (e?.tag) {
+      throw e;
+    }
+    const err = getFirstError(e);
+    switch (err.code) {
+      case "ECONNRESET":
+        throw { tag: "HTTP-protocol-error" };
+      case "ENOTFOUND":
+        throw {
+          tag: "DNS-error",
+          val: {
+            rcode: err.code,
+            infoCode: err.errno < 0 ? -err.errno : err.errno,
+          },
+        };
+      case "ECONNREFUSED":
+        throw {
+          tag: "connection-refused",
+        };
+    }
+    throw {
+      tag: "internal-error",
+      val: err.toString(),
+    };
+  }
+}
+
+function getFirstError(e) {
+  if (typeof e !== "object" || e === null) {
+    return e;
+  }
+  if (e.cause) {
+    return getFirstError(e.cause);
+  }
+  if (e instanceof AggregateError) {
+    return getFirstError(e.errors[0]);
+  }
+  return e;
+}