@noodleseed/one 0.95.2 → 0.96.1

package/node_modules/@modelcontextprotocol/client/dist/stdio.cjs

@@ -0,0 +1,217 @@
+const require_chunk = require('./chunk-Bnu9O96Y.cjs');
+const require_src = require('./src-NAgB4Mp8.cjs');
+let node_process = require("node:process");
+node_process = require_chunk.__toESM(node_process);
+let node_stream = require("node:stream");
+let cross_spawn = require("cross-spawn");
+cross_spawn = require_chunk.__toESM(cross_spawn);
+
+//#region src/client/stdio.ts
+/**
+* Environment variables to inherit by default, if an environment is not explicitly given.
+*/
+const DEFAULT_INHERITED_ENV_VARS = node_process.default.platform === "win32" ? [
+	"APPDATA",
+	"HOMEDRIVE",
+	"HOMEPATH",
+	"LOCALAPPDATA",
+	"PATH",
+	"PROCESSOR_ARCHITECTURE",
+	"SYSTEMDRIVE",
+	"SYSTEMROOT",
+	"TEMP",
+	"USERNAME",
+	"USERPROFILE",
+	"PROGRAMFILES"
+] : [
+	"HOME",
+	"LOGNAME",
+	"PATH",
+	"SHELL",
+	"TERM",
+	"USER"
+];
+/**
+* Returns a default environment object including only environment variables deemed safe to inherit.
+*/
+function getDefaultEnvironment() {
+	const env = {};
+	for (const key of DEFAULT_INHERITED_ENV_VARS) {
+		const value = node_process.default.env[key];
+		if (value === void 0) continue;
+		if (value.startsWith("()")) continue;
+		env[key] = value;
+	}
+	return env;
+}
+/**
+* Client transport for stdio: this will connect to a server by spawning a process and communicating with it over stdin/stdout.
+*
+* This transport is only available in Node.js environments.
+*/
+var StdioClientTransport = class {
+	_process;
+	_readBuffer;
+	_serverParams;
+	_stderrStream = null;
+	onclose;
+	onerror;
+	onmessage;
+	constructor(server) {
+		this._serverParams = server;
+		this._readBuffer = new require_src.ReadBuffer({ maxBufferSize: server.maxBufferSize });
+		if (server.stderr === "pipe" || server.stderr === "overlapped") this._stderrStream = new node_stream.PassThrough();
+	}
+	/**
+	* Starts the server process and prepares to communicate with it.
+	*/
+	async start() {
+		if (this._process) throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+		return new Promise((resolve, reject) => {
+			this._process = (0, cross_spawn.default)(this._serverParams.command, this._serverParams.args ?? [], {
+				env: {
+					...getDefaultEnvironment(),
+					...this._serverParams.env
+				},
+				stdio: [
+					"pipe",
+					"pipe",
+					this._serverParams.stderr ?? "inherit"
+				],
+				shell: false,
+				windowsHide: node_process.default.platform === "win32",
+				cwd: this._serverParams.cwd
+			});
+			this._process.on("error", (error) => {
+				reject(error);
+				this.onerror?.(error);
+			});
+			this._process.on("spawn", () => {
+				resolve();
+			});
+			this._process.on("close", (_code) => {
+				this._process = void 0;
+				this.onclose?.();
+			});
+			this._process.stdin?.on("error", (error) => {
+				this.onerror?.(error);
+			});
+			this._process.stdout?.on("data", (chunk) => {
+				try {
+					this._readBuffer.append(chunk);
+					this.processReadBuffer();
+				} catch (error) {
+					this.onerror?.(error);
+					this.close().catch(() => {});
+				}
+			});
+			this._process.stdout?.on("error", (error) => {
+				this.onerror?.(error);
+			});
+			if (this._stderrStream && this._process.stderr) this._process.stderr.pipe(this._stderrStream);
+		});
+	}
+	/**
+	* The `stderr` stream of the child process, if {@linkcode StdioServerParameters.stderr} was set to `"pipe"` or `"overlapped"`.
+	*
+	* If `stderr` piping was requested, a `PassThrough` stream is returned _immediately_, allowing callers to
+	* attach listeners before the `start` method is invoked. This prevents loss of any early
+	* error output emitted by the child process.
+	*/
+	get stderr() {
+		if (this._stderrStream) return this._stderrStream;
+		return this._process?.stderr ?? null;
+	}
+	/**
+	* The child process pid spawned by this transport.
+	*
+	* This is only available after the transport has been started.
+	*/
+	get pid() {
+		return this._process?.pid ?? null;
+	}
+	processReadBuffer() {
+		while (true) try {
+			const message = this._readBuffer.readMessage();
+			if (message === null) break;
+			this.onmessage?.(message);
+		} catch (error) {
+			this.onerror?.(error);
+		}
+	}
+	/**
+	* Reap a disposable probe sibling (see the version-negotiation sibling
+	* flow): signal-first teardown awaiting process `exit` — never the `close`
+	* event, so a helper process holding the child's stdio pipes can never
+	* block disposal. Not part of the public transport lifecycle.
+	*
+	* @internal
+	*/
+	async _dispose() {
+		const proc = this._process;
+		this._process = void 0;
+		if (proc && proc.exitCode === null && proc.signalCode === null) {
+			const exited = new Promise((resolve) => proc.once("exit", () => resolve()));
+			try {
+				proc.stdin?.end();
+			} catch {}
+			try {
+				proc.kill("SIGTERM");
+			} catch {}
+			await Promise.race([exited, new Promise((resolve) => setTimeout(resolve, 1e3).unref())]);
+			if (proc.exitCode === null && proc.signalCode === null) try {
+				proc.kill("SIGKILL");
+			} catch {}
+			await exited;
+		}
+		try {
+			proc?.stdout?.destroy();
+		} catch {}
+		try {
+			proc?.stdin?.destroy();
+		} catch {}
+		try {
+			proc?.stderr?.destroy();
+		} catch {}
+		this._readBuffer.clear();
+	}
+	async close() {
+		if (this._process) {
+			const processToClose = this._process;
+			this._process = void 0;
+			const closePromise = new Promise((resolve) => {
+				processToClose.once("close", () => {
+					resolve();
+				});
+			});
+			try {
+				processToClose.stdin?.end();
+			} catch {}
+			await Promise.race([closePromise, new Promise((resolve) => setTimeout(resolve, 2e3).unref())]);
+			if (processToClose.exitCode === null) {
+				try {
+					processToClose.kill("SIGTERM");
+				} catch {}
+				await Promise.race([closePromise, new Promise((resolve) => setTimeout(resolve, 2e3).unref())]);
+			}
+			if (processToClose.exitCode === null) try {
+				processToClose.kill("SIGKILL");
+			} catch {}
+		}
+		this._readBuffer.clear();
+	}
+	send(message) {
+		return new Promise((resolve) => {
+			if (!this._process?.stdin) throw new require_src.SdkError(require_src.SdkErrorCode.NotConnected, "Not connected");
+			const json = require_src.serializeMessage(message);
+			if (this._process.stdin.write(json)) resolve();
+			else this._process.stdin.once("drain", resolve);
+		});
+	}
+};
+
+//#endregion
+exports.DEFAULT_INHERITED_ENV_VARS = DEFAULT_INHERITED_ENV_VARS;
+exports.StdioClientTransport = StdioClientTransport;
+exports.getDefaultEnvironment = getDefaultEnvironment;
+//# sourceMappingURL=stdio.cjs.map

package/node_modules/@modelcontextprotocol/client/dist/stdio.cjs.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.cjs","names":["process","env: Record<string, string>","ReadBuffer","PassThrough","SdkError","SdkErrorCode","serializeMessage"],"sources":["../src/client/stdio.ts"],"sourcesContent":["import type { ChildProcess, IOType } from 'node:child_process';\nimport process from 'node:process';\nimport type { Stream } from 'node:stream';\nimport { PassThrough } from 'node:stream';\n\nimport type { JSONRPCMessage, Transport } from '@modelcontextprotocol/core-internal';\nimport { ReadBuffer, SdkError, SdkErrorCode, serializeMessage } from '@modelcontextprotocol/core-internal';\nimport spawn from 'cross-spawn';\n\nexport type StdioServerParameters = {\n    /**\n     * The executable to run to start the server.\n     */\n    command: string;\n\n    /**\n     * Command line arguments to pass to the executable.\n     */\n    args?: string[];\n\n    /**\n     * The environment to use when spawning the process.\n     *\n     * If not specified, the result of {@linkcode getDefaultEnvironment} will be used.\n     */\n    env?: Record<string, string>;\n\n    /**\n     * How to handle stderr of the child process. This matches the semantics of Node's `child_process.spawn`.\n     *\n     * The default is `\"inherit\"`, meaning messages to stderr will be printed to the parent process's stderr.\n     */\n    stderr?: IOType | Stream | number;\n\n    /**\n     * The working directory to use when spawning the process.\n     *\n     * If not specified, the current working directory will be inherited.\n     */\n    cwd?: string;\n\n    /**\n     * Maximum size of the read buffer in bytes. If a single message exceeds\n     * this size the transport will emit an error and close.\n     *\n     * Defaults to 10 MB.\n     */\n    maxBufferSize?: number;\n};\n\n/**\n * Environment variables to inherit by default, if an environment is not explicitly given.\n */\nexport const DEFAULT_INHERITED_ENV_VARS =\n    process.platform === 'win32'\n        ? [\n              'APPDATA',\n              'HOMEDRIVE',\n              'HOMEPATH',\n              'LOCALAPPDATA',\n              'PATH',\n              'PROCESSOR_ARCHITECTURE',\n              'SYSTEMDRIVE',\n              'SYSTEMROOT',\n              'TEMP',\n              'USERNAME',\n              'USERPROFILE',\n              'PROGRAMFILES'\n          ]\n        : /* list inspired by the default env inheritance of sudo */\n          ['HOME', 'LOGNAME', 'PATH', 'SHELL', 'TERM', 'USER'];\n\n/**\n * Returns a default environment object including only environment variables deemed safe to inherit.\n */\nexport function getDefaultEnvironment(): Record<string, string> {\n    const env: Record<string, string> = {};\n\n    for (const key of DEFAULT_INHERITED_ENV_VARS) {\n        const value = process.env[key];\n        if (value === undefined) {\n            continue;\n        }\n\n        if (value.startsWith('()')) {\n            // Skip functions, which are a security risk.\n            continue;\n        }\n\n        env[key] = value;\n    }\n\n    return env;\n}\n\n/**\n * Client transport for stdio: this will connect to a server by spawning a process and communicating with it over stdin/stdout.\n *\n * This transport is only available in Node.js environments.\n */\nexport class StdioClientTransport implements Transport {\n    private _process?: ChildProcess;\n    private _readBuffer: ReadBuffer;\n    private _serverParams: StdioServerParameters;\n    private _stderrStream: PassThrough | null = null;\n\n    onclose?: () => void;\n    onerror?: (error: Error) => void;\n    onmessage?: (message: JSONRPCMessage) => void;\n\n    constructor(server: StdioServerParameters) {\n        this._serverParams = server;\n        this._readBuffer = new ReadBuffer({ maxBufferSize: server.maxBufferSize });\n        if (server.stderr === 'pipe' || server.stderr === 'overlapped') {\n            this._stderrStream = new PassThrough();\n        }\n    }\n\n    /**\n     * Starts the server process and prepares to communicate with it.\n     */\n    async start(): Promise<void> {\n        if (this._process) {\n            throw new Error(\n                'StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.'\n            );\n        }\n\n        return new Promise((resolve, reject) => {\n            this._process = spawn(this._serverParams.command, this._serverParams.args ?? [], {\n                // merge default env with server env because mcp server needs some env vars\n                env: {\n                    ...getDefaultEnvironment(),\n                    ...this._serverParams.env\n                },\n                stdio: ['pipe', 'pipe', this._serverParams.stderr ?? 'inherit'],\n                shell: false,\n                windowsHide: process.platform === 'win32',\n                cwd: this._serverParams.cwd\n            });\n\n            this._process.on('error', error => {\n                reject(error);\n                this.onerror?.(error);\n            });\n\n            this._process.on('spawn', () => {\n                resolve();\n            });\n\n            this._process.on('close', _code => {\n                this._process = undefined;\n                this.onclose?.();\n            });\n\n            this._process.stdin?.on('error', error => {\n                this.onerror?.(error);\n            });\n\n            this._process.stdout?.on('data', chunk => {\n                try {\n                    this._readBuffer.append(chunk);\n                    this.processReadBuffer();\n                } catch (error) {\n                    this.onerror?.(error as Error);\n                    this.close().catch(() => {});\n                }\n            });\n\n            this._process.stdout?.on('error', error => {\n                this.onerror?.(error);\n            });\n\n            if (this._stderrStream && this._process.stderr) {\n                this._process.stderr.pipe(this._stderrStream);\n            }\n        });\n    }\n\n    /**\n     * The `stderr` stream of the child process, if {@linkcode StdioServerParameters.stderr} was set to `\"pipe\"` or `\"overlapped\"`.\n     *\n     * If `stderr` piping was requested, a `PassThrough` stream is returned _immediately_, allowing callers to\n     * attach listeners before the `start` method is invoked. This prevents loss of any early\n     * error output emitted by the child process.\n     */\n    get stderr(): Stream | null {\n        if (this._stderrStream) {\n            return this._stderrStream;\n        }\n\n        return this._process?.stderr ?? null;\n    }\n\n    /**\n     * The child process pid spawned by this transport.\n     *\n     * This is only available after the transport has been started.\n     */\n    get pid(): number | null {\n        return this._process?.pid ?? null;\n    }\n\n    private processReadBuffer() {\n        while (true) {\n            try {\n                const message = this._readBuffer.readMessage();\n                if (message === null) {\n                    break;\n                }\n\n                this.onmessage?.(message);\n            } catch (error) {\n                this.onerror?.(error as Error);\n            }\n        }\n    }\n\n    /**\n     * Reap a disposable probe sibling (see the version-negotiation sibling\n     * flow): signal-first teardown awaiting process `exit` — never the `close`\n     * event, so a helper process holding the child's stdio pipes can never\n     * block disposal. Not part of the public transport lifecycle.\n     *\n     * @internal\n     */\n    private async _dispose(): Promise<void> {\n        const proc = this._process;\n        this._process = undefined;\n        if (proc && proc.exitCode === null && proc.signalCode === null) {\n            const exited = new Promise<void>(resolve => proc.once('exit', () => resolve()));\n            try {\n                proc.stdin?.end();\n            } catch {\n                // ignore\n            }\n            try {\n                proc.kill('SIGTERM');\n            } catch {\n                // ignore\n            }\n            await Promise.race([exited, new Promise(resolve => setTimeout(resolve, 1000).unref())]);\n            if (proc.exitCode === null && proc.signalCode === null) {\n                try {\n                    proc.kill('SIGKILL');\n                } catch {\n                    // ignore\n                }\n            }\n            await exited;\n        }\n        // The child is gone — release the PARENT-side pipe handles too. A helper\n        // process holding the inherited write ends would otherwise keep them (and\n        // with them the host's event loop: stdout carries a flowing 'data'\n        // listener from start()) alive until the helper exits.\n        try {\n            proc?.stdout?.destroy();\n        } catch {\n            // ignore\n        }\n        try {\n            proc?.stdin?.destroy();\n        } catch {\n            // ignore\n        }\n        try {\n            proc?.stderr?.destroy();\n        } catch {\n            // ignore\n        }\n        this._readBuffer.clear();\n    }\n\n    async close(): Promise<void> {\n        if (this._process) {\n            const processToClose = this._process;\n            this._process = undefined;\n\n            const closePromise = new Promise<void>(resolve => {\n                processToClose.once('close', () => {\n                    resolve();\n                });\n            });\n\n            try {\n                processToClose.stdin?.end();\n            } catch {\n                // ignore\n            }\n\n            await Promise.race([closePromise, new Promise(resolve => setTimeout(resolve, 2000).unref())]);\n\n            if (processToClose.exitCode === null) {\n                try {\n                    processToClose.kill('SIGTERM');\n                } catch {\n                    // ignore\n                }\n\n                await Promise.race([closePromise, new Promise(resolve => setTimeout(resolve, 2000).unref())]);\n            }\n\n            if (processToClose.exitCode === null) {\n                try {\n                    processToClose.kill('SIGKILL');\n                } catch {\n                    // ignore\n                }\n            }\n        }\n\n        this._readBuffer.clear();\n    }\n\n    send(message: JSONRPCMessage): Promise<void> {\n        return new Promise(resolve => {\n            if (!this._process?.stdin) {\n                throw new SdkError(SdkErrorCode.NotConnected, 'Not connected');\n            }\n\n            const json = serializeMessage(message);\n            if (this._process.stdin.write(json)) {\n                resolve();\n            } else {\n                this._process.stdin.once('drain', resolve);\n            }\n        });\n    }\n}\n"],"mappings":"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"}

package/node_modules/@modelcontextprotocol/client/dist/stdio.d.cts

@@ -0,0 +1,96 @@
+import { E as Transport, bn as JSONRPCMessage } from "./index-CHhhk6PQ.cjs";
+import { IOType } from "node:child_process";
+import { Stream } from "node:stream";
+
+//#region src/client/stdio.d.ts
+type StdioServerParameters = {
+  /**
+   * The executable to run to start the server.
+   */
+  command: string;
+  /**
+   * Command line arguments to pass to the executable.
+   */
+  args?: string[];
+  /**
+   * The environment to use when spawning the process.
+   *
+   * If not specified, the result of {@linkcode getDefaultEnvironment} will be used.
+   */
+  env?: Record<string, string>;
+  /**
+   * How to handle stderr of the child process. This matches the semantics of Node's `child_process.spawn`.
+   *
+   * The default is `"inherit"`, meaning messages to stderr will be printed to the parent process's stderr.
+   */
+  stderr?: IOType | Stream | number;
+  /**
+   * The working directory to use when spawning the process.
+   *
+   * If not specified, the current working directory will be inherited.
+   */
+  cwd?: string;
+  /**
+   * Maximum size of the read buffer in bytes. If a single message exceeds
+   * this size the transport will emit an error and close.
+   *
+   * Defaults to 10 MB.
+   */
+  maxBufferSize?: number;
+};
+/**
+ * Environment variables to inherit by default, if an environment is not explicitly given.
+ */
+declare const DEFAULT_INHERITED_ENV_VARS: string[];
+/**
+ * Returns a default environment object including only environment variables deemed safe to inherit.
+ */
+declare function getDefaultEnvironment(): Record<string, string>;
+/**
+ * Client transport for stdio: this will connect to a server by spawning a process and communicating with it over stdin/stdout.
+ *
+ * This transport is only available in Node.js environments.
+ */
+declare class StdioClientTransport implements Transport {
+  private _process?;
+  private _readBuffer;
+  private _serverParams;
+  private _stderrStream;
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+  constructor(server: StdioServerParameters);
+  /**
+   * Starts the server process and prepares to communicate with it.
+   */
+  start(): Promise<void>;
+  /**
+   * The `stderr` stream of the child process, if {@linkcode StdioServerParameters.stderr} was set to `"pipe"` or `"overlapped"`.
+   *
+   * If `stderr` piping was requested, a `PassThrough` stream is returned _immediately_, allowing callers to
+   * attach listeners before the `start` method is invoked. This prevents loss of any early
+   * error output emitted by the child process.
+   */
+  get stderr(): Stream | null;
+  /**
+   * The child process pid spawned by this transport.
+   *
+   * This is only available after the transport has been started.
+   */
+  get pid(): number | null;
+  private processReadBuffer;
+  /**
+   * Reap a disposable probe sibling (see the version-negotiation sibling
+   * flow): signal-first teardown awaiting process `exit` — never the `close`
+   * event, so a helper process holding the child's stdio pipes can never
+   * block disposal. Not part of the public transport lifecycle.
+   *
+   * @internal
+   */
+  private _dispose;
+  close(): Promise<void>;
+  send(message: JSONRPCMessage): Promise<void>;
+}
+//#endregion
+export { DEFAULT_INHERITED_ENV_VARS, StdioClientTransport, type StdioServerParameters, getDefaultEnvironment };
+//# sourceMappingURL=stdio.d.cts.map

package/node_modules/@modelcontextprotocol/client/dist/stdio.d.cts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.cts","names":[],"sources":["../src/client/stdio.ts"],"sourcesContent":[],"mappings":";;;;;KASY,qBAAA;;AAAZ;;EAuBa,OAAA,EAAA,MAAA;EAAS;;AAqBtB;EAsBgB,IAAA,CAAA,EAAA,MAAA,EAAA;EAyBH;;;;;EAsFK,GAAA,CAAA,EAjKR,MAiKQ,CAAA,MAAA,EAAA,MAAA,CAAA;EAuFC;;;;;WAjPN,SAAS;;;;;;;;;;;;;;;;;;cAqBT;;;;iBAsBG,qBAAA,CAAA,GAAyB;;;;;;cAyB5B,oBAAA,YAAgC;;;;;;oBAOvB;wBACI;sBAEF;;;;WAWL;;;;;;;;gBAiED;;;;;;;;;;;;;;;;;WAuFC;gBAyCD,iBAAiB"}

package/node_modules/@modelcontextprotocol/client/dist/stdio.d.mts

@@ -0,0 +1,96 @@
+import { E as Transport, bn as JSONRPCMessage } from "./index-D4xIIEF6.mjs";
+import { Stream } from "node:stream";
+import { IOType } from "node:child_process";
+
+//#region src/client/stdio.d.ts
+type StdioServerParameters = {
+  /**
+   * The executable to run to start the server.
+   */
+  command: string;
+  /**
+   * Command line arguments to pass to the executable.
+   */
+  args?: string[];
+  /**
+   * The environment to use when spawning the process.
+   *
+   * If not specified, the result of {@linkcode getDefaultEnvironment} will be used.
+   */
+  env?: Record<string, string>;
+  /**
+   * How to handle stderr of the child process. This matches the semantics of Node's `child_process.spawn`.
+   *
+   * The default is `"inherit"`, meaning messages to stderr will be printed to the parent process's stderr.
+   */
+  stderr?: IOType | Stream | number;
+  /**
+   * The working directory to use when spawning the process.
+   *
+   * If not specified, the current working directory will be inherited.
+   */
+  cwd?: string;
+  /**
+   * Maximum size of the read buffer in bytes. If a single message exceeds
+   * this size the transport will emit an error and close.
+   *
+   * Defaults to 10 MB.
+   */
+  maxBufferSize?: number;
+};
+/**
+ * Environment variables to inherit by default, if an environment is not explicitly given.
+ */
+declare const DEFAULT_INHERITED_ENV_VARS: string[];
+/**
+ * Returns a default environment object including only environment variables deemed safe to inherit.
+ */
+declare function getDefaultEnvironment(): Record<string, string>;
+/**
+ * Client transport for stdio: this will connect to a server by spawning a process and communicating with it over stdin/stdout.
+ *
+ * This transport is only available in Node.js environments.
+ */
+declare class StdioClientTransport implements Transport {
+  private _process?;
+  private _readBuffer;
+  private _serverParams;
+  private _stderrStream;
+  onclose?: () => void;
+  onerror?: (error: Error) => void;
+  onmessage?: (message: JSONRPCMessage) => void;
+  constructor(server: StdioServerParameters);
+  /**
+   * Starts the server process and prepares to communicate with it.
+   */
+  start(): Promise<void>;
+  /**
+   * The `stderr` stream of the child process, if {@linkcode StdioServerParameters.stderr} was set to `"pipe"` or `"overlapped"`.
+   *
+   * If `stderr` piping was requested, a `PassThrough` stream is returned _immediately_, allowing callers to
+   * attach listeners before the `start` method is invoked. This prevents loss of any early
+   * error output emitted by the child process.
+   */
+  get stderr(): Stream | null;
+  /**
+   * The child process pid spawned by this transport.
+   *
+   * This is only available after the transport has been started.
+   */
+  get pid(): number | null;
+  private processReadBuffer;
+  /**
+   * Reap a disposable probe sibling (see the version-negotiation sibling
+   * flow): signal-first teardown awaiting process `exit` — never the `close`
+   * event, so a helper process holding the child's stdio pipes can never
+   * block disposal. Not part of the public transport lifecycle.
+   *
+   * @internal
+   */
+  private _dispose;
+  close(): Promise<void>;
+  send(message: JSONRPCMessage): Promise<void>;
+}
+//#endregion
+export { DEFAULT_INHERITED_ENV_VARS, StdioClientTransport, type StdioServerParameters, getDefaultEnvironment };
+//# sourceMappingURL=stdio.d.mts.map

package/node_modules/@modelcontextprotocol/client/dist/stdio.d.mts.map

@@ -0,0 +1 @@
+{"version":3,"file":"stdio.d.mts","names":[],"sources":["../src/client/stdio.ts"],"sourcesContent":[],"mappings":";;;;;KASY,qBAAA;;AAAZ;;EAuBa,OAAA,EAAA,MAAA;EAAS;;AAqBtB;EAsBgB,IAAA,CAAA,EAAA,MAAA,EAAA;EAyBH;;;;;EAsFK,GAAA,CAAA,EAjKR,MAiKQ,CAAA,MAAA,EAAA,MAAA,CAAA;EAuFC;;;;;WAjPN,SAAS;;;;;;;;;;;;;;;;;;cAqBT;;;;iBAsBG,qBAAA,CAAA,GAAyB;;;;;;cAyB5B,oBAAA,YAAgC;;;;;;oBAOvB;wBACI;sBAEF;;;;WAWL;;;;;;;;gBAiED;;;;;;;;;;;;;;;;;WAuFC;gBAyCD,iBAAiB"}

package/node_modules/@modelcontextprotocol/client/dist/stdio.mjs

@@ -0,0 +1,212 @@
+import { At as SdkErrorCode, kt as SdkError, s as ReadBuffer, u as serializeMessage } from "./src-D_zzAWoS.mjs";
+import process from "node:process";
+import { PassThrough } from "node:stream";
+import spawn from "cross-spawn";
+
+//#region src/client/stdio.ts
+/**
+* Environment variables to inherit by default, if an environment is not explicitly given.
+*/
+const DEFAULT_INHERITED_ENV_VARS = process.platform === "win32" ? [
+	"APPDATA",
+	"HOMEDRIVE",
+	"HOMEPATH",
+	"LOCALAPPDATA",
+	"PATH",
+	"PROCESSOR_ARCHITECTURE",
+	"SYSTEMDRIVE",
+	"SYSTEMROOT",
+	"TEMP",
+	"USERNAME",
+	"USERPROFILE",
+	"PROGRAMFILES"
+] : [
+	"HOME",
+	"LOGNAME",
+	"PATH",
+	"SHELL",
+	"TERM",
+	"USER"
+];
+/**
+* Returns a default environment object including only environment variables deemed safe to inherit.
+*/
+function getDefaultEnvironment() {
+	const env = {};
+	for (const key of DEFAULT_INHERITED_ENV_VARS) {
+		const value = process.env[key];
+		if (value === void 0) continue;
+		if (value.startsWith("()")) continue;
+		env[key] = value;
+	}
+	return env;
+}
+/**
+* Client transport for stdio: this will connect to a server by spawning a process and communicating with it over stdin/stdout.
+*
+* This transport is only available in Node.js environments.
+*/
+var StdioClientTransport = class {
+	_process;
+	_readBuffer;
+	_serverParams;
+	_stderrStream = null;
+	onclose;
+	onerror;
+	onmessage;
+	constructor(server) {
+		this._serverParams = server;
+		this._readBuffer = new ReadBuffer({ maxBufferSize: server.maxBufferSize });
+		if (server.stderr === "pipe" || server.stderr === "overlapped") this._stderrStream = new PassThrough();
+	}
+	/**
+	* Starts the server process and prepares to communicate with it.
+	*/
+	async start() {
+		if (this._process) throw new Error("StdioClientTransport already started! If using Client class, note that connect() calls start() automatically.");
+		return new Promise((resolve, reject) => {
+			this._process = spawn(this._serverParams.command, this._serverParams.args ?? [], {
+				env: {
+					...getDefaultEnvironment(),
+					...this._serverParams.env
+				},
+				stdio: [
+					"pipe",
+					"pipe",
+					this._serverParams.stderr ?? "inherit"
+				],
+				shell: false,
+				windowsHide: process.platform === "win32",
+				cwd: this._serverParams.cwd
+			});
+			this._process.on("error", (error) => {
+				reject(error);
+				this.onerror?.(error);
+			});
+			this._process.on("spawn", () => {
+				resolve();
+			});
+			this._process.on("close", (_code) => {
+				this._process = void 0;
+				this.onclose?.();
+			});
+			this._process.stdin?.on("error", (error) => {
+				this.onerror?.(error);
+			});
+			this._process.stdout?.on("data", (chunk) => {
+				try {
+					this._readBuffer.append(chunk);
+					this.processReadBuffer();
+				} catch (error) {
+					this.onerror?.(error);
+					this.close().catch(() => {});
+				}
+			});
+			this._process.stdout?.on("error", (error) => {
+				this.onerror?.(error);
+			});
+			if (this._stderrStream && this._process.stderr) this._process.stderr.pipe(this._stderrStream);
+		});
+	}
+	/**
+	* The `stderr` stream of the child process, if {@linkcode StdioServerParameters.stderr} was set to `"pipe"` or `"overlapped"`.
+	*
+	* If `stderr` piping was requested, a `PassThrough` stream is returned _immediately_, allowing callers to
+	* attach listeners before the `start` method is invoked. This prevents loss of any early
+	* error output emitted by the child process.
+	*/
+	get stderr() {
+		if (this._stderrStream) return this._stderrStream;
+		return this._process?.stderr ?? null;
+	}
+	/**
+	* The child process pid spawned by this transport.
+	*
+	* This is only available after the transport has been started.
+	*/
+	get pid() {
+		return this._process?.pid ?? null;
+	}
+	processReadBuffer() {
+		while (true) try {
+			const message = this._readBuffer.readMessage();
+			if (message === null) break;
+			this.onmessage?.(message);
+		} catch (error) {
+			this.onerror?.(error);
+		}
+	}
+	/**
+	* Reap a disposable probe sibling (see the version-negotiation sibling
+	* flow): signal-first teardown awaiting process `exit` — never the `close`
+	* event, so a helper process holding the child's stdio pipes can never
+	* block disposal. Not part of the public transport lifecycle.
+	*
+	* @internal
+	*/
+	async _dispose() {
+		const proc = this._process;
+		this._process = void 0;
+		if (proc && proc.exitCode === null && proc.signalCode === null) {
+			const exited = new Promise((resolve) => proc.once("exit", () => resolve()));
+			try {
+				proc.stdin?.end();
+			} catch {}
+			try {
+				proc.kill("SIGTERM");
+			} catch {}
+			await Promise.race([exited, new Promise((resolve) => setTimeout(resolve, 1e3).unref())]);
+			if (proc.exitCode === null && proc.signalCode === null) try {
+				proc.kill("SIGKILL");
+			} catch {}
+			await exited;
+		}
+		try {
+			proc?.stdout?.destroy();
+		} catch {}
+		try {
+			proc?.stdin?.destroy();
+		} catch {}
+		try {
+			proc?.stderr?.destroy();
+		} catch {}
+		this._readBuffer.clear();
+	}
+	async close() {
+		if (this._process) {
+			const processToClose = this._process;
+			this._process = void 0;
+			const closePromise = new Promise((resolve) => {
+				processToClose.once("close", () => {
+					resolve();
+				});
+			});
+			try {
+				processToClose.stdin?.end();
+			} catch {}
+			await Promise.race([closePromise, new Promise((resolve) => setTimeout(resolve, 2e3).unref())]);
+			if (processToClose.exitCode === null) {
+				try {
+					processToClose.kill("SIGTERM");
+				} catch {}
+				await Promise.race([closePromise, new Promise((resolve) => setTimeout(resolve, 2e3).unref())]);
+			}
+			if (processToClose.exitCode === null) try {
+				processToClose.kill("SIGKILL");
+			} catch {}
+		}
+		this._readBuffer.clear();
+	}
+	send(message) {
+		return new Promise((resolve) => {
+			if (!this._process?.stdin) throw new SdkError(SdkErrorCode.NotConnected, "Not connected");
+			const json = serializeMessage(message);
+			if (this._process.stdin.write(json)) resolve();
+			else this._process.stdin.once("drain", resolve);
+		});
+	}
+};
+
+//#endregion
+export { DEFAULT_INHERITED_ENV_VARS, StdioClientTransport, getDefaultEnvironment };
+//# sourceMappingURL=stdio.mjs.map