@orkestrel/mcp 0.0.22 → 0.0.24

package/dist/src/server/index.d.cts

@@ -1484,8 +1484,10 @@ export declare interface StdioServerOptions {
  *   emits `error` (never throws). `input`'s `close` bridges to this
  *   transport's `close`.
  * - **Outbound (`send`).** `send(message)` writes one newline-terminated
- *   `JSON.stringify`d line to `output`.
- * - **`close()`** removes this transport's input subscriptions and fires its `close`
+ *   `JSON.stringify`d line to `output` and awaits the writable completion callback. The
+ *   callback is the backpressure boundary and its error rejects the send.
+ * - **`close()`** removes this transport's input and output subscriptions, rejects every
+ *   pending send, and fires its `close`
  *   event (idempotent). It pauses the input only when the caller was not already reading
  *   it at `start` (`readableFlowing !== true`) AND no `data` listener remains once this
  *   transport's own is removed — so a process holding `process.stdin` can exit, and a
@@ -1508,6 +1510,19 @@ export declare class StdioServerTransport implements MCPClientTransportInterface
     get session(): string | undefined;
     get duplex(): boolean;
     start(): Promise<void>;
+    /**
+     * Sends one newline-delimited JSON-RPC message through the caller-owned output stream.
+     *
+     * @remarks
+     * The writable completion callback is the backpressure boundary. This method awaits that
+     * callback rather than adding a `drain` listener. Closing the transport rejects every send
+     * whose callback has not settled.
+     *
+     * @param message - The message to serialize and write
+     * @returns Resolves when the output confirms the write
+     * @throws Thrown with `stdio transport is not connected` after the transport closes
+     * @throws Thrown with the output callback error or synchronous write failure
+     */
     send(message: JSONRPCMessage_2): Promise<void>;
     close(): Promise<void>;
 }
@@ -1556,7 +1571,11 @@ export declare function upgradeRequestPath(request: IncomingMessage): string;
  *   event (the reply the {@link import('@orkestrel/mcp').MCPClientInterface} correlates by `id`); a
  *   non-JSON / non-message frame surfaces on `error` and is dropped. The socket's `close`
  *   / `error` bridge to this transport's events.
- * - **Outbound (`send`).** `send(message)` writes one masked text frame.
+ * - **Outbound (`send`).** `send(message)` writes one masked text frame. A socket write is not
+ *   confirmed, so this transport answers a closed channel from its OWN state: a `send` with no
+ *   bound socket — before `start()`, after `close()`, or after the peer ended the socket —
+ *   REJECTS with `WebSocket transport is not connected`. It neither drops the message (the
+ *   browser face's posture) nor queues it for a connection this transport is not holding.
  * - **`close()`** unsubscribes from the socket, closes it, and fires `close` (idempotent). An
  *   upgrade still on the wire is DESTROYED, so a `close()` during the handshake ends the
  *   transport at once instead of waiting for a peer that may never answer — the suspended
@@ -1684,4 +1703,30 @@ export declare class WebSocketServerTransport implements MCPClientTransportInter
     close(): Promise<void>;
 }
 
+/**
+ * Writes one line to a Node writable stream and waits for its completion callback.
+ *
+ * @remarks
+ * The completion callback is the writable channel's backpressure boundary. A callback error and
+ * a synchronous `write` throw reject the returned promise with the original value.
+ *
+ * That callback is the ONLY thing that settles the promise: this helper holds no timer and no
+ * abort, so an output that neither confirms nor fails the write parks the promise for as long as
+ * the caller-owned stream holds the callback. A caller wanting a bound races this promise against
+ * one it owns — {@link import('./transports/StdioServerTransport.js').StdioServerTransport}
+ * registers such a bound per send and rejects it on `close()`, so closing the transport settles
+ * the CALLER's `send` while the abandoned write stays with the stream that still holds its
+ * callback, reachable from nothing the transport retains.
+ *
+ * @param output - The writable stream that receives the line
+ * @param line - The complete line to write
+ * @returns Resolves when the stream confirms the write; rejects when the write fails
+ *
+ * @example
+ * ```ts
+ * await writeLine(process.stdout, '{"jsonrpc":"2.0","method":"ping"}\n')
+ * ```
+ */
+export declare function writeLine(output: NodeJS.WritableStream, line: string): Promise<void>;
+
 export { }

package/dist/src/server/index.d.ts

@@ -1484,8 +1484,10 @@ export declare interface StdioServerOptions {
  *   emits `error` (never throws). `input`'s `close` bridges to this
  *   transport's `close`.
  * - **Outbound (`send`).** `send(message)` writes one newline-terminated
- *   `JSON.stringify`d line to `output`.
- * - **`close()`** removes this transport's input subscriptions and fires its `close`
+ *   `JSON.stringify`d line to `output` and awaits the writable completion callback. The
+ *   callback is the backpressure boundary and its error rejects the send.
+ * - **`close()`** removes this transport's input and output subscriptions, rejects every
+ *   pending send, and fires its `close`
  *   event (idempotent). It pauses the input only when the caller was not already reading
  *   it at `start` (`readableFlowing !== true`) AND no `data` listener remains once this
  *   transport's own is removed — so a process holding `process.stdin` can exit, and a
@@ -1508,6 +1510,19 @@ export declare class StdioServerTransport implements MCPClientTransportInterface
     get session(): string | undefined;
     get duplex(): boolean;
     start(): Promise<void>;
+    /**
+     * Sends one newline-delimited JSON-RPC message through the caller-owned output stream.
+     *
+     * @remarks
+     * The writable completion callback is the backpressure boundary. This method awaits that
+     * callback rather than adding a `drain` listener. Closing the transport rejects every send
+     * whose callback has not settled.
+     *
+     * @param message - The message to serialize and write
+     * @returns Resolves when the output confirms the write
+     * @throws Thrown with `stdio transport is not connected` after the transport closes
+     * @throws Thrown with the output callback error or synchronous write failure
+     */
     send(message: JSONRPCMessage_2): Promise<void>;
     close(): Promise<void>;
 }
@@ -1556,7 +1571,11 @@ export declare function upgradeRequestPath(request: IncomingMessage): string;
  *   event (the reply the {@link import('@orkestrel/mcp').MCPClientInterface} correlates by `id`); a
  *   non-JSON / non-message frame surfaces on `error` and is dropped. The socket's `close`
  *   / `error` bridge to this transport's events.
- * - **Outbound (`send`).** `send(message)` writes one masked text frame.
+ * - **Outbound (`send`).** `send(message)` writes one masked text frame. A socket write is not
+ *   confirmed, so this transport answers a closed channel from its OWN state: a `send` with no
+ *   bound socket — before `start()`, after `close()`, or after the peer ended the socket —
+ *   REJECTS with `WebSocket transport is not connected`. It neither drops the message (the
+ *   browser face's posture) nor queues it for a connection this transport is not holding.
  * - **`close()`** unsubscribes from the socket, closes it, and fires `close` (idempotent). An
  *   upgrade still on the wire is DESTROYED, so a `close()` during the handshake ends the
  *   transport at once instead of waiting for a peer that may never answer — the suspended
@@ -1684,4 +1703,30 @@ export declare class WebSocketServerTransport implements MCPClientTransportInter
     close(): Promise<void>;
 }
 
+/**
+ * Writes one line to a Node writable stream and waits for its completion callback.
+ *
+ * @remarks
+ * The completion callback is the writable channel's backpressure boundary. A callback error and
+ * a synchronous `write` throw reject the returned promise with the original value.
+ *
+ * That callback is the ONLY thing that settles the promise: this helper holds no timer and no
+ * abort, so an output that neither confirms nor fails the write parks the promise for as long as
+ * the caller-owned stream holds the callback. A caller wanting a bound races this promise against
+ * one it owns — {@link import('./transports/StdioServerTransport.js').StdioServerTransport}
+ * registers such a bound per send and rejects it on `close()`, so closing the transport settles
+ * the CALLER's `send` while the abandoned write stays with the stream that still holds its
+ * callback, reachable from nothing the transport retains.
+ *
+ * @param output - The writable stream that receives the line
+ * @param line - The complete line to write
+ * @returns Resolves when the stream confirms the write; rejects when the write fails
+ *
+ * @example
+ * ```ts
+ * await writeLine(process.stdout, '{"jsonrpc":"2.0","method":"ping"}\n')
+ * ```
+ */
+export declare function writeLine(output: NodeJS.WritableStream, line: string): Promise<void>;
+
 export { }

package/dist/src/server/index.js

@@ -364,6 +364,42 @@ function extractLines(buffer, chunk) {
 	};
 }
 /**
+* Writes one line to a Node writable stream and waits for its completion callback.
+*
+* @remarks
+* The completion callback is the writable channel's backpressure boundary. A callback error and
+* a synchronous `write` throw reject the returned promise with the original value.
+*
+* That callback is the ONLY thing that settles the promise: this helper holds no timer and no
+* abort, so an output that neither confirms nor fails the write parks the promise for as long as
+* the caller-owned stream holds the callback. A caller wanting a bound races this promise against
+* one it owns — {@link import('./transports/StdioServerTransport.js').StdioServerTransport}
+* registers such a bound per send and rejects it on `close()`, so closing the transport settles
+* the CALLER's `send` while the abandoned write stays with the stream that still holds its
+* callback, reachable from nothing the transport retains.
+*
+* @param output - The writable stream that receives the line
+* @param line - The complete line to write
+* @returns Resolves when the stream confirms the write; rejects when the write fails
+*
+* @example
+* ```ts
+* await writeLine(process.stdout, '{"jsonrpc":"2.0","method":"ping"}\n')
+* ```
+*/
+function writeLine(output, line) {
+	return new Promise((resolve, reject) => {
+		try {
+			output.write(line, (error) => {
+				if (error === void 0 || error === null) resolve();
+				else reject(error);
+			});
+		} catch (error) {
+			reject(error);
+		}
+	});
+}
+/**
 * Decodes and delivers each complete newline-framed line onto a {@link
 * MCPClientTransportEventMap} emitter — the shared per-chunk dispatch step both stdio
 * transports run their framed lines through: the server transport frames with {@link
@@ -1211,7 +1247,11 @@ var WebSocketServerTransport = class {
 *   event (the reply the {@link import('@orkestrel/mcp').MCPClientInterface} correlates by `id`); a
 *   non-JSON / non-message frame surfaces on `error` and is dropped. The socket's `close`
 *   / `error` bridge to this transport's events.
-* - **Outbound (`send`).** `send(message)` writes one masked text frame.
+* - **Outbound (`send`).** `send(message)` writes one masked text frame. A socket write is not
+*   confirmed, so this transport answers a closed channel from its OWN state: a `send` with no
+*   bound socket — before `start()`, after `close()`, or after the peer ended the socket —
+*   REJECTS with `WebSocket transport is not connected`. It neither drops the message (the
+*   browser face's posture) nor queues it for a connection this transport is not holding.
 * - **`close()`** unsubscribes from the socket, closes it, and fires `close` (idempotent). An
 *   upgrade still on the wire is DESTROYED, so a `close()` during the handshake ends the
 *   transport at once instead of waiting for a peer that may never answer — the suspended
@@ -1558,8 +1598,10 @@ var StdioClientTransport = class {
 *   emits `error` (never throws). `input`'s `close` bridges to this
 *   transport's `close`.
 * - **Outbound (`send`).** `send(message)` writes one newline-terminated
-*   `JSON.stringify`d line to `output`.
-* - **`close()`** removes this transport's input subscriptions and fires its `close`
+*   `JSON.stringify`d line to `output` and awaits the writable completion callback. The
+*   callback is the backpressure boundary and its error rejects the send.
+* - **`close()`** removes this transport's input and output subscriptions, rejects every
+*   pending send, and fires its `close`
 *   event (idempotent). It pauses the input only when the caller was not already reading
 *   it at `start` (`readableFlowing !== true`) AND no `data` listener remains once this
 *   transport's own is removed — so a process holding `process.stdin` can exit, and a
@@ -1582,6 +1624,7 @@ var StdioServerTransport = class {
 	#data = (chunk) => this.#receive(chunk.toString());
 	#ending = () => this.#onClose();
 	#failure = (error) => this.#emitter.emit("error", error);
+	#pending = /* @__PURE__ */ new Set();
 	#buffer = "";
 	#started = false;
 	#closed = false;
@@ -1605,9 +1648,30 @@ var StdioServerTransport = class {
 		this.#input.on("data", this.#data);
 		this.#input.on("close", this.#ending);
 		this.#input.on("error", this.#failure);
+		this.#output.on("error", this.#failure);
 	}
+	/**
+	* Sends one newline-delimited JSON-RPC message through the caller-owned output stream.
+	*
+	* @remarks
+	* The writable completion callback is the backpressure boundary. This method awaits that
+	* callback rather than adding a `drain` listener. Closing the transport rejects every send
+	* whose callback has not settled.
+	*
+	* @param message - The message to serialize and write
+	* @returns Resolves when the output confirms the write
+	* @throws Thrown with `stdio transport is not connected` after the transport closes
+	* @throws Thrown with the output callback error or synchronous write failure
+	*/
 	async send(message) {
-		this.#output.write(`${JSON.stringify(message)}\n`);
+		if (this.#closed) throw new Error("stdio transport is not connected");
+		const pending = Promise.withResolvers();
+		this.#pending.add(pending);
+		try {
+			await Promise.race([writeLine(this.#output, `${JSON.stringify(message)}\n`), pending.promise]);
+		} finally {
+			this.#pending.delete(pending);
+		}
 	}
 	async close() {
 		if (this.#closed) return;
@@ -1630,6 +1694,9 @@ var StdioServerTransport = class {
 		this.#input.removeListener("data", this.#data);
 		this.#input.removeListener("close", this.#ending);
 		this.#input.removeListener("error", this.#failure);
+		this.#output.removeListener("error", this.#failure);
+		for (const pending of this.#pending) pending.reject(/* @__PURE__ */ new Error("stdio transport is not connected"));
+		this.#pending.clear();
 		if (!this.#flowing && this.#input.listenerCount("data") === 0) this.#input.pause();
 	}
 };
@@ -2137,6 +2204,6 @@ function createMCPSession(options) {
 	};
 }
 //#endregion
-export { DEFAULT_MCP_DELIVERY, DEFAULT_MCP_KEEPALIVE_INTERVAL, DEFAULT_MCP_PATH, DEFAULT_MCP_SESSION_CAPACITY, DEFAULT_MCP_SESSION_TTL, HTTPClientTransport, HTTPDisconnect, MCPSession, MCP_METHOD_HEADER, MCP_NAME_HEADER, MCP_PROTOCOL_VERSION_HEADER, MCP_SESSION_HEADER, MCP_WEBSOCKET_SUBPROTOCOL, SSE_BUFFERING_DISABLED, SSE_BUFFERING_HEADER, SSE_KEEPALIVE_COMMENT, StdioClientTransport, StdioServerTransport, WebSocketClientTransport, WebSocketServerTransport, acceptsEventStream, allowsOrigin, bridgeMessageTransport, createHTTPClientTransport, createMCPContinuation, createMCPPostHandler, createMCPRoutes, createMCPSession, createReadableStream, createStdioClientTransport, createStdioServer, createWebSocketClientTransport, createWebSocketServer, decodeEvent, dispatchLines, extractLines, inferHeaderIssue, inferLegacyVersion, inferStatus, readEventStream, readLastEventId, readSessionHeader, rejectUnknownSession, sendEventStream, upgradeRequestPath };
+export { DEFAULT_MCP_DELIVERY, DEFAULT_MCP_KEEPALIVE_INTERVAL, DEFAULT_MCP_PATH, DEFAULT_MCP_SESSION_CAPACITY, DEFAULT_MCP_SESSION_TTL, HTTPClientTransport, HTTPDisconnect, MCPSession, MCP_METHOD_HEADER, MCP_NAME_HEADER, MCP_PROTOCOL_VERSION_HEADER, MCP_SESSION_HEADER, MCP_WEBSOCKET_SUBPROTOCOL, SSE_BUFFERING_DISABLED, SSE_BUFFERING_HEADER, SSE_KEEPALIVE_COMMENT, StdioClientTransport, StdioServerTransport, WebSocketClientTransport, WebSocketServerTransport, acceptsEventStream, allowsOrigin, bridgeMessageTransport, createHTTPClientTransport, createMCPContinuation, createMCPPostHandler, createMCPRoutes, createMCPSession, createReadableStream, createStdioClientTransport, createStdioServer, createWebSocketClientTransport, createWebSocketServer, decodeEvent, dispatchLines, extractLines, inferHeaderIssue, inferLegacyVersion, inferStatus, readEventStream, readLastEventId, readSessionHeader, rejectUnknownSession, sendEventStream, upgradeRequestPath, writeLine };
 
 //# sourceMappingURL=index.js.map