@acid-cat/cli 0.8.0 → 0.9.0

package/README.md

@@ -6,7 +6,7 @@ The AcidCat command line. npm package: `@acid-cat/cli`. It gives the `acid-cat`
 acid-cat check [--strict] <catalog.json ...>  # check catalogs
 acid-cat format [--write] <catalog.json ...>  # write catalogs in canonical form
 acid-cat view <catalog.json> <target>         # write the view of one target
-acid-cat conform --mcp <url> --http <url> --cli "<command>" --webmcp <url> [--deadline <ms>]  # test an implementation
+acid-cat conform --mcp <url> --mcp-stdio "<command>" --http <url> --cli "<command>" --webmcp <url> [--deadline <ms>]  # test an implementation
 ```
 
 Install it as a development dependency, and run it with `pnpm exec acid-cat …`:
@@ -34,10 +34,11 @@ The exit code is 0 if there are no errors. It is 1 if there are errors. With `--
 
 `conform` tests a running implementation of the [conformance fixture](conformance/fixture.pkl) through its bindings (see [Conformance](../../spec/conformance.md#acid-cat-conform)):
 
-- **MCP:** the official MCP client, with revision `2026-07-28`, for tools and outcomes; raw requests for rejections.
+- **MCP through HTTP:** `--mcp <url>`. The official MCP client, with revision `2026-07-28`, for tools and outcomes; raw requests for rejections.
+- **MCP through stdio:** `--mcp-stdio "<command>"`, or `mcpStdio` in code. The checks start the server as a process. The official MCP client tests the tools and outcomes two times: with revision `2026-07-28`, and with the `initialize` handshake of revision `2025-11-25`. It also tests `notifications/tools/list_changed` and `notifications/cancelled`. Raw lines test the version negotiation, a line that is not JSON, a standard output with only JSON-RPC messages, and the end of standard input.
 - **HTTP** and **CLI:** each outcome, each kind of call failure, availability, and rejections. For the CLI, also each kind of flag, including a repeated flag that gives one item of an array for each occurrence, or the whole array as JSON text, and the usage line of each command. An interrupt (`SIGINT`) during a call that holds gives exit code 130.
 - **WebMCP:** the checks act as the WebMCP host. `--webmcp <url>` opens a page that serves the `app` target in Chromium, through [Playwright](https://playwright.dev), with a test `modelContext`. Install Playwright to use it: `pnpm add -D playwright`, then `pnpm exec playwright install chromium`. In code, `webmcp` can also be a function that installs the implementation on a host in the same process.
-- **Properties:** with fast-check, through each remote binding: concurrent calls each get exactly their own outcome, and a cancellation changes only its own call.
+- **Properties:** with fast-check, through MCP with each transport and through HTTP: concurrent calls each get exactly their own outcome, and a cancellation changes only its own call.
 
 The checks wait for states that they can observe, not for times. Before a check cancels a call to `fixture.hold`, it waits until `fixture.held` gives the key of the call, or, for the CLI, until the marker file of the call exists. Each check has one deadline: `--deadline`, or `deadline` in code, in milliseconds. The default is 30 000. A check that does not settle before its deadline fails with "did not settle", and the check stops what it started. This cleanup has a deadline of the same length, so `conform` always returns. The deadline never makes a check pass.
 

package/dist/conform/check.d.ts

@@ -35,6 +35,7 @@ export declare class Checks {
  * Read a state until `done` is true for it, and give that value. The read and the pause between two reads stop when the
  * signal of the check aborts.
  */
+export declare function until<T, Done extends T>(what: string, read: () => Promise<T>, done: (value: T) => value is Done, signal: AbortSignal): Promise<Done>;
 export declare function until<T>(what: string, read: () => Promise<T>, done: (value: T) => boolean, signal: AbortSignal): Promise<T>;
 /** Settle as the promise does, or reject with the reason of the signal when it aborts first. */
 export declare function abortable<T>(promise: Promise<T>, signal: AbortSignal): Promise<T>;

package/dist/conform/check.js

@@ -60,10 +60,6 @@ var Checks = class {
 		}
 	}
 };
-/**
-* Read a state until `done` is true for it, and give that value. The read and the pause between two reads stop when the
-* signal of the check aborts.
-*/
 async function until(what, read, done, signal) {
 	let last;
 	try {

package/dist/conform/index.d.ts

@@ -9,6 +9,11 @@ export type { TestHost, WebMcpInstall } from "./webmcp.js";
 export interface ConformOptions {
     /** The URL of the MCP server, for example `http://localhost:8787/mcp`. */
     readonly mcp?: string | undefined;
+    /**
+     * The command that starts the MCP server through standard input and standard output, for example
+     * `["node", "fixture-mcp-stdio.ts"]`. Each check starts its own process.
+     */
+    readonly mcpStdio?: readonly string[] | undefined;
     /** The base URL of the HTTP API, before `/capabilities`. */
     readonly http?: string | undefined;
     /** The command that starts the command line, for example `["node", "fixture-cli.ts"]`. */

package/dist/conform/index.js

@@ -3,6 +3,7 @@ import { checkCli } from "./cli.js";
 import { checkHttp } from "./http.js";
 import { checkMcp } from "./mcp.js";
 import { checkProperties, httpInvoke, mcpInvoke } from "./properties.js";
+import { checkMcpStdio } from "./mcp-stdio.js";
 import { browserDriver, checkWebMcp, processDriver } from "./webmcp.js";
 import { serve } from "./serve.js";
 //#region src/conform/index.ts
@@ -26,6 +27,7 @@ async function conform(options) {
 			await mcp.close();
 		}
 	}
+	if (options.mcpStdio !== void 0) for (const checks of await checkMcpStdio(options.mcpStdio, { deadline })) results.push(...checks.results);
 	if (options.http !== void 0) {
 		results.push(...(await checkHttp(options.http, {
 			maximumBytes,

package/dist/conform/mcp-stdio.d.ts

@@ -0,0 +1,4 @@
+import { Checks } from "./check.js";
+export declare function checkMcpStdio(command: readonly string[], options: {
+    readonly deadline: number;
+}): Promise<readonly Checks[]>;

package/dist/conform/mcp-stdio.js

@@ -0,0 +1,266 @@
+import { isObject, memberOf } from "../json.js";
+import { Checks, abortable, expect, expectEqual, until } from "./check.js";
+import { checkTools } from "./mcp.js";
+import { checkProperties, clientInvoke, heldKeys } from "./properties.js";
+import { spawn } from "node:child_process";
+import { Client } from "@modelcontextprotocol/client";
+import { randomUUID } from "node:crypto";
+import { StdioClientTransport } from "@modelcontextprotocol/client/stdio";
+//#region src/conform/mcp-stdio.ts
+/**
+* Conformance checks for the MCP binding through standard input and standard output (spec/bindings/mcp.md#stdio). Each
+* check starts the server as a process. The protocol checks use the official MCP client, once with revision 2026-07-28
+* and once with the `initialize` handshake of revision 2025-11-25. The other checks write lines that a client never
+* writes, or end standard input during a call.
+*/
+const RULE = "spec/bindings/mcp.md#stdio";
+/** The two ways that a client opens the session: revision 2026-07-28, or the handshake of revision 2025-11-25. */
+const ERAS = [{
+	revision: "2026-07-28",
+	connects: "an MCP client connects with revision 2026-07-28",
+	options: { versionNegotiation: { mode: { pin: "2026-07-28" } } }
+}, {
+	revision: "2025-11-25",
+	connects: "an MCP client connects with the initialize handshake of revision 2025-11-25",
+	options: {}
+}];
+/** The environment of the process: the environment of `conform`, without the variables that have no value. */
+function environment() {
+	return Object.fromEntries(Object.entries(process.env).flatMap(([name, value]) => value === void 0 ? [] : [[name, value]]));
+}
+/** Start the server and connect an MCP client. `changes` counts each `notifications/tools/list_changed`. */
+async function connect(command, options, changes, signal) {
+	const [program, ...args] = command;
+	if (program === void 0) throw new Error("the command that starts the MCP server is empty");
+	const client = new Client({
+		name: "acid-cat-conform",
+		version: "0.1.0"
+	}, {
+		...options,
+		listChanged: { tools: {
+			autoRefresh: false,
+			debounceMs: 0,
+			onChanged: () => void (changes.count += 1)
+		} }
+	});
+	const transport = new StdioClientTransport({
+		command: program,
+		args,
+		env: environment(),
+		stderr: "ignore"
+	});
+	await client.connect(transport, { signal });
+	return client;
+}
+async function checkMcpStdio(command, options) {
+	const all = [];
+	for (const era of ERAS) {
+		const checks = new Checks(`mcp-stdio ${era.revision}`, options.deadline);
+		all.push(checks);
+		const changes = { count: 0 };
+		let client;
+		await checks.run(era.connects, RULE, async (signal) => {
+			client = await connect(command, era.options, changes, signal);
+			expectEqual(client.getNegotiatedProtocolVersion(), era.revision, "the revision of the session");
+		});
+		if (client === void 0) continue;
+		const mcp = client;
+		try {
+			await checkTools(checks, mcp);
+			await checkChanges(checks, mcp, changes);
+			await checkCancellation(checks, mcp);
+			all.push(await checkProperties(`mcp-stdio ${era.revision} properties`, clientInvoke(mcp), options.deadline));
+		} finally {
+			await mcp.close();
+		}
+	}
+	all.push(await checkLines(command, options));
+	return all;
+}
+/** The server tells the client each change of the set of available tools. */
+async function checkChanges(checks, mcp, changes) {
+	const set = (on, signal) => mcp.callTool({
+		name: "fixture.switch.set",
+		arguments: { on }
+	}, { signal });
+	const listsToggle = async (signal) => (await mcp.listTools(void 0, { signal })).tools.some((tool) => tool.name === "fixture.toggle");
+	await checks.run("notifications/tools/list_changed comes when a capability becomes unavailable or available", RULE, async (signal) => {
+		try {
+			const before = changes.count;
+			await set(false, signal);
+			await until("notifications/tools/list_changed comes", async () => changes.count, (count) => count > before, signal);
+			expect(!await listsToggle(signal), "fixture.toggle must not be listed while it is unavailable");
+			const off = changes.count;
+			await set(true, signal);
+			await until("notifications/tools/list_changed comes again", async () => changes.count, (count) => count > off, signal);
+			expect(await listsToggle(signal), "fixture.toggle must be listed when it is available again");
+		} finally {
+			await set(true, AbortSignal.timeout(checks.deadline));
+		}
+	});
+}
+/** `notifications/cancelled` cancels a call. The official client sends it when the signal of a call aborts. */
+async function checkCancellation(checks, mcp) {
+	const invoke = clientInvoke(mcp);
+	await checks.run("notifications/cancelled cancels the call", RULE, async (signal) => {
+		const key = randomUUID();
+		const controller = new AbortController();
+		const call = invoke("fixture.hold", { key }, AbortSignal.any([controller.signal, signal])).catch(() => void 0);
+		try {
+			await until("fixture.held gives the key of the call", () => heldKeys(invoke, signal), (held) => held.includes(key), signal);
+			controller.abort();
+			await call;
+			await until("the cancelled call stops holding", () => heldKeys(invoke, signal), (held) => !held.includes(key), signal);
+		} finally {
+			await invoke("fixture.release", { key }, AbortSignal.timeout(checks.deadline)).catch(() => void 0);
+		}
+	});
+}
+/**
+* A server process with its standard input and output, one JSON-RPC message on each line. `lines` holds each line of
+* standard output. When the signal aborts, the process is killed.
+*/
+function startRaw(command, signal) {
+	const [program, ...args] = command;
+	if (program === void 0) throw new Error("the command that starts the MCP server is empty");
+	const child = spawn(program, args, {
+		stdio: [
+			"pipe",
+			"pipe",
+			"ignore"
+		],
+		signal,
+		killSignal: "SIGKILL"
+	});
+	const lines = [];
+	const messages = [];
+	let rest = "";
+	child.stdout.on("data", (chunk) => {
+		const parts = (rest + chunk.toString()).split("\n");
+		rest = parts.pop() ?? "";
+		for (const line of parts) {
+			lines.push(line);
+			try {
+				messages.push(JSON.parse(line));
+			} catch {
+				messages.push(void 0);
+			}
+		}
+	});
+	child.stdin.on("error", () => void 0);
+	const exited = new Promise((resolve, reject) => {
+		child.on("error", (error) => reject(signal.aborted ? /* @__PURE__ */ new Error("waiting until the MCP server exits") : error));
+		child.on("close", (code, exitSignal) => resolve({
+			code,
+			signal: exitSignal
+		}));
+	});
+	exited.catch(() => void 0);
+	let next = 0;
+	const write = (line) => child.stdin.write(`${line}\n`);
+	/** Send a request and wait for its response. */
+	const request = async (method, params = {}) => {
+		const id = `conform-${next += 1}`;
+		write(JSON.stringify({
+			jsonrpc: "2.0",
+			id,
+			method,
+			params
+		}));
+		return until(`the response to ${method}`, async () => messages.find((message) => memberOf(message, "id") === id), isObject, signal);
+	};
+	return {
+		child,
+		lines,
+		messages,
+		write,
+		request,
+		exited
+	};
+}
+/** The `initialize` handshake of revision 2025-11-25, through a raw process. */
+async function handshake(server, revision = "2025-11-25") {
+	const response = await server.request("initialize", {
+		protocolVersion: revision,
+		capabilities: {},
+		clientInfo: {
+			name: "acid-cat-conform",
+			version: "0.1.0"
+		}
+	});
+	server.write(JSON.stringify({
+		jsonrpc: "2.0",
+		method: "notifications/initialized"
+	}));
+	return response;
+}
+async function checkLines(command, options) {
+	const checks = new Checks("mcp-stdio", options.deadline);
+	/** Run a body with a new server process, and kill the process at the end. */
+	const withServer = (body) => async (signal) => {
+		const controller = new AbortController();
+		const server = startRaw(command, AbortSignal.any([controller.signal, signal]));
+		try {
+			await body(server, signal);
+		} finally {
+			controller.abort();
+		}
+	};
+	await checks.run("initialize with a revision that the server does not serve gives a revision that it serves", RULE, withServer(async (server) => {
+		const response = await handshake(server, "1999-01-01");
+		const version = memberOf(memberOf(response, "result"), "protocolVersion");
+		expect(typeof version === "string" && version !== "1999-01-01", `expected another revision, got ${JSON.stringify(response)}`);
+	}));
+	await checks.run("a line that is not JSON gets the error -32700, and the session stays open", RULE, withServer(async (server, signal) => {
+		await handshake(server);
+		server.write("{");
+		const parseError = await until("the error -32700", async () => server.messages.find((message) => memberOf(memberOf(message, "error"), "code") === -32700), isObject, signal);
+		expectEqual(parseError["id"], null, "the id of the error");
+		const echo = await server.request("tools/call", {
+			name: "fixture.echo",
+			arguments: { text: "after" }
+		});
+		expectEqual(memberOf(memberOf(echo, "result"), "structuredContent"), { text: "after" }, "structuredContent after the error");
+	}));
+	await checks.run("standard output has only JSON-RPC messages, also after a defect", RULE, withServer(async (server) => {
+		await handshake(server);
+		await server.request("tools/list");
+		await server.request("tools/call", {
+			name: "fixture.crash",
+			arguments: {}
+		});
+		await server.request("tools/call", {
+			name: "fixture.echo",
+			arguments: { text: "last" }
+		});
+		const other = server.messages.findIndex((message) => memberOf(message, "jsonrpc") !== "2.0");
+		expect(other === -1, `standard output must have only JSON-RPC messages, got the line ${JSON.stringify(server.lines[other])}`);
+	}));
+	await checks.run("the server exits when standard input ends, also during a call", RULE, withServer(async (server, signal) => {
+		await handshake(server);
+		const key = randomUUID();
+		server.write(JSON.stringify({
+			jsonrpc: "2.0",
+			id: "conform-hold",
+			method: "tools/call",
+			params: {
+				name: "fixture.hold",
+				arguments: { key }
+			}
+		}));
+		const held = async () => {
+			const response = await server.request("tools/call", {
+				name: "fixture.held",
+				arguments: {}
+			});
+			return memberOf(memberOf(memberOf(response, "result"), "structuredContent"), "keys");
+		};
+		await until("fixture.held gives the key of the call", held, (keys) => Array.isArray(keys) && keys.includes(key), signal);
+		server.child.stdin.end();
+		const exit = await abortable(server.exited, signal);
+		expect(exit.signal === null, `the process must exit, not end by the signal ${exit.signal}`);
+	}));
+	return checks;
+}
+//#endregion
+export { checkMcpStdio };

package/dist/conform/mcp.d.ts

@@ -1,6 +1,6 @@
 /**
- * Conformance checks for the MCP binding (spec/bindings/mcp.md). The protocol checks use the official MCP client,
- * with revision 2026-07-28. The rejection checks send requests that a client never sends.
+ * Conformance checks for the MCP binding through HTTP (spec/bindings/mcp.md). The protocol checks use the official MCP
+ * client, with revision 2026-07-28. The rejection checks send requests that a client never sends.
  */
 import { Client } from "@modelcontextprotocol/client";
 import { Checks } from "./check.js";
@@ -10,3 +10,8 @@ export declare function checkMcp(url: string, options: {
     readonly maximumBytes: number;
     readonly deadline: number;
 }): Promise<Checks>;
+/**
+ * The checks of the tools and their outcomes, through a connected client (spec/bindings/mcp.md#tools). Each transport
+ * runs them.
+ */
+export declare function checkTools(checks: Checks, mcp: Client): Promise<void>;

package/dist/conform/mcp.js

@@ -3,8 +3,8 @@ import { Checks, FORBIDDEN_ORIGIN, expect, expectEqual, fixture, idsOf, sorted }
 import { Client, StreamableHTTPClientTransport } from "@modelcontextprotocol/client";
 //#region src/conform/mcp.ts
 /**
-* Conformance checks for the MCP binding (spec/bindings/mcp.md). The protocol checks use the official MCP client,
-* with revision 2026-07-28. The rejection checks send requests that a client never sends.
+* Conformance checks for the MCP binding through HTTP (spec/bindings/mcp.md). The protocol checks use the official MCP
+* client, with revision 2026-07-28. The rejection checks send requests that a client never sends.
 */
 const RULE = "spec/bindings/mcp.md";
 /** A connected MCP client. */
@@ -24,16 +24,69 @@ const textOf = (result) => {
 async function checkMcp(url, options) {
 	const checks = new Checks("mcp", options.deadline);
 	let client;
-	await checks.run("an MCP client connects with revision 2026-07-28", `${RULE}#server`, async (signal) => {
+	await checks.run("an MCP client connects with revision 2026-07-28", `${RULE}#http`, async (signal) => {
 		client = await mcpClient(url, signal);
 	});
 	if (client === void 0) return checks;
 	const mcp = client;
+	await checkTools(checks, mcp);
+	await mcp.close();
+	const post = (signal, { headers = {}, body }) => fetch(url, {
+		method: "POST",
+		body,
+		headers: {
+			"Content-Type": "application/json",
+			...headers
+		},
+		signal
+	});
+	const rejection = async (response, status, code) => {
+		expectEqual(response.status, status, "status");
+		expectEqual(response.headers.get("Cache-Control"), "no-store", "Cache-Control");
+		if (code !== void 0) expectEqual(memberOf(memberOf(await readJson(response), "error"), "code"), code, "JSON-RPC error code");
+	};
+	await checks.run("a method other than POST is rejected with 405", `${RULE}#http`, async (signal) => {
+		const response = await fetch(url, { signal });
+		await rejection(response, 405);
+		expectEqual(response.headers.get("Allow"), "POST", "Allow");
+	});
+	await checks.run("an origin that is not allowed is rejected with 403", `${RULE}#http`, async (signal) => {
+		await rejection(await post(signal, {
+			headers: { Origin: FORBIDDEN_ORIGIN },
+			body: "{}"
+		}), 403);
+	});
+	await checks.run("a media type other than JSON is rejected with 415", `${RULE}#http`, async (signal) => {
+		await rejection(await post(signal, {
+			headers: { "Content-Type": "text/plain" },
+			body: "{}"
+		}), 415);
+	});
+	await checks.run("a body over the limit is rejected with 413 and -32600", `${RULE}#http`, async (signal) => {
+		await rejection(await post(signal, { body: " ".repeat(options.maximumBytes + 1) }), 413, -32600);
+	});
+	await checks.run("a body that is not JSON is rejected with 400 and -32700", `${RULE}#http`, async (signal) => {
+		await rejection(await post(signal, { body: "{" }), 400, -32700);
+	});
+	await checks.run("a body that is not UTF-8 is rejected with 400", `${RULE}#http`, async (signal) => {
+		await rejection(await post(signal, { body: new Uint8Array([
+			123,
+			255,
+			125
+		]) }), 400);
+	});
+	return checks;
+}
+/**
+* The checks of the tools and their outcomes, through a connected client (spec/bindings/mcp.md#tools). Each transport
+* runs them.
+*/
+async function checkTools(checks, mcp) {
 	const call = (signal, name, args) => mcp.callTool({
 		name,
 		arguments: args
 	}, { signal });
-	await checks.run("server/discover gives the description of the catalog as instructions", `${RULE}#server`, () => {
+	await checks.run("the instructions are the description of the catalog", `${RULE}#server`, () => {
 		expectEqual(mcp.getInstructions(), fixture.description, "instructions");
 	});
 	await checks.run("tools/list gives each available capability of the view", `${RULE}#tools`, async (signal) => {
@@ -84,55 +137,9 @@ async function checkMcp(url, options) {
 			const { tools } = await mcp.listTools(void 0, { signal });
 			expect(!tools.some((tool) => tool.name === "fixture.toggle"), "fixture.toggle must not be listed while it is unavailable");
 		} finally {
-			await call(AbortSignal.timeout(options.deadline), "fixture.switch.set", { on: true });
+			await call(AbortSignal.timeout(checks.deadline), "fixture.switch.set", { on: true });
 		}
 	});
-	await mcp.close();
-	const post = (signal, { headers = {}, body }) => fetch(url, {
-		method: "POST",
-		body,
-		headers: {
-			"Content-Type": "application/json",
-			...headers
-		},
-		signal
-	});
-	const rejection = async (response, status, code) => {
-		expectEqual(response.status, status, "status");
-		expectEqual(response.headers.get("Cache-Control"), "no-store", "Cache-Control");
-		if (code !== void 0) expectEqual(memberOf(memberOf(await readJson(response), "error"), "code"), code, "JSON-RPC error code");
-	};
-	await checks.run("a method other than POST is rejected with 405", `${RULE}#server`, async (signal) => {
-		const response = await fetch(url, { signal });
-		await rejection(response, 405);
-		expectEqual(response.headers.get("Allow"), "POST", "Allow");
-	});
-	await checks.run("an origin that is not allowed is rejected with 403", `${RULE}#server`, async (signal) => {
-		await rejection(await post(signal, {
-			headers: { Origin: FORBIDDEN_ORIGIN },
-			body: "{}"
-		}), 403);
-	});
-	await checks.run("a media type other than JSON is rejected with 415", `${RULE}#server`, async (signal) => {
-		await rejection(await post(signal, {
-			headers: { "Content-Type": "text/plain" },
-			body: "{}"
-		}), 415);
-	});
-	await checks.run("a body over the limit is rejected with 413 and -32600", `${RULE}#server`, async (signal) => {
-		await rejection(await post(signal, { body: " ".repeat(options.maximumBytes + 1) }), 413, -32600);
-	});
-	await checks.run("a body that is not JSON is rejected with 400 and -32700", `${RULE}#server`, async (signal) => {
-		await rejection(await post(signal, { body: "{" }), 400, -32700);
-	});
-	await checks.run("a body that is not UTF-8 is rejected with 400", `${RULE}#server`, async (signal) => {
-		await rejection(await post(signal, { body: new Uint8Array([
-			123,
-			255,
-			125
-		]) }), 400);
-	});
-	return checks;
 }
 //#endregion
-export { checkMcp, mcpClient };
+export { checkMcp, checkTools, mcpClient };

package/dist/conform/properties.d.ts

@@ -1,4 +1,5 @@
 import type { Outcome } from "@acid-cat/spec-ts";
+import type { Client } from "@modelcontextprotocol/client";
 import type { JsonObject } from "../json.js";
 import { Checks } from "./check.js";
 /** A call through one binding. When the signal aborts, the client stops the call and rejects with the reason of the signal. */
@@ -8,4 +9,8 @@ export declare function mcpInvoke(url: string, signal: AbortSignal): Promise<{
     readonly invoke: Invoke;
     close(): Promise<void>;
 }>;
+/** Calls through a connected MCP client, with any transport. */
+export declare function clientInvoke(client: Client): Invoke;
+/** The keys of the calls that hold now, as fixture.held gives them through the binding. */
+export declare function heldKeys(invoke: Invoke, signal: AbortSignal): Promise<readonly string[]>;
 export declare function checkProperties(binding: string, invoke: Invoke, deadline: number): Promise<Checks>;

package/dist/conform/properties.js

@@ -26,32 +26,36 @@ function httpInvoke(base) {
 async function mcpInvoke(url, signal) {
 	const client = await mcpClient(url, signal);
 	return {
-		invoke: async (id, input, signal) => {
-			try {
-				const result = await client.callTool({
-					name: id,
-					arguments: input
-				}, signal ? { signal } : void 0);
-				const first = result.content[0];
-				const body = parseJson(first?.type === "text" ? first.text : "null");
-				if (result.isError !== true) return {
-					ok: true,
-					value: result.structuredContent ?? body
-				};
-				if (!isOutcome(body)) throw new Error(`the error result of ${id} gave ${JSON.stringify(body)}, which is not an outcome`);
-				return body;
-			} catch (error) {
-				if (signal?.aborted && error instanceof SdkError && error.message === String(signal.reason)) throw signal.reason;
-				if (memberOf(error, "code") === -32602) return {
-					kind: "unknown-capability",
-					message: String(error)
-				};
-				throw error;
-			}
-		},
+		invoke: clientInvoke(client),
 		close: () => client.close()
 	};
 }
+/** Calls through a connected MCP client, with any transport. */
+function clientInvoke(client) {
+	return async (id, input, signal) => {
+		try {
+			const result = await client.callTool({
+				name: id,
+				arguments: input
+			}, signal ? { signal } : void 0);
+			const first = result.content[0];
+			const body = parseJson(first?.type === "text" ? first.text : "null");
+			if (result.isError !== true) return {
+				ok: true,
+				value: result.structuredContent ?? body
+			};
+			if (!isOutcome(body)) throw new Error(`the error result of ${id} gave ${JSON.stringify(body)}, which is not an outcome`);
+			return body;
+		} catch (error) {
+			if (signal?.aborted && error instanceof SdkError && error.message === String(signal.reason)) throw signal.reason;
+			if (memberOf(error, "code") === -32602) return {
+				kind: "unknown-capability",
+				message: String(error)
+			};
+			throw error;
+		}
+	};
+}
 const operation = fc.oneof(fc.string({ maxLength: 40 }).map((text) => ({
 	kind: "echo",
 	text
@@ -167,4 +171,4 @@ async function checkProperties(binding, invoke, deadline) {
 	return checks;
 }
 //#endregion
-export { checkProperties, httpInvoke, mcpInvoke };
+export { checkProperties, clientInvoke, heldKeys, httpInvoke, mcpInvoke };

package/dist/json/package.json.js

@@ -1,4 +1,4 @@
 //#region package.json
-var version = "0.8.0";
+var version = "0.9.0";
 //#endregion
 export { version };

package/dist/main.js

@@ -70,6 +70,7 @@ const viewCommand = Command.make("view", {
 const url = (name, description) => Flag.String(name).pipe(Flag.withDescription(description), Flag.optional);
 const conformCommand = Command.make("conform", {
 	mcp: url("mcp", "The URL of the MCP server"),
+	mcpStdio: url("mcp-stdio", "The command that starts the MCP server through standard input and output, for example \"node fixture-mcp-stdio.ts\""),
 	http: url("http", "The base URL of the HTTP API, before /capabilities"),
 	cli: url("cli", "The command that starts the command line, for example \"node fixture-cli.ts\""),
 	webmcp: url("webmcp", "The URL of a web page that serves the app target. It runs in Chromium, through Playwright"),
@@ -77,17 +78,18 @@ const conformCommand = Command.make("conform", {
 	deadline: Flag.Int("deadline").pipe(Flag.withDescription("The time, in milliseconds, that each check has to settle. A check that does not settle in this time fails"), Flag.withDefault(DEADLINE))
 }, Effect.fn(function* (options) {
 	const value = (option) => Option.isSome(option) ? option.value : void 0;
-	const command = value(options.cli)?.split(/\s+/).filter((word) => word !== "");
+	const words = (option) => value(option)?.split(/\s+/).filter((word) => word !== "");
 	const results = yield* Effect.promise(() => conform({
 		mcp: value(options.mcp),
+		mcpStdio: words(options.mcpStdio),
 		http: value(options.http),
-		cli: command,
+		cli: words(options.cli),
 		webmcp: value(options.webmcp),
 		maximumBytes: options.maximumBytes,
 		deadline: options.deadline
 	}));
 	if (results.length === 0) {
-		yield* Console.error("Give at least one binding: --mcp, --http, --cli or --webmcp.");
+		yield* Console.error("Give at least one binding: --mcp, --mcp-stdio, --http, --cli or --webmcp.");
 		return yield* fail;
 	}
 	for (const result of results) yield* Console.log(`${result.passed ? "✓" : "✗"} ${result.binding}: ${result.name} (${result.rule})${result.detail ? `\n    ${result.detail}` : ""}`);

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@acid-cat/cli",
-  "version": "0.8.0",
+  "version": "0.9.0",
   "description": "The AcidCat command line: check, format and view catalogs, and test implementations.",
   "keywords": [
     "acidcat",
@@ -37,8 +37,8 @@
     "access": "public"
   },
   "dependencies": {
-    "@acid-cat/catalog": "0.8.0",
-    "@acid-cat/spec-ts": "0.8.0",
+    "@acid-cat/catalog": "0.9.0",
+    "@acid-cat/spec-ts": "0.9.0",
     "@effect/platform-node": "4.0.6",
     "@effect/platform-node-shared": "4.0.6",
     "@modelcontextprotocol/client": "2.3.1",