@mcp-z/client 1.0.0

package/dist/cjs/connection/existing-process-transport.js

@@ -0,0 +1,274 @@
+/**
+ * existing-process-transport.ts
+ *
+ * MCP transport that wraps an existing child process for stdio communication.
+ * Used when connecting to servers already spawned by initServers().
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+Object.defineProperty(exports, "ExistingProcessTransport", {
+    enumerable: true,
+    get: function() {
+        return ExistingProcessTransport;
+    }
+});
+var _stdio = require("@modelcontextprotocol/sdk/shared/stdio.js");
+function asyncGeneratorStep(gen, resolve, reject, _next, _throw, key, arg) {
+    try {
+        var info = gen[key](arg);
+        var value = info.value;
+    } catch (error) {
+        reject(error);
+        return;
+    }
+    if (info.done) {
+        resolve(value);
+    } else {
+        Promise.resolve(value).then(_next, _throw);
+    }
+}
+function _async_to_generator(fn) {
+    return function() {
+        var self = this, args = arguments;
+        return new Promise(function(resolve, reject) {
+            var gen = fn.apply(self, args);
+            function _next(value) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "next", value);
+            }
+            function _throw(err) {
+                asyncGeneratorStep(gen, resolve, reject, _next, _throw, "throw", err);
+            }
+            _next(undefined);
+        });
+    };
+}
+function _class_call_check(instance, Constructor) {
+    if (!(instance instanceof Constructor)) {
+        throw new TypeError("Cannot call a class as a function");
+    }
+}
+function _ts_generator(thisArg, body) {
+    var f, y, t, _ = {
+        label: 0,
+        sent: function() {
+            if (t[0] & 1) throw t[1];
+            return t[1];
+        },
+        trys: [],
+        ops: []
+    }, g = Object.create((typeof Iterator === "function" ? Iterator : Object).prototype), d = Object.defineProperty;
+    return d(g, "next", {
+        value: verb(0)
+    }), d(g, "throw", {
+        value: verb(1)
+    }), d(g, "return", {
+        value: verb(2)
+    }), typeof Symbol === "function" && d(g, Symbol.iterator, {
+        value: function() {
+            return this;
+        }
+    }), g;
+    function verb(n) {
+        return function(v) {
+            return step([
+                n,
+                v
+            ]);
+        };
+    }
+    function step(op) {
+        if (f) throw new TypeError("Generator is already executing.");
+        while(g && (g = 0, op[0] && (_ = 0)), _)try {
+            if (f = 1, y && (t = op[0] & 2 ? y["return"] : op[0] ? y["throw"] || ((t = y["return"]) && t.call(y), 0) : y.next) && !(t = t.call(y, op[1])).done) return t;
+            if (y = 0, t) op = [
+                op[0] & 2,
+                t.value
+            ];
+            switch(op[0]){
+                case 0:
+                case 1:
+                    t = op;
+                    break;
+                case 4:
+                    _.label++;
+                    return {
+                        value: op[1],
+                        done: false
+                    };
+                case 5:
+                    _.label++;
+                    y = op[1];
+                    op = [
+                        0
+                    ];
+                    continue;
+                case 7:
+                    op = _.ops.pop();
+                    _.trys.pop();
+                    continue;
+                default:
+                    if (!(t = _.trys, t = t.length > 0 && t[t.length - 1]) && (op[0] === 6 || op[0] === 2)) {
+                        _ = 0;
+                        continue;
+                    }
+                    if (op[0] === 3 && (!t || op[1] > t[0] && op[1] < t[3])) {
+                        _.label = op[1];
+                        break;
+                    }
+                    if (op[0] === 6 && _.label < t[1]) {
+                        _.label = t[1];
+                        t = op;
+                        break;
+                    }
+                    if (t && _.label < t[2]) {
+                        _.label = t[2];
+                        _.ops.push(op);
+                        break;
+                    }
+                    if (t[2]) _.ops.pop();
+                    _.trys.pop();
+                    continue;
+            }
+            op = body.call(thisArg, _);
+        } catch (e) {
+            op = [
+                6,
+                e
+            ];
+            y = 0;
+        } finally{
+            f = t = 0;
+        }
+        if (op[0] & 5) throw op[1];
+        return {
+            value: op[0] ? op[1] : void 0,
+            done: true
+        };
+    }
+}
+var ExistingProcessTransport = /*#__PURE__*/ function() {
+    "use strict";
+    function ExistingProcessTransport(process) {
+        _class_call_check(this, ExistingProcessTransport);
+        this._dataHandler = null;
+        this._errorHandler = null;
+        if (!process.stdin || !process.stdout) {
+            throw new Error('Child process must have stdin and stdout pipes');
+        }
+        this._process = process;
+        this._readBuffer = new _stdio.ReadBuffer();
+    }
+    var _proto = ExistingProcessTransport.prototype;
+    /**
+   * Start the transport - sets up stdio listeners on existing process.
+   */ _proto.start = function start() {
+        return _async_to_generator(function() {
+            var _this;
+            return _ts_generator(this, function(_state) {
+                _this = this;
+                return [
+                    2,
+                    new Promise(function(resolve, reject) {
+                        var // Listen for stdout data (MCP messages)
+                        _this__process_stdout, _this__process_stdout1, _this__process_stdin;
+                        // Listen for process events
+                        _this._process.on('error', function(error) {
+                            var _this_onerror, _this1;
+                            (_this_onerror = (_this1 = _this).onerror) === null || _this_onerror === void 0 ? void 0 : _this_onerror.call(_this1, error);
+                            reject(error);
+                        });
+                        _this._process.on('close', function() {
+                            var _this_onclose, _this1;
+                            (_this_onclose = (_this1 = _this).onclose) === null || _this_onclose === void 0 ? void 0 : _this_onclose.call(_this1);
+                        });
+                        // Create and save data handler for close
+                        _this._dataHandler = function(chunk) {
+                            _this._readBuffer.append(chunk);
+                            _this.processReadBuffer();
+                        };
+                        // Create and save error handler for close
+                        _this._errorHandler = function(error) {
+                            var _this_onerror, _this1;
+                            (_this_onerror = (_this1 = _this).onerror) === null || _this_onerror === void 0 ? void 0 : _this_onerror.call(_this1, error);
+                        };
+                        (_this__process_stdout = _this._process.stdout) === null || _this__process_stdout === void 0 ? void 0 : _this__process_stdout.on('data', _this._dataHandler);
+                        (_this__process_stdout1 = _this._process.stdout) === null || _this__process_stdout1 === void 0 ? void 0 : _this__process_stdout1.on('error', _this._errorHandler);
+                        (_this__process_stdin = _this._process.stdin) === null || _this__process_stdin === void 0 ? void 0 : _this__process_stdin.on('error', _this._errorHandler);
+                        // Process is already running - resolve immediately
+                        resolve();
+                    })
+                ];
+            });
+        }).call(this);
+    };
+    /**
+   * Process buffered messages from stdout.
+   */ _proto.processReadBuffer = function processReadBuffer() {
+        while(true){
+            try {
+                var _this_onmessage, _this;
+                var message = this._readBuffer.readMessage();
+                if (message === null) {
+                    break;
+                }
+                (_this_onmessage = (_this = this).onmessage) === null || _this_onmessage === void 0 ? void 0 : _this_onmessage.call(_this, message);
+            } catch (error) {
+                var _this_onerror, _this1;
+                (_this_onerror = (_this1 = this).onerror) === null || _this_onerror === void 0 ? void 0 : _this_onerror.call(_this1, error);
+            }
+        }
+    };
+    /**
+   * Close the transport - close without killing the shared process.
+   * The process is managed by the cluster and may have other active connections.
+   */ _proto.close = function close() {
+        return _async_to_generator(function() {
+            var _this__process_stdout, _this__process_stdout1, _this__process_stdin;
+            return _ts_generator(this, function(_state) {
+                if (this._dataHandler) {
+                    ;
+                    (_this__process_stdout = this._process.stdout) === null || _this__process_stdout === void 0 ? void 0 : _this__process_stdout.off('data', this._dataHandler);
+                    this._dataHandler = null;
+                }
+                if (this._errorHandler) {
+                    ;
+                    (_this__process_stdout1 = this._process.stdout) === null || _this__process_stdout1 === void 0 ? void 0 : _this__process_stdout1.off('error', this._errorHandler);
+                    (_this__process_stdin = this._process.stdin) === null || _this__process_stdin === void 0 ? void 0 : _this__process_stdin.off('error', this._errorHandler);
+                    this._errorHandler = null;
+                }
+                this._readBuffer.clear();
+                return [
+                    2
+                ];
+            });
+        }).call(this);
+    };
+    /**
+   * Send a message to the server via stdin.
+   */ _proto.send = function send(message) {
+        return _async_to_generator(function() {
+            var _this;
+            return _ts_generator(this, function(_state) {
+                _this = this;
+                return [
+                    2,
+                    new Promise(function(resolve, reject) {
+                        if (!_this._process.stdin) {
+                            reject(new Error('stdin is not available'));
+                            return;
+                        }
+                        var json = (0, _stdio.serializeMessage)(message);
+                        if (_this._process.stdin.write(json)) {
+                            resolve();
+                        } else {
+                            _this._process.stdin.once('drain', resolve);
+                        }
+                    })
+                ];
+            });
+        }).call(this);
+    };
+    return ExistingProcessTransport;
+}();
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/connection/existing-process-transport.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/libs/client/src/connection/existing-process-transport.ts"],"sourcesContent":["/**\n * existing-process-transport.ts\n *\n * MCP transport that wraps an existing child process for stdio communication.\n * Used when connecting to servers already spawned by initServers().\n */\n\nimport { ReadBuffer, serializeMessage } from '@modelcontextprotocol/sdk/shared/stdio.js';\nimport type { Transport } from '@modelcontextprotocol/sdk/shared/transport.js';\nimport type { JSONRPCMessage } from '@modelcontextprotocol/sdk/types.js';\nimport type { ChildProcess } from 'child_process';\n\n/**\n * Transport that communicates with an existing child process via stdio.\n * Does NOT spawn a new process - uses the one provided.\n */\nexport class ExistingProcessTransport implements Transport {\n  private _process: ChildProcess;\n  private _readBuffer: ReadBuffer;\n  private _dataHandler: ((chunk: Buffer) => void) | null = null;\n  private _errorHandler: ((error: Error) => void) | null = null;\n\n  // Transport interface callbacks\n  onclose?: () => void;\n  onerror?: (error: Error) => void;\n  onmessage?: (message: JSONRPCMessage) => void;\n\n  constructor(process: ChildProcess) {\n    if (!process.stdin || !process.stdout) {\n      throw new Error('Child process must have stdin and stdout pipes');\n    }\n\n    this._process = process;\n    this._readBuffer = new ReadBuffer();\n  }\n\n  /**\n   * Start the transport - sets up stdio listeners on existing process.\n   */\n  async start(): Promise<void> {\n    return new Promise((resolve, reject) => {\n      // Listen for process events\n      this._process.on('error', (error) => {\n        this.onerror?.(error);\n        reject(error);\n      });\n\n      this._process.on('close', () => {\n        this.onclose?.();\n      });\n\n      // Create and save data handler for close\n      this._dataHandler = (chunk: Buffer) => {\n        this._readBuffer.append(chunk);\n        this.processReadBuffer();\n      };\n\n      // Create and save error handler for close\n      this._errorHandler = (error: Error) => {\n        this.onerror?.(error);\n      };\n\n      // Listen for stdout data (MCP messages)\n      this._process.stdout?.on('data', this._dataHandler);\n      this._process.stdout?.on('error', this._errorHandler);\n      this._process.stdin?.on('error', this._errorHandler);\n\n      // Process is already running - resolve immediately\n      resolve();\n    });\n  }\n\n  /**\n   * Process buffered messages from stdout.\n   */\n  private processReadBuffer(): void {\n    while (true) {\n      try {\n        const message = this._readBuffer.readMessage();\n        if (message === null) {\n          break;\n        }\n        this.onmessage?.(message);\n      } catch (error) {\n        this.onerror?.(error as Error);\n      }\n    }\n  }\n\n  /**\n   * Close the transport - close without killing the shared process.\n   * The process is managed by the cluster and may have other active connections.\n   */\n  async close(): Promise<void> {\n    if (this._dataHandler) {\n      this._process.stdout?.off('data', this._dataHandler);\n      this._dataHandler = null;\n    }\n\n    if (this._errorHandler) {\n      this._process.stdout?.off('error', this._errorHandler);\n      this._process.stdin?.off('error', this._errorHandler);\n      this._errorHandler = null;\n    }\n\n    this._readBuffer.clear();\n  }\n\n  /**\n   * Send a message to the server via stdin.\n   */\n  async send(message: JSONRPCMessage): Promise<void> {\n    return new Promise((resolve, reject) => {\n      if (!this._process.stdin) {\n        reject(new Error('stdin is not available'));\n        return;\n      }\n\n      const json = serializeMessage(message);\n\n      if (this._process.stdin.write(json)) {\n        resolve();\n      } else {\n        this._process.stdin.once('drain', resolve);\n      }\n    });\n  }\n}\n"],"names":["ExistingProcessTransport","process","_dataHandler","_errorHandler","stdin","stdout","Error","_process","_readBuffer","ReadBuffer","start","Promise","resolve","reject","on","error","onerror","onclose","chunk","append","processReadBuffer","message","readMessage","onmessage","close","off","clear","send","json","serializeMessage","write","once"],"mappings":"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"}

package/dist/cjs/connection/types.d.cts

@@ -0,0 +1,61 @@
+/**
+ * Type definitions and type guards for CLI
+ * Per project convention, all types and runtime validators in single file
+ */
+/**
+ * JSON-serializable value type per MCP spec
+ * Used for tool arguments and responses
+ */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/**
+ * Tool arguments must be JSON-serializable
+ */
+export type ToolArguments = Record<string, JsonValue>;
+/**
+ * Spawn metadata for logging and sanitization
+ */
+export interface SpawnMetadata {
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    pid?: number;
+    [key: string]: JsonValue;
+}
+/**
+ * MCP prompt argument structure
+ * Explicit undefined for exactOptionalPropertyTypes compatibility
+ */
+export interface PromptArgument {
+    name: string;
+    description?: string | undefined;
+    required?: boolean | undefined;
+}
+/**
+ * Parsed MCP response structure
+ */
+export interface ParsedResponse {
+    result?: JsonValue;
+}
+/**
+ * Result object structure for error detection
+ */
+export interface ResultObject {
+    type?: string;
+    error?: string;
+    message?: string;
+}
+/**
+ * Type guard for JSON-serializable values
+ */
+export declare function isJsonValue(value: unknown): value is JsonValue;
+/**
+ * Type guard for parsed MCP response
+ */
+export declare function isParsedResponse(value: unknown): value is ParsedResponse;
+/**
+ * Type guard for result object
+ */
+export declare function isResultObject(value: unknown): value is ResultObject;

package/dist/cjs/connection/types.d.ts

@@ -0,0 +1,61 @@
+/**
+ * Type definitions and type guards for CLI
+ * Per project convention, all types and runtime validators in single file
+ */
+/**
+ * JSON-serializable value type per MCP spec
+ * Used for tool arguments and responses
+ */
+export type JsonValue = string | number | boolean | null | JsonValue[] | {
+    [key: string]: JsonValue;
+};
+/**
+ * Tool arguments must be JSON-serializable
+ */
+export type ToolArguments = Record<string, JsonValue>;
+/**
+ * Spawn metadata for logging and sanitization
+ */
+export interface SpawnMetadata {
+    command?: string;
+    args?: string[];
+    env?: Record<string, string>;
+    cwd?: string;
+    pid?: number;
+    [key: string]: JsonValue;
+}
+/**
+ * MCP prompt argument structure
+ * Explicit undefined for exactOptionalPropertyTypes compatibility
+ */
+export interface PromptArgument {
+    name: string;
+    description?: string | undefined;
+    required?: boolean | undefined;
+}
+/**
+ * Parsed MCP response structure
+ */
+export interface ParsedResponse {
+    result?: JsonValue;
+}
+/**
+ * Result object structure for error detection
+ */
+export interface ResultObject {
+    type?: string;
+    error?: string;
+    message?: string;
+}
+/**
+ * Type guard for JSON-serializable values
+ */
+export declare function isJsonValue(value: unknown): value is JsonValue;
+/**
+ * Type guard for parsed MCP response
+ */
+export declare function isParsedResponse(value: unknown): value is ParsedResponse;
+/**
+ * Type guard for result object
+ */
+export declare function isResultObject(value: unknown): value is ResultObject;

package/dist/cjs/connection/types.js

@@ -0,0 +1,53 @@
+/**
+ * Type definitions and type guards for CLI
+ * Per project convention, all types and runtime validators in single file
+ */ /**
+ * JSON-serializable value type per MCP spec
+ * Used for tool arguments and responses
+ */ "use strict";
+Object.defineProperty(exports, "__esModule", {
+    value: true
+});
+function _export(target, all) {
+    for(var name in all)Object.defineProperty(target, name, {
+        enumerable: true,
+        get: Object.getOwnPropertyDescriptor(all, name).get
+    });
+}
+_export(exports, {
+    get isJsonValue () {
+        return isJsonValue;
+    },
+    get isParsedResponse () {
+        return isParsedResponse;
+    },
+    get isResultObject () {
+        return isResultObject;
+    }
+});
+function _type_of(obj) {
+    "@swc/helpers - typeof";
+    return obj && typeof Symbol !== "undefined" && obj.constructor === Symbol ? "symbol" : typeof obj;
+}
+function isJsonValue(value) {
+    if (value === null) return true;
+    if (typeof value === 'string') return true;
+    if (typeof value === 'number') return true;
+    if (typeof value === 'boolean') return true;
+    if (Array.isArray(value)) {
+        return value.every(isJsonValue);
+    }
+    if ((typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object') {
+        return Object.values(value).every(isJsonValue);
+    }
+    return false;
+}
+function isParsedResponse(value) {
+    return (typeof value === "undefined" ? "undefined" : _type_of(value)) === 'object' && value !== null && 'result' in value;
+}
+function isResultObject(value) {
+    if ((typeof value === "undefined" ? "undefined" : _type_of(value)) !== 'object' || value === null) return false;
+    var obj = value;
+    return (obj.type === undefined || typeof obj.type === 'string') && (obj.error === undefined || typeof obj.error === 'string') && (obj.message === undefined || typeof obj.message === 'string');
+}
+/* CJS INTEROP */ if (exports.__esModule && exports.default) { try { Object.defineProperty(exports.default, '__esModule', { value: true }); for (var key in exports) { exports.default[key] = exports[key]; } } catch (_) {}; module.exports = exports.default; }

package/dist/cjs/connection/types.js.map

@@ -0,0 +1 @@
+{"version":3,"sources":["/Users/kevin/Dev/Projects/ai/mcp-z/libs/client/src/connection/types.ts"],"sourcesContent":["/**\n * Type definitions and type guards for CLI\n * Per project convention, all types and runtime validators in single file\n */\n\n/**\n * JSON-serializable value type per MCP spec\n * Used for tool arguments and responses\n */\nexport type JsonValue = string | number | boolean | null | JsonValue[] | { [key: string]: JsonValue };\n\n/**\n * Tool arguments must be JSON-serializable\n */\nexport type ToolArguments = Record<string, JsonValue>;\n\n/**\n * Spawn metadata for logging and sanitization\n */\nexport interface SpawnMetadata {\n  command?: string;\n  args?: string[];\n  env?: Record<string, string>;\n  cwd?: string;\n  pid?: number;\n  [key: string]: JsonValue;\n}\n\n/**\n * MCP prompt argument structure\n * Explicit undefined for exactOptionalPropertyTypes compatibility\n */\nexport interface PromptArgument {\n  name: string;\n  description?: string | undefined;\n  required?: boolean | undefined;\n}\n\n/**\n * Parsed MCP response structure\n */\nexport interface ParsedResponse {\n  result?: JsonValue;\n}\n\n/**\n * Result object structure for error detection\n */\nexport interface ResultObject {\n  type?: string;\n  error?: string;\n  message?: string;\n}\n\n// Type Guards (runtime validation functions)\n\n/**\n * Type guard for JSON-serializable values\n */\nexport function isJsonValue(value: unknown): value is JsonValue {\n  if (value === null) return true;\n  if (typeof value === 'string') return true;\n  if (typeof value === 'number') return true;\n  if (typeof value === 'boolean') return true;\n\n  if (Array.isArray(value)) {\n    return value.every(isJsonValue);\n  }\n\n  if (typeof value === 'object') {\n    return Object.values(value).every(isJsonValue);\n  }\n\n  return false;\n}\n\n/**\n * Type guard for parsed MCP response\n */\nexport function isParsedResponse(value: unknown): value is ParsedResponse {\n  return typeof value === 'object' && value !== null && 'result' in value;\n}\n\n/**\n * Type guard for result object\n */\nexport function isResultObject(value: unknown): value is ResultObject {\n  if (typeof value !== 'object' || value === null) return false;\n  const obj = value as Record<string, unknown>;\n  return (obj.type === undefined || typeof obj.type === 'string') && (obj.error === undefined || typeof obj.error === 'string') && (obj.message === undefined || typeof obj.message === 'string');\n}\n"],"names":["isJsonValue","isParsedResponse","isResultObject","value","Array","isArray","every","Object","values","obj","type","undefined","error","message"],"mappings":"AAAA;;;CAGC,GAED;;;CAGC;;;;;;;;;;;QAmDeA;eAAAA;;QAoBAC;eAAAA;;QAOAC;eAAAA;;;;;;;AA3BT,SAASF,YAAYG,KAAc;IACxC,IAAIA,UAAU,MAAM,OAAO;IAC3B,IAAI,OAAOA,UAAU,UAAU,OAAO;IACtC,IAAI,OAAOA,UAAU,UAAU,OAAO;IACtC,IAAI,OAAOA,UAAU,WAAW,OAAO;IAEvC,IAAIC,MAAMC,OAAO,CAACF,QAAQ;QACxB,OAAOA,MAAMG,KAAK,CAACN;IACrB;IAEA,IAAI,CAAA,OAAOG,sCAAP,SAAOA,MAAI,MAAM,UAAU;QAC7B,OAAOI,OAAOC,MAAM,CAACL,OAAOG,KAAK,CAACN;IACpC;IAEA,OAAO;AACT;AAKO,SAASC,iBAAiBE,KAAc;IAC7C,OAAO,CAAA,OAAOA,sCAAP,SAAOA,MAAI,MAAM,YAAYA,UAAU,QAAQ,YAAYA;AACpE;AAKO,SAASD,eAAeC,KAAc;IAC3C,IAAI,CAAA,OAAOA,sCAAP,SAAOA,MAAI,MAAM,YAAYA,UAAU,MAAM,OAAO;IACxD,IAAMM,MAAMN;IACZ,OAAO,AAACM,CAAAA,IAAIC,IAAI,KAAKC,aAAa,OAAOF,IAAIC,IAAI,KAAK,QAAO,KAAOD,CAAAA,IAAIG,KAAK,KAAKD,aAAa,OAAOF,IAAIG,KAAK,KAAK,QAAO,KAAOH,CAAAA,IAAII,OAAO,KAAKF,aAAa,OAAOF,IAAII,OAAO,KAAK,QAAO;AAC/L"}

package/dist/cjs/connection/wait-for-http-ready.d.cts

@@ -0,0 +1,15 @@
+/**
+ * wait-for-http-ready.ts
+ *
+ * Utility for waiting for HTTP servers to become ready.
+ */
+/**
+ * Wait for HTTP server to be ready by checking endpoint accessibility.
+ * Used to handle HTTP servers that need time to start listening.
+ *
+ * @param url - URL to check for server readiness
+ * @param timeoutMs - Maximum time to wait in milliseconds (default: 30000)
+ * @returns Promise that resolves when server is ready
+ * @throws Error if server doesn't become ready within timeout
+ */
+export declare function waitForHttpReady(url: string, timeoutMs?: number): Promise<void>;

package/dist/cjs/connection/wait-for-http-ready.d.ts

@@ -0,0 +1,15 @@
+/**
+ * wait-for-http-ready.ts
+ *
+ * Utility for waiting for HTTP servers to become ready.
+ */
+/**
+ * Wait for HTTP server to be ready by checking endpoint accessibility.
+ * Used to handle HTTP servers that need time to start listening.
+ *
+ * @param url - URL to check for server readiness
+ * @param timeoutMs - Maximum time to wait in milliseconds (default: 30000)
+ * @returns Promise that resolves when server is ready
+ * @throws Error if server doesn't become ready within timeout
+ */
+export declare function waitForHttpReady(url: string, timeoutMs?: number): Promise<void>;