@silver886/mcp-proxy 0.2.0 → 0.2.2

package/node_modules/cloudflared/lib/install.js

@@ -0,0 +1,155 @@
+"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 install_exports = {};
+__export(install_exports, {
+  install: () => install,
+  install_linux: () => install_linux,
+  install_macos: () => install_macos,
+  install_windows: () => install_windows
+});
+module.exports = __toCommonJS(install_exports);
+var import_node_fs = __toESM(require("node:fs"));
+var import_node_path = __toESM(require("node:path"));
+var import_node_https = __toESM(require("node:https"));
+var import_node_child_process = require("node:child_process");
+var import_constants = require("./constants");
+var import_error = require("./error");
+const LINUX_URL = {
+  arm64: "cloudflared-linux-arm64",
+  arm: "cloudflared-linux-arm",
+  x64: "cloudflared-linux-amd64",
+  ia32: "cloudflared-linux-386"
+};
+const MACOS_URL = {
+  arm64: "cloudflared-darwin-arm64.tgz",
+  x64: "cloudflared-darwin-amd64.tgz"
+};
+const WINDOWS_URL = {
+  x64: "cloudflared-windows-amd64.exe",
+  ia32: "cloudflared-windows-386.exe"
+};
+function resolve_base(version) {
+  if (version === "latest") {
+    return `${import_constants.RELEASE_BASE}latest/download/`;
+  }
+  return `${import_constants.RELEASE_BASE}download/${version}/`;
+}
+async function install(to, version = import_constants.CLOUDFLARED_VERSION) {
+  if (process.platform === "linux") {
+    return install_linux(to, version);
+  } else if (process.platform === "darwin") {
+    return install_macos(to, version);
+  } else if (process.platform === "win32") {
+    return install_windows(to, version);
+  } else {
+    throw new import_error.UnsupportedError("Unsupported platform: " + process.platform);
+  }
+}
+async function install_linux(to, version = import_constants.CLOUDFLARED_VERSION) {
+  const file = LINUX_URL[process.arch];
+  if (file === void 0) {
+    throw new import_error.UnsupportedError("Unsupported architecture: " + process.arch);
+  }
+  await download(resolve_base(version) + file, to);
+  import_node_fs.default.chmodSync(to, "755");
+  return to;
+}
+async function install_macos(to, version = import_constants.CLOUDFLARED_VERSION) {
+  let arch = process.arch;
+  if (version !== "latest" && version_number(version) < 20240802) {
+    arch = "x64";
+  }
+  const file = MACOS_URL[arch];
+  if (file === void 0) {
+    throw new import_error.UnsupportedError("Unsupported architecture: " + arch);
+  }
+  await download(resolve_base(version) + file, `${to}.tgz`);
+  process.env.VERBOSE && console.log(`Extracting to ${to}`);
+  (0, import_node_child_process.execSync)(`tar -xzf ${import_node_path.default.basename(`${to}.tgz`)}`, { cwd: import_node_path.default.dirname(to) });
+  import_node_fs.default.unlinkSync(`${to}.tgz`);
+  import_node_fs.default.renameSync(`${import_node_path.default.dirname(to)}/cloudflared`, to);
+  return to;
+}
+async function install_windows(to, version = import_constants.CLOUDFLARED_VERSION) {
+  const file = WINDOWS_URL[process.arch];
+  if (file === void 0) {
+    throw new import_error.UnsupportedError("Unsupported architecture: " + process.arch);
+  }
+  await download(resolve_base(version) + file, to);
+  return to;
+}
+function download(url, to, redirect = 0) {
+  if (redirect === 0) {
+    process.env.VERBOSE && console.log(`Downloading ${url} to ${to}`);
+  } else {
+    process.env.VERBOSE && console.log(`Redirecting to ${url}`);
+  }
+  if (!import_node_fs.default.existsSync(import_node_path.default.dirname(to))) {
+    import_node_fs.default.mkdirSync(import_node_path.default.dirname(to), { recursive: true });
+  }
+  return new Promise((resolve, reject) => {
+    const request = import_node_https.default.get(url, (res) => {
+      const redirect_code = [301, 302, 303, 307, 308];
+      if (redirect_code.includes(res.statusCode) && res.headers.location !== void 0) {
+        request.destroy();
+        const redirection = res.headers.location;
+        resolve(download(redirection, to, redirect + 1));
+        return;
+      }
+      if (res.statusCode && res.statusCode >= 200 && res.statusCode < 300) {
+        const file = import_node_fs.default.createWriteStream(to);
+        file.on("finish", () => {
+          file.close(() => resolve(to));
+        });
+        file.on("error", (err) => {
+          import_node_fs.default.unlink(to, () => reject(err));
+        });
+        res.pipe(file);
+      } else {
+        request.destroy();
+        reject(new Error(`HTTP response with status code: ${res.statusCode}`));
+      }
+    });
+    request.on("error", (err) => {
+      reject(err);
+    });
+    request.end();
+  });
+}
+function version_number(semver) {
+  const [major, minor, patch] = semver.split(".").map(Number);
+  return major * 1e4 + minor * 100 + patch;
+}
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  install,
+  install_linux,
+  install_macos,
+  install_windows
+});

package/node_modules/cloudflared/lib/lib.d.ts

@@ -0,0 +1,236 @@
+import { ChildProcess } from 'node:child_process';
+import { EventEmitter } from 'node:events';
+import { EventEmitter as EventEmitter$1 } from 'node:stream';
+
+declare const DEFAULT_CLOUDFLARED_BIN: string;
+/**
+ * The path to the cloudflared binary.
+ * If the `CLOUDFLARED_BIN` environment variable is set, it will be used; otherwise, {@link DEFAULT_CLOUDFLARED_BIN} will be used.
+ * Can be overridden with {@link use}.
+ */
+declare let bin: string;
+/**
+ * Override the path to the cloudflared binary.
+ * @param executable - The path to the cloudflared executable.
+ */
+declare function use(executable: string): void;
+declare const CLOUDFLARED_VERSION: string;
+declare const RELEASE_BASE = "https://github.com/cloudflare/cloudflared/releases/";
+
+/**
+ * Install cloudflared to the given path.
+ * @param to The path to the binary to install.
+ * @param version The version of cloudflared to install.
+ * @returns The path to the binary that was installed.
+ */
+declare function install$1(to: string, version?: string): Promise<string>;
+declare function install_linux(to: string, version?: string): Promise<string>;
+declare function install_macos(to: string, version?: string): Promise<string>;
+declare function install_windows(to: string, version?: string): Promise<string>;
+
+interface Connection {
+    id: string;
+    ip: string;
+    location: string;
+}
+
+type TunnelOptions = Record<string, string | number | boolean>;
+interface TunnelEvents {
+    url: (url: string) => void;
+    connected: (connection: Connection) => void;
+    disconnected: (connection: Connection) => void;
+    stdout: (data: string) => void;
+    stderr: (data: string) => void;
+    error: (error: Error) => void;
+    exit: (code: number | null, signal: NodeJS.Signals | null) => void;
+}
+type OutputHandler = (output: string, tunnel: Tunnel) => void;
+declare class Tunnel extends EventEmitter {
+    private _process;
+    private outputHandlers;
+    constructor(options?: TunnelOptions | string[]);
+    get process(): ChildProcess;
+    private setupDefaultHandlers;
+    /**
+     * Add a custom output handler
+     * @param handler Function to handle cloudflared output
+     */
+    addHandler(handler: OutputHandler): void;
+    /**
+     * Remove a previously added output handler
+     * @param handler The handler to remove
+     */
+    removeHandler(handler: OutputHandler): void;
+    private processOutput;
+    private setupEventHandlers;
+    private createProcess;
+    stop: () => boolean;
+    private _stop;
+    on<E extends keyof TunnelEvents>(event: E, listener: TunnelEvents[E]): this;
+    once<E extends keyof TunnelEvents>(event: E, listener: TunnelEvents[E]): this;
+    off<E extends keyof TunnelEvents>(event: E, listener: TunnelEvents[E]): this;
+    emit<E extends keyof TunnelEvents>(event: E, ...args: Parameters<TunnelEvents[E]>): boolean;
+    /**
+     * Create a quick tunnel without a Cloudflare account.
+     * @param url The local service URL to connect to. If not provided, the hello world mode will be used.
+     * @param options The options to pass to cloudflared.
+     */
+    static quick(url?: string, options?: TunnelOptions): Tunnel;
+    /**
+     * Create a tunnel with a Cloudflare account.
+     * @param token The Cloudflare Tunnel token.
+     * @param options The options to pass to cloudflared.
+     */
+    static withToken(token: string, options?: TunnelOptions): Tunnel;
+}
+/**
+ * Create a tunnel.
+ * @param options The options to pass to cloudflared.
+ * @returns A Tunnel instance
+ */
+declare function tunnel(options?: TunnelOptions): Tunnel;
+/**
+ * Build the arguments for the cloudflared command.
+ * @param options The options to pass to cloudflared.
+ * @returns The arguments for the cloudflared command.
+ */
+declare function build_args(options: TunnelOptions): string[];
+declare function build_options(options: TunnelOptions): string[];
+
+/**
+ * Cloudflared launchd identifier.
+ * @platform macOS
+ */
+declare const identifier = "com.cloudflare.cloudflared";
+/**
+ * Path of service related files.
+ * @platform macOS
+ */
+declare const MACOS_SERVICE_PATH: {
+    readonly PLIST: string;
+    readonly OUT: string;
+    readonly ERR: string;
+};
+/**
+ * Cloudflared Service API.
+ */
+declare const service: {
+    install: typeof install;
+    uninstall: typeof uninstall;
+    exists: typeof exists;
+    log: typeof log;
+    err: typeof err;
+    current: typeof current;
+    clean: typeof clean;
+    journal: typeof journal;
+};
+/**
+ * Throw when service is already installed.
+ */
+declare class AlreadyInstalledError extends Error {
+    constructor();
+}
+/**
+ * Throw when service is not installed.
+ */
+declare class NotInstalledError extends Error {
+    constructor();
+}
+/**
+ * Install Cloudflared service.
+ * @param token Tunnel service token.
+ * @platform macOS, linux
+ */
+declare function install(token?: string): void;
+/**
+ * Uninstall Cloudflared service.
+ * @platform macOS, linux
+ */
+declare function uninstall(): void;
+/**
+ * Get stdout log of cloudflared service. (Usually empty)
+ * @returns stdout log of cloudflared service.
+ * @platform macOS, linux (sysv)
+ */
+declare function log(): string;
+/**
+ * Get stderr log of cloudflared service. (cloudflared print all things here)
+ * @returns stderr log of cloudflared service.
+ * @platform macOS, linux (sysv)
+ */
+declare function err(): string;
+/**
+ * Get cloudflared service journal from journalctl.
+ * @param n The number of entries to return.
+ * @returns cloudflared service journal.
+ * @platform linux (systemd)
+ */
+declare function journal(n?: number): string;
+/**
+ * Get informations of current running cloudflared service.
+ * @returns informations of current running cloudflared service.
+ * @platform macOS, linux
+ */
+declare function current(): {
+    /** Tunnel ID */
+    tunnelID: string;
+    /** Connector ID */
+    connectorID: string;
+    /** The connections of the tunnel */
+    connections: Connection[];
+    /** Metrics Server Location */
+    metrics: string;
+    /** Tunnel Configuration */
+    config: {
+        ingress?: {
+            service: string;
+            hostname?: string;
+        }[];
+        [key: string]: unknown;
+    };
+};
+/**
+ * Clean up service log files.
+ * @platform macOS
+ */
+declare function clean(): void;
+/**
+ * Check if cloudflared service is installed.
+ * @returns true if service is installed, false otherwise.
+ * @platform macOS, linux
+ */
+declare function exists(): boolean;
+
+declare class ConnectionHandler {
+    private connections;
+    constructor(tunnel: Tunnel);
+    private connected_handler;
+    private disconnected_handler;
+}
+declare class TryCloudflareHandler {
+    constructor(tunnel: Tunnel);
+    private url_handler;
+}
+interface ConfigHandlerEvents<T> {
+    config: (config: {
+        config: T;
+        version: number;
+    }) => void;
+    error: (error: Error) => void;
+}
+interface TunnelConfig {
+    ingress: Record<string, string>[];
+    warp_routing: {
+        enabled: boolean;
+    };
+}
+declare class ConfigHandler<T = TunnelConfig> extends EventEmitter$1 {
+    constructor(tunnel: Tunnel);
+    private config_handler;
+    on<E extends keyof ConfigHandlerEvents<T>>(event: E, listener: ConfigHandlerEvents<T>[E]): this;
+    once<E extends keyof ConfigHandlerEvents<T>>(event: E, listener: ConfigHandlerEvents<T>[E]): this;
+    off<E extends keyof ConfigHandlerEvents<T>>(event: E, listener: ConfigHandlerEvents<T>[E]): this;
+    emit<E extends keyof ConfigHandlerEvents<T>>(event: E, ...args: Parameters<ConfigHandlerEvents<T>[E]>): boolean;
+}
+
+export { AlreadyInstalledError, CLOUDFLARED_VERSION, ConfigHandler, type ConfigHandlerEvents, type Connection, ConnectionHandler, DEFAULT_CLOUDFLARED_BIN, MACOS_SERVICE_PATH, NotInstalledError, type OutputHandler, RELEASE_BASE, TryCloudflareHandler, Tunnel, type TunnelConfig, type TunnelEvents, type TunnelOptions, bin, build_args, build_options, identifier, install$1 as install, install_linux, install_macos, install_windows, service, tunnel, use };

package/node_modules/cloudflared/lib/lib.js

@@ -0,0 +1,45 @@
+"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 __reExport = (target, mod, secondTarget) => (__copyProps(target, mod, "default"), secondTarget && __copyProps(secondTarget, mod, "default"));
+var __toCommonJS = (mod) => __copyProps(__defProp({}, "__esModule", { value: true }), mod);
+var lib_exports = {};
+__export(lib_exports, {
+  AlreadyInstalledError: () => import_service.AlreadyInstalledError,
+  MACOS_SERVICE_PATH: () => import_service.MACOS_SERVICE_PATH,
+  NotInstalledError: () => import_service.NotInstalledError,
+  identifier: () => import_service.identifier,
+  service: () => import_service.service
+});
+module.exports = __toCommonJS(lib_exports);
+__reExport(lib_exports, require("./constants.js"), module.exports);
+__reExport(lib_exports, require("./install.js"), module.exports);
+__reExport(lib_exports, require("./tunnel.js"), module.exports);
+var import_service = require("./service.js");
+__reExport(lib_exports, require("./handler.js"), module.exports);
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  AlreadyInstalledError,
+  MACOS_SERVICE_PATH,
+  NotInstalledError,
+  identifier,
+  service,
+  ...require("./constants.js"),
+  ...require("./install.js"),
+  ...require("./tunnel.js"),
+  ...require("./handler.js")
+});

package/node_modules/cloudflared/lib/regex.js

@@ -0,0 +1,52 @@
+"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 regex_exports = {};
+__export(regex_exports, {
+  config_regex: () => config_regex,
+  conn_regex: () => conn_regex,
+  connectorID_regex: () => connectorID_regex,
+  disconnect_regex: () => disconnect_regex,
+  index_regex: () => index_regex,
+  ip_regex: () => ip_regex,
+  location_regex: () => location_regex,
+  metrics_regex: () => metrics_regex,
+  tunnelID_regex: () => tunnelID_regex
+});
+module.exports = __toCommonJS(regex_exports);
+const conn_regex = /connection[= ]([0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12})/i;
+const ip_regex = /ip=([0-9.]+)/;
+const location_regex = /location=([A-Za-z0-9]+)/;
+const index_regex = /connIndex=(\d)/;
+const disconnect_regex = /Unregistered tunnel connection connIndex=(\d)/i;
+const tunnelID_regex = /tunnelID=([0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12})/i;
+const connectorID_regex = /Connector ID: ([0-9a-f]{8}-[0-9a-f]{4}-4[0-9a-f]{3}-[0-9a-f]{4}-[0-9a-f]{12})/i;
+const metrics_regex = /metrics server on ([0-9.:]+\/metrics)/;
+const config_regex = /config="(.+[^\\])"/;
+// Annotate the CommonJS export names for ESM import in node:
+0 && (module.exports = {
+  config_regex,
+  conn_regex,
+  connectorID_regex,
+  disconnect_regex,
+  index_regex,
+  ip_regex,
+  location_regex,
+  metrics_regex,
+  tunnelID_regex
+});