@agentcomms/whatsapp 0.7.0

package/dist/stdio-BR8R87El.mjs

@@ -0,0 +1,102 @@
+import { i as serializeMessage, n as process, r as ReadBuffer } from "./mcp-DXXb3Vv3-Co5BzjYe.mjs";
+//#region ../../node_modules/.pnpm/@modelcontextprotocol+server@2.0.0/node_modules/@modelcontextprotocol/server/dist/stdio.mjs
+/**
+* Server transport for stdio: this communicates with an MCP client by reading from the current process' `stdin` and writing to `stdout`.
+*
+* This transport is only available in Node.js environments.
+*
+* @example
+* ```ts source="./stdio.examples.ts#StdioServerTransport_basicUsage"
+* const server = new McpServer({ name: 'my-server', version: '1.0.0' });
+* const transport = new StdioServerTransport();
+* await server.connect(transport);
+* ```
+*/
+var StdioServerTransport = class {
+	_readBuffer;
+	_started = false;
+	_closed = false;
+	constructor(_stdin = process.stdin, _stdout = process.stdout, options) {
+		this._stdin = _stdin;
+		this._stdout = _stdout;
+		this._readBuffer = new ReadBuffer({ maxBufferSize: options?.maxBufferSize });
+	}
+	onclose;
+	onerror;
+	onmessage;
+	_ondata = (chunk) => {
+		try {
+			this._readBuffer.append(chunk);
+			this.processReadBuffer();
+		} catch (error) {
+			this.onerror?.(error);
+			this.close().catch(() => {});
+		}
+	};
+	_onerror = (error) => {
+		this.onerror?.(error);
+	};
+	_onstdouterror = (error) => {
+		this.onerror?.(error);
+		this.close().catch(() => {});
+	};
+	/**
+	* Starts listening for messages on `stdin`.
+	*/
+	async start() {
+		if (this._started) throw new Error("StdioServerTransport already started! If using Server class, note that connect() calls start() automatically.");
+		this._started = true;
+		this._stdin.on("data", this._ondata);
+		this._stdin.on("error", this._onerror);
+		this._stdout.on("error", this._onstdouterror);
+	}
+	processReadBuffer() {
+		while (true) try {
+			const message = this._readBuffer.readMessage();
+			if (message === null) break;
+			this.onmessage?.(message);
+		} catch (error) {
+			this.onerror?.(error);
+		}
+	}
+	async close() {
+		if (this._closed) return;
+		this._closed = true;
+		this._stdin.off("data", this._ondata);
+		this._stdin.off("error", this._onerror);
+		this._stdout.off("error", this._onstdouterror);
+		if (this._stdin.listenerCount("data") === 0) this._stdin.pause();
+		this._readBuffer.clear();
+		this.onclose?.();
+	}
+	send(message) {
+		if (this._closed) return Promise.reject(/* @__PURE__ */ new Error("StdioServerTransport is closed"));
+		return new Promise((resolve, reject) => {
+			const json = serializeMessage(message);
+			let settled = false;
+			const onError = (error) => {
+				if (settled) return;
+				settled = true;
+				this._stdout.off("error", onError);
+				this._stdout.off("drain", onDrain);
+				reject(error);
+			};
+			const onDrain = () => {
+				if (settled) return;
+				settled = true;
+				this._stdout.off("error", onError);
+				this._stdout.off("drain", onDrain);
+				resolve();
+			};
+			this._stdout.once("error", onError);
+			if (this._stdout.write(json)) {
+				if (settled) return;
+				settled = true;
+				this._stdout.off("error", onError);
+				resolve();
+			} else if (!settled) this._stdout.once("drain", onDrain);
+		});
+	}
+};
+//#endregion
+export { StdioServerTransport };

package/dist/stdio-CHZ2WRcx-5iYMXTdw.mjs

@@ -0,0 +1,607 @@
+import { a as ReadBuffer, c as SdkErrorCode, k as serializeMessage, s as SdkError } from "./src-D_zzAWoS-BhK0GFdq-XAvBzdGB.mjs";
+import { createRequire } from "node:module";
+import process$1 from "node:process";
+import { PassThrough } from "node:stream";
+//#region ../core/dist/stdio-CHZ2WRcx.mjs
+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 __commonJSMin = (cb, mod) => () => (mod || (cb((mod = { exports: {} }).exports, mod), cb = null), mod.exports);
+var __copyProps = (to, from, except, desc) => {
+	if (from && typeof from === "object" || typeof from === "function") for (var keys = __getOwnPropNames(from), i = 0, n = keys.length, key; i < n; i++) {
+		key = keys[i];
+		if (!__hasOwnProp.call(to, key) && key !== except) __defProp(to, key, {
+			get: ((k) => from[k]).bind(null, key),
+			enumerable: !(desc = __getOwnPropDesc(from, key)) || desc.enumerable
+		});
+	}
+	return to;
+};
+var __toESM = (mod, isNodeMode, target) => (target = mod != null ? __create(__getProtoOf(mod)) : {}, __copyProps(isNodeMode || !mod || !mod.__esModule || !__hasOwnProp.call(mod, "default") ? __defProp(target, "default", {
+	value: mod,
+	enumerable: true
+}) : target, mod));
+var __require = /* #__PURE__ */ (() => createRequire(import.meta.url))();
+var require_windows = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = isexe;
+	isexe.sync = sync;
+	var fs$2 = __require("fs");
+	function checkPathExt(path, options) {
+		var pathext = options.pathExt !== void 0 ? options.pathExt : process.env.PATHEXT;
+		if (!pathext) return true;
+		pathext = pathext.split(";");
+		if (pathext.indexOf("") !== -1) return true;
+		for (var i = 0; i < pathext.length; i++) {
+			var p = pathext[i].toLowerCase();
+			if (p && path.substr(-p.length).toLowerCase() === p) return true;
+		}
+		return false;
+	}
+	function checkStat(stat, path, options) {
+		if (!stat.isSymbolicLink() && !stat.isFile()) return false;
+		return checkPathExt(path, options);
+	}
+	function isexe(path, options, cb) {
+		fs$2.stat(path, function(er, stat) {
+			cb(er, er ? false : checkStat(stat, path, options));
+		});
+	}
+	function sync(path, options) {
+		return checkStat(fs$2.statSync(path), path, options);
+	}
+}));
+var require_mode = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = isexe;
+	isexe.sync = sync;
+	var fs$1 = __require("fs");
+	function isexe(path, options, cb) {
+		fs$1.stat(path, function(er, stat) {
+			cb(er, er ? false : checkStat(stat, options));
+		});
+	}
+	function sync(path, options) {
+		return checkStat(fs$1.statSync(path), options);
+	}
+	function checkStat(stat, options) {
+		return stat.isFile() && checkMode(stat, options);
+	}
+	function checkMode(stat, options) {
+		var mod = stat.mode;
+		var uid = stat.uid;
+		var gid = stat.gid;
+		var myUid = options.uid !== void 0 ? options.uid : process.getuid && process.getuid();
+		var myGid = options.gid !== void 0 ? options.gid : process.getgid && process.getgid();
+		var u = parseInt("100", 8);
+		var g = parseInt("010", 8);
+		var o = parseInt("001", 8);
+		var ug = u | g;
+		return mod & o || mod & g && gid === myGid || mod & u && uid === myUid || mod & ug && myUid === 0;
+	}
+}));
+var require_isexe = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	__require("fs");
+	var core;
+	if (process.platform === "win32" || global.TESTING_WINDOWS) core = require_windows();
+	else core = require_mode();
+	module.exports = isexe;
+	isexe.sync = sync;
+	function isexe(path, options, cb) {
+		if (typeof options === "function") {
+			cb = options;
+			options = {};
+		}
+		if (!cb) {
+			if (typeof Promise !== "function") throw new TypeError("callback not provided");
+			return new Promise(function(resolve, reject) {
+				isexe(path, options || {}, function(er, is) {
+					if (er) reject(er);
+					else resolve(is);
+				});
+			});
+		}
+		core(path, options || {}, function(er, is) {
+			if (er) {
+				if (er.code === "EACCES" || options && options.ignoreErrors) {
+					er = null;
+					is = false;
+				}
+			}
+			cb(er, is);
+		});
+	}
+	function sync(path, options) {
+		try {
+			return core.sync(path, options || {});
+		} catch (er) {
+			if (options && options.ignoreErrors || er.code === "EACCES") return false;
+			else throw er;
+		}
+	}
+}));
+var require_which = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWindows = process.platform === "win32" || process.env.OSTYPE === "cygwin" || process.env.OSTYPE === "msys";
+	const path$2 = __require("path");
+	const COLON = isWindows ? ";" : ":";
+	const isexe = require_isexe();
+	const getNotFoundError = (cmd) => Object.assign(/* @__PURE__ */ new Error(`not found: ${cmd}`), { code: "ENOENT" });
+	const getPathInfo = (cmd, opt) => {
+		const colon = opt.colon || COLON;
+		const pathEnv = cmd.match(/\//) || isWindows && cmd.match(/\\/) ? [""] : [...isWindows ? [process.cwd()] : [], ...(opt.path || process.env.PATH || 
+		/* istanbul ignore next: very unusual */ "").split(colon)];
+		const pathExtExe = isWindows ? opt.pathExt || process.env.PATHEXT || ".EXE;.CMD;.BAT;.COM" : "";
+		const pathExt = isWindows ? pathExtExe.split(colon) : [""];
+		if (isWindows) {
+			if (cmd.indexOf(".") !== -1 && pathExt[0] !== "") pathExt.unshift("");
+		}
+		return {
+			pathEnv,
+			pathExt,
+			pathExtExe
+		};
+	};
+	const which = (cmd, opt, cb) => {
+		if (typeof opt === "function") {
+			cb = opt;
+			opt = {};
+		}
+		if (!opt) opt = {};
+		const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+		const found = [];
+		const step = (i) => new Promise((resolve, reject) => {
+			if (i === pathEnv.length) return opt.all && found.length ? resolve(found) : reject(getNotFoundError(cmd));
+			const ppRaw = pathEnv[i];
+			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+			const pCmd = path$2.join(pathPart, cmd);
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			resolve(subStep(p, i, 0));
+		});
+		const subStep = (p, i, ii) => new Promise((resolve, reject) => {
+			if (ii === pathExt.length) return resolve(step(i + 1));
+			const ext = pathExt[ii];
+			isexe(p + ext, { pathExt: pathExtExe }, (er, is) => {
+				if (!er && is) {
+					if (opt.all) found.push(p + ext);
+					else return resolve(p + ext);
+				}
+				return resolve(subStep(p, i, ii + 1));
+			});
+		});
+		return cb ? step(0).then((res) => cb(null, res), cb) : step(0);
+	};
+	const whichSync = (cmd, opt) => {
+		opt = opt || {};
+		const { pathEnv, pathExt, pathExtExe } = getPathInfo(cmd, opt);
+		const found = [];
+		for (let i = 0; i < pathEnv.length; i++) {
+			const ppRaw = pathEnv[i];
+			const pathPart = /^".*"$/.test(ppRaw) ? ppRaw.slice(1, -1) : ppRaw;
+			const pCmd = path$2.join(pathPart, cmd);
+			const p = !pathPart && /^\.[\\\/]/.test(cmd) ? cmd.slice(0, 2) + pCmd : pCmd;
+			for (let j = 0; j < pathExt.length; j++) {
+				const cur = p + pathExt[j];
+				try {
+					if (isexe.sync(cur, { pathExt: pathExtExe })) {
+						if (opt.all) found.push(cur);
+						else return cur;
+					}
+				} catch (ex) {}
+			}
+		}
+		if (opt.all && found.length) return found;
+		if (opt.nothrow) return null;
+		throw getNotFoundError(cmd);
+	};
+	module.exports = which;
+	which.sync = whichSync;
+}));
+var require_path_key = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const pathKey = (options = {}) => {
+		const environment = options.env || process.env;
+		if ((options.platform || process.platform) !== "win32") return "PATH";
+		return Object.keys(environment).reverse().find((key) => key.toUpperCase() === "PATH") || "Path";
+	};
+	module.exports = pathKey;
+	module.exports.default = pathKey;
+}));
+var require_resolveCommand = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path$1 = __require("path");
+	const which = require_which();
+	const getPathKey = require_path_key();
+	function resolveCommandAttempt(parsed, withoutPathExt) {
+		const env = parsed.options.env || process.env;
+		const cwd = process.cwd();
+		const hasCustomCwd = parsed.options.cwd != null;
+		const shouldSwitchCwd = hasCustomCwd && process.chdir !== void 0 && !process.chdir.disabled;
+		if (shouldSwitchCwd) try {
+			process.chdir(parsed.options.cwd);
+		} catch (err) {}
+		let resolved;
+		try {
+			resolved = which.sync(parsed.command, {
+				path: env[getPathKey({ env })],
+				pathExt: withoutPathExt ? path$1.delimiter : void 0
+			});
+		} catch (e) {} finally {
+			if (shouldSwitchCwd) process.chdir(cwd);
+		}
+		if (resolved) resolved = path$1.resolve(hasCustomCwd ? parsed.options.cwd : "", resolved);
+		return resolved;
+	}
+	function resolveCommand(parsed) {
+		return resolveCommandAttempt(parsed) || resolveCommandAttempt(parsed, true);
+	}
+	module.exports = resolveCommand;
+}));
+var require_escape = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const metaCharsRegExp = /([()\][%!^"`<>&|;, *?])/g;
+	function escapeCommand(arg) {
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	function escapeArgument(arg, doubleEscapeMetaChars) {
+		arg = `${arg}`;
+		arg = arg.replace(/(?=(\\+?)?)\1"/g, "$1$1\\\"");
+		arg = arg.replace(/(?=(\\+?)?)\1$/, "$1$1");
+		arg = `"${arg}"`;
+		arg = arg.replace(metaCharsRegExp, "^$1");
+		if (doubleEscapeMetaChars) arg = arg.replace(metaCharsRegExp, "^$1");
+		return arg;
+	}
+	module.exports.command = escapeCommand;
+	module.exports.argument = escapeArgument;
+}));
+var require_shebang_regex = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	module.exports = /^#!(.*)/;
+}));
+var require_shebang_command = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const shebangRegex = require_shebang_regex();
+	module.exports = (string = "") => {
+		const match = string.match(shebangRegex);
+		if (!match) return null;
+		const [path, argument] = match[0].replace(/#! ?/, "").split(" ");
+		const binary = path.split("/").pop();
+		if (binary === "env") return argument;
+		return argument ? `${binary} ${argument}` : binary;
+	};
+}));
+var require_readShebang = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const fs = __require("fs");
+	const shebangCommand = require_shebang_command();
+	function readShebang(command) {
+		const size = 150;
+		const buffer = Buffer.alloc(size);
+		let fd;
+		try {
+			fd = fs.openSync(command, "r");
+			fs.readSync(fd, buffer, 0, size, 0);
+			fs.closeSync(fd);
+		} catch (e) {}
+		return shebangCommand(buffer.toString());
+	}
+	module.exports = readShebang;
+}));
+var require_parse = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const path = __require("path");
+	const resolveCommand = require_resolveCommand();
+	const escape = require_escape();
+	const readShebang = require_readShebang();
+	const isWin = process.platform === "win32";
+	const isExecutableRegExp = /\.(?:com|exe)$/i;
+	const isCmdShimRegExp = /node_modules[\\/].bin[\\/][^\\/]+\.cmd$/i;
+	function detectShebang(parsed) {
+		parsed.file = resolveCommand(parsed);
+		const shebang = parsed.file && readShebang(parsed.file);
+		if (shebang) {
+			parsed.args.unshift(parsed.file);
+			parsed.command = shebang;
+			return resolveCommand(parsed);
+		}
+		return parsed.file;
+	}
+	function parseNonShell(parsed) {
+		if (!isWin) return parsed;
+		const commandFile = detectShebang(parsed);
+		const needsShell = !isExecutableRegExp.test(commandFile);
+		if (parsed.options.forceShell || needsShell) {
+			const needsDoubleEscapeMetaChars = isCmdShimRegExp.test(commandFile);
+			parsed.command = path.normalize(parsed.command);
+			parsed.command = escape.command(parsed.command);
+			parsed.args = parsed.args.map((arg) => escape.argument(arg, needsDoubleEscapeMetaChars));
+			parsed.args = [
+				"/d",
+				"/s",
+				"/c",
+				`"${[parsed.command].concat(parsed.args).join(" ")}"`
+			];
+			parsed.command = process.env.comspec || "cmd.exe";
+			parsed.options.windowsVerbatimArguments = true;
+		}
+		return parsed;
+	}
+	function parse(command, args, options) {
+		if (args && !Array.isArray(args)) {
+			options = args;
+			args = null;
+		}
+		args = args ? args.slice(0) : [];
+		options = Object.assign({}, options);
+		const parsed = {
+			command,
+			args,
+			options,
+			file: void 0,
+			original: {
+				command,
+				args
+			}
+		};
+		return options.shell ? parsed : parseNonShell(parsed);
+	}
+	module.exports = parse;
+}));
+var require_enoent = /* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const isWin = process.platform === "win32";
+	function notFoundError(original, syscall) {
+		return Object.assign(/* @__PURE__ */ new Error(`${syscall} ${original.command} ENOENT`), {
+			code: "ENOENT",
+			errno: "ENOENT",
+			syscall: `${syscall} ${original.command}`,
+			path: original.command,
+			spawnargs: original.args
+		});
+	}
+	function hookChildProcess(cp, parsed) {
+		if (!isWin) return;
+		const originalEmit = cp.emit;
+		cp.emit = function(name, arg1) {
+			if (name === "exit") {
+				const err = verifyENOENT(arg1, parsed);
+				if (err) return originalEmit.call(cp, "error", err);
+			}
+			return originalEmit.apply(cp, arguments);
+		};
+	}
+	function verifyENOENT(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawn");
+		return null;
+	}
+	function verifyENOENTSync(status, parsed) {
+		if (isWin && status === 1 && !parsed.file) return notFoundError(parsed.original, "spawnSync");
+		return null;
+	}
+	module.exports = {
+		hookChildProcess,
+		verifyENOENT,
+		verifyENOENTSync,
+		notFoundError
+	};
+}));
+var import_cross_spawn = /* @__PURE__ */ __toESM((/* @__PURE__ */ __commonJSMin(((exports, module) => {
+	const cp = __require("child_process");
+	const parse = require_parse();
+	const enoent = require_enoent();
+	function spawn(command, args, options) {
+		const parsed = parse(command, args, options);
+		const spawned = cp.spawn(parsed.command, parsed.args, parsed.options);
+		enoent.hookChildProcess(spawned, parsed);
+		return spawned;
+	}
+	function spawnSync(command, args, options) {
+		const parsed = parse(command, args, options);
+		const result = cp.spawnSync(parsed.command, parsed.args, parsed.options);
+		result.error = result.error || enoent.verifyENOENTSync(result.status, parsed);
+		return result;
+	}
+	module.exports = spawn;
+	module.exports.spawn = spawn;
+	module.exports.sync = spawnSync;
+	module.exports._parse = parse;
+	module.exports._enoent = enoent;
+})))(), 1);
+/**
+* Environment variables to inherit by default, if an environment is not explicitly given.
+*/
+const DEFAULT_INHERITED_ENV_VARS = process$1.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$1.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 = (0, import_cross_spawn.default)(this._serverParams.command, this._serverParams.args ?? [], {
+				env: {
+					...getDefaultEnvironment(),
+					...this._serverParams.env
+				},
+				stdio: [
+					"pipe",
+					"pipe",
+					this._serverParams.stderr ?? "inherit"
+				],
+				shell: false,
+				windowsHide: process$1.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 { StdioClientTransport };