@silver886/mcp-proxy 0.2.0 → 0.2.2

package/README.md

@@ -213,11 +213,3 @@ object.
 | `-32003` | `PROCESS_EXITED` | MCP server child process died |
 | `-32004` | `PROCESS_NOT_RUNNING` | Child process isn't running |
 | `-32005` | `REQUEST_TIMEOUT` | MCP server didn't respond in time |
-
-## Development
-
-```bash
-pnpm install
-pnpm run build
-pnpm publish --access public --no-git-checks
-```

package/node_modules/cloudflared/LICENSE

@@ -0,0 +1,21 @@
+MIT License
+
+Copyright (c) 2022 JacobLinCool
+
+Permission is hereby granted, free of charge, to any person obtaining a copy
+of this software and associated documentation files (the "Software"), to deal
+in the Software without restriction, including without limitation the rights
+to use, copy, modify, merge, publish, distribute, sublicense, and/or sell
+copies of the Software, and to permit persons to whom the Software is
+furnished to do so, subject to the following conditions:
+
+The above copyright notice and this permission notice shall be included in all
+copies or substantial portions of the Software.
+
+THE SOFTWARE IS PROVIDED "AS IS", WITHOUT WARRANTY OF ANY KIND, EXPRESS OR
+IMPLIED, INCLUDING BUT NOT LIMITED TO THE WARRANTIES OF MERCHANTABILITY,
+FITNESS FOR A PARTICULAR PURPOSE AND NONINFRINGEMENT. IN NO EVENT SHALL THE
+AUTHORS OR COPYRIGHT HOLDERS BE LIABLE FOR ANY CLAIM, DAMAGES OR OTHER
+LIABILITY, WHETHER IN AN ACTION OF CONTRACT, TORT OR OTHERWISE, ARISING FROM,
+OUT OF OR IN CONNECTION WITH THE SOFTWARE OR THE USE OR OTHER DEALINGS IN THE
+SOFTWARE.

package/node_modules/cloudflared/README.md

@@ -0,0 +1,156 @@
+# cloudflared
+
+A Node.js package that allows you to easily create HTTPS tunnels using Cloudflare's `cloudflared` command-line tool. It provides a typed API for creating tunnels and managing the `cloudflared` binary installation.
+
+> This tool will automatically install the [latest version of `cloudflared`](https://github.com/cloudflare/cloudflared/releases/latest) (or `CLOUDFLARED_VERSION` env var if exists) at the first time.
+> Then, it just passes down the command to `cloudflared`.
+
+## Installation
+
+You can install this package using your favorite package manager:
+
+### PNPM
+
+```sh
+pnpm i -g cloudflared
+```
+
+### NPM
+
+```sh
+npm i -g cloudflared
+```
+
+### Yarn
+
+```sh
+yarn global add cloudflared
+```
+
+> If `CLOUDFLARED_VERSION` env var is set, it will install the specified version of `cloudflared`, otherwise it will install the latest version.
+
+## CLI Usage
+
+You can use the `cloudflared` command-line tool to create HTTPS tunnels. You can find the usage of `cloudflared` [here](https://developers.cloudflare.com/cloudflare-one/connections/connect-apps/install-and-setup/tunnel-useful-commands/).
+
+In addition to the standard `cloudflared` commands, this package also provides an extra subcommand: `cloudflared bin`. You can use it to manage the `cloudflared` binary version.
+
+```sh
+❯ cloudflared bin --help
+cloudflared bin                    : Prints the path to the binary
+cloudflared bin remove             : Removes the binary
+cloudflared bin install [version]  : Installs the binary
+cloudflared bin list               : Lists 30 latest releases
+cloudflared bin help               : Prints this help message
+Examples:
+cloudflared bin install            : Installs the latest version of cloudflared
+cloudflared bin install 2023.4.1   : Installs cloudflared 2023.4.1
+You can find releases at https://github.com/cloudflare/cloudflared/releases
+```
+
+## Library Usage
+
+You can also use it as a library in your TypeScript / JavaScript projects.
+
+### Binary Path & Install
+
+You can get the path of the `cloudflared` binary and install it using the `bin` and `install` functions, respectively.
+
+```js
+import { bin, install } from "cloudflared";
+import fs from "node:fs";
+import { spawn } from "node:child_process";
+
+if (!fs.existsSync(bin)) {
+  // install cloudflared binary
+  await install(bin);
+}
+
+// run cloudflared
+spawn(bin, ["--version"], { stdio: "inherit" });
+```
+
+- `bin`: The path of the binary.
+- `install`: A function that installs the binary to the given path.
+
+### Tunnel
+
+Checkout [`examples/tunnel.js`](examples/tunnel.js).
+
+`Tunnel` is inherited from `EventEmitter`, so you can listen to the events it emits, checkout [`examples/events.mjs`](examples/events.mjs).
+
+```js
+import { Tunnel } from "cloudflared";
+
+console.log("Cloudflared Tunnel Example.");
+main();
+
+async function main() {
+  // run: cloudflared tunnel --hello-world
+  const tunnel = Tunnel.quick();
+
+  // show the url
+  const url = new Promise((resolve) => tunnel.once("url", resolve));
+  console.log("LINK:", await url);
+
+  // wait for connection to be established
+  const conn = new Promise((resolve) => tunnel.once("connected", resolve));
+  console.log("CONN:", await conn);
+
+  // stop the tunnel after 15 seconds
+  setTimeout(tunnel.stop, 15_000);
+
+  tunnel.on("exit", (code) => {
+    console.log("tunnel process exited with code", code);
+  });
+}
+```
+
+```sh
+❯ node examples/tunnel.js
+Cloudflared Tunnel Example.
+LINK: https://mailto-davis-wilderness-facts.trycloudflare.com
+CONN: {
+  id: 'df1b8330-44ea-4ecb-bb93-8a32400f6d1c',
+  ip: '198.41.200.193',
+  location: 'tpe01'
+}
+tunnel process exited with code 0
+```
+
+### Service
+
+Checkout [`examples/service.js`](examples/service.js).
+
+```js
+import { service } from "cloudflared";
+
+console.log("Cloudflared Service Example.");
+main();
+
+async function main() {
+  if (service.exists()) {
+    console.log("Service is running.");
+    const current = service.current();
+    for (const { service, hostname } of current.config.ingress) {
+      console.log(`  - ${service} -> ${hostname}`);
+    }
+    console.log("metrics server:", current.metrics);
+  } else {
+    console.log("Service is not running.");
+  }
+}
+```
+
+```sh
+❯ node examples/service.js
+Cloudflared Service Example.
+Service is running.
+  - http://localhost:12345 -> sub.example.com
+  - http_status:404 -> undefined
+metrics server: 127.0.0.1:49177/metrics
+```
+
+NOTICE: On linux, service can only be installed and uninstalled by root.
+
+Run service test on linux: `sudo -E env "PATH=$PATH" pnpm test`

package/node_modules/cloudflared/lib/cloudflared.js

@@ -0,0 +1,10 @@
+#!/usr/bin/env node
+"use strict";
+var import_error = require("./error.js");
+var import_index = require("./index.js");
+(0, import_index.main)().catch((err) => {
+  if (err instanceof import_error.UnsupportedError) {
+    console.error(err.message);
+    process.exit(1);
+  }
+});

package/node_modules/cloudflared/lib/constants.js

@@ -0,0 +1,58 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var constants_exports = {};
+__export(constants_exports, {
+  CLOUDFLARED_VERSION: () => CLOUDFLARED_VERSION,
+  DEFAULT_CLOUDFLARED_BIN: () => DEFAULT_CLOUDFLARED_BIN,
+  RELEASE_BASE: () => RELEASE_BASE,
+  bin: () => bin,
+  use: () => use
+});
+module.exports = __toCommonJS(constants_exports);
+var import_node_path = __toESM(require("node:path"));
+const DEFAULT_CLOUDFLARED_BIN = import_node_path.default.join(
+  __dirname,
+  "..",
+  "bin",
+  process.platform === "win32" ? "cloudflared.exe" : "cloudflared"
+);
+let bin = process.env.CLOUDFLARED_BIN || DEFAULT_CLOUDFLARED_BIN;
+function use(executable) {
+  bin = executable;
+}
+const CLOUDFLARED_VERSION = process.env.CLOUDFLARED_VERSION || "latest";
+const RELEASE_BASE = "https://github.com/cloudflare/cloudflared/releases/";
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  CLOUDFLARED_VERSION,
+  DEFAULT_CLOUDFLARED_BIN,
+  RELEASE_BASE,
+  bin,
+  use
+});

package/node_modules/cloudflared/lib/error.js

@@ -0,0 +1,32 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var error_exports = {};
+__export(error_exports, {
+  UnsupportedError: () => UnsupportedError
+});
+module.exports = __toCommonJS(error_exports);
+class UnsupportedError extends Error {
+  constructor(message) {
+    super(message);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  UnsupportedError
+});

package/node_modules/cloudflared/lib/handler.js

@@ -0,0 +1,117 @@
+"use strict";
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var handler_exports = {};
+__export(handler_exports, {
+  ConfigHandler: () => ConfigHandler,
+  ConnectionHandler: () => ConnectionHandler,
+  TryCloudflareHandler: () => TryCloudflareHandler
+});
+module.exports = __toCommonJS(handler_exports);
+var import_node_stream = require("node:stream");
+var import_regex = require("./regex");
+class ConnectionHandler {
+  constructor(tunnel) {
+    this.connections = [];
+    this.connected_handler = (output, tunnel) => {
+      const conn_match = output.match(import_regex.conn_regex);
+      const ip_match = output.match(import_regex.ip_regex);
+      const location_match = output.match(import_regex.location_regex);
+      const index_match = output.match(import_regex.index_regex);
+      if (conn_match && ip_match && location_match && index_match) {
+        const connection = {
+          id: conn_match[1],
+          ip: ip_match[1],
+          location: location_match[1]
+        };
+        this.connections[Number(index_match[1])] = connection;
+        tunnel.emit("connected", connection);
+      }
+    };
+    this.disconnected_handler = (output, tunnel) => {
+      const index_match = output.includes("terminated") ? output.match(import_regex.index_regex) : null;
+      if (index_match) {
+        const index = Number(index_match[1]);
+        if (this.connections[index]) {
+          tunnel.emit("disconnected", this.connections[index]);
+          this.connections[index] = void 0;
+        }
+      }
+    };
+    tunnel.addHandler(this.connected_handler.bind(this));
+    tunnel.addHandler(this.disconnected_handler.bind(this));
+  }
+}
+class TryCloudflareHandler {
+  constructor(tunnel) {
+    this.url_handler = (output, tunnel) => {
+      const url_match = output.match(/https:\/\/([a-z0-9-]+)\.trycloudflare\.com/);
+      if (url_match) {
+        tunnel.emit("url", url_match[0]);
+      }
+    };
+    tunnel.addHandler(this.url_handler.bind(this));
+  }
+}
+class ConfigHandler extends import_node_stream.EventEmitter {
+  constructor(tunnel) {
+    super();
+    this.config_handler = (output, tunnel) => {
+      const config_match = output.match(/\bconfig="(.+?)" version=(\d+)/);
+      if (config_match) {
+        try {
+          const config_str = config_match[1].replace(/\\"/g, '"');
+          const config = JSON.parse(config_str);
+          const version = parseInt(config_match[2], 10);
+          this.emit("config", {
+            config,
+            version
+          });
+          if (config && typeof config === "object" && "ingress" in config && Array.isArray(config.ingress)) {
+            for (const ingress of config.ingress) {
+              if ("hostname" in ingress) {
+                tunnel.emit("url", ingress.hostname);
+              }
+            }
+          }
+        } catch (error) {
+          this.emit("error", new Error(`Failed to parse config: ${error}`));
+        }
+      }
+    };
+    tunnel.addHandler(this.config_handler.bind(this));
+  }
+  on(event, listener) {
+    return super.on(event, listener);
+  }
+  once(event, listener) {
+    return super.once(event, listener);
+  }
+  off(event, listener) {
+    return super.off(event, listener);
+  }
+  emit(event, ...args) {
+    return super.emit(event, ...args);
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  ConfigHandler,
+  ConnectionHandler,
+  TryCloudflareHandler
+});

package/node_modules/cloudflared/lib/index.js

@@ -0,0 +1,126 @@
+"use strict";
+var __create = Object.create;
+var __defProp = Object.defineProperty;
+var __getOwnPropDesc = Object.getOwnPropertyDescriptor;
+var __getOwnPropNames = Object.getOwnPropertyNames;
+var __getProtoOf = Object.getPrototypeOf;
+var __hasOwnProp = Object.prototype.hasOwnProperty;
+var __export = (target, all) => {
+  for (var name in all)
+    __defProp(target, name, { get: all[name], enumerable: true });
+};
+var __copyProps = (to, from, except, desc) => {
+  if (from && typeof from === "object" || typeof from === "function") {
+    for (let key of __getOwnPropNames(from))
+      if (!__hasOwnProp.call(to, key) && key !== except)
+        __defProp(to, key, { get: () => from[key], enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable });
+  }
+  return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(
+  // If the importer is in node compatibility mode or this is not an ESM
+  // file that has been converted to a CommonJS file using a Babel-
+  // compatible transform (i.e. "__esModule" has not been set), then set
+  // "default" to the CommonJS "module.exports" for node compatibility.
+  isNodeMode || !mod || !mod.__esModule ? __defProp(target, "default", { value: mod, enumerable: true }) : target,
+  mod
+));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var src_exports = {};
+__export(src_exports, {
+  main: () => main
+});
+module.exports = __toCommonJS(src_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_https = __toESM(require("node:https"));
+var import_node_child_process = require("node:child_process");
+var import_lib = require("./lib.js");
+var import_constants = require("./constants.js");
+async function main() {
+  const args = process.argv.slice(2);
+  if (args[0] === "bin") {
+    if (!args[1]) {
+      console.log(import_lib.bin);
+      return;
+    }
+    if (args[1] === "remove") {
+      import_node_fs.default.unlinkSync(import_lib.bin);
+      console.log("Removed cloudflared");
+      return;
+    }
+    if (args[1] === "install") {
+      const version = args[2] || import_constants.CLOUDFLARED_VERSION;
+      if (version !== "latest") {
+        console.log(`Installing cloudflared ${args[2]}`);
+        console.log(await (0, import_lib.install)(import_lib.bin, args[2]));
+      } else {
+        console.log("Installing latest version of cloudflared");
+        await (0, import_lib.install)(import_lib.bin, version);
+      }
+      return;
+    }
+    if (args[1] === "list") {
+      import_node_https.default.get(
+        {
+          hostname: "api.github.com",
+          path: "/repos/cloudflare/cloudflared/releases",
+          headers: {
+            "user-agent": "node-cloudflared"
+          }
+        },
+        (res) => {
+          let data = "";
+          res.on("data", (chunk) => {
+            data += chunk;
+          });
+          res.on("end", () => {
+            const releases = JSON.parse(data);
+            for (const release of releases) {
+              console.log(
+                `${release.tag_name.padEnd(10)} (${release.published_at}) [${release.html_url}]`
+              );
+            }
+          });
+        }
+      );
+      return;
+    }
+    if (args[1] === "help" || args[1] === "--help" || args[1] === "-h") {
+      console.log(`cloudflared bin                    : Prints the path to the binary`);
+      console.log(`cloudflared bin remove             : Removes the binary`);
+      console.log(`cloudflared bin install [version]  : Installs the binary`);
+      console.log(`cloudflared bin list               : Lists 30 latest releases`);
+      console.log(`cloudflared bin help               : Prints this help message`);
+      console.log(`Examples:`);
+      console.log(
+        `cloudflared bin install            : Installs the latest version of cloudflared`
+      );
+      console.log(`cloudflared bin install 2023.4.1   : Installs cloudflared 2023.4.1`);
+      console.log(
+        `You can find releases at https://github.com/cloudflare/cloudflared/releases`
+      );
+      return;
+    }
+  }
+  if (!import_node_fs.default.existsSync(import_lib.bin)) {
+    console.log("Installed cloudflared to " + await (0, import_lib.install)(import_lib.bin));
+  }
+  const sub = (0, import_node_child_process.spawn)(import_lib.bin, args, { stdio: "inherit" });
+  sub.on("exit", (code) => {
+    if (typeof code === "number") {
+      process.exit(code);
+    } else {
+      process.exit(1);
+    }
+  });
+  const signals = ["SIGINT", "SIGTERM", "SIGQUIT"];
+  for (const signal of signals) {
+    process.on(signal, () => {
+      sub.kill(signal);
+    });
+  }
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  main
+});