@outfitter/testing 0.2.5 → 0.3.0

package/dist/cli-helpers.js

@@ -1,95 +1,8 @@
 // @bun
-// packages/testing/src/cli-helpers.ts
-class ExitError extends Error {
-  code;
-  constructor(code) {
-    super(`Process exited with code ${code}`);
-    this.code = code;
-  }
-}
-async function captureCLI(fn) {
-  const stdoutChunks = [];
-  const stderrChunks = [];
-  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
-  const originalStderrWrite = process.stderr.write.bind(process.stderr);
-  const originalExit = process.exit.bind(process);
-  const originalConsoleLog = console.log;
-  const originalConsoleError = console.error;
-  process.stdout.write = (chunk, _encoding, cb) => {
-    stdoutChunks.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
-    if (typeof cb === "function")
-      cb();
-    return true;
-  };
-  process.stderr.write = (chunk, _encoding, cb) => {
-    stderrChunks.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
-    if (typeof cb === "function")
-      cb();
-    return true;
-  };
-  console.log = (...args) => {
-    const line = `${args.map(String).join(" ")}
-`;
-    stdoutChunks.push(new TextEncoder().encode(line));
-  };
-  console.error = (...args) => {
-    const line = `${args.map(String).join(" ")}
-`;
-    stderrChunks.push(new TextEncoder().encode(line));
-  };
-  process.exit = (code) => {
-    throw new ExitError(code ?? 0);
-  };
-  let exitCode = 0;
-  try {
-    await fn();
-  } catch (error) {
-    if (error instanceof ExitError) {
-      exitCode = error.code;
-    } else {
-      exitCode = 1;
-    }
-  } finally {
-    process.stdout.write = originalStdoutWrite;
-    process.stderr.write = originalStderrWrite;
-    process.exit = originalExit;
-    console.log = originalConsoleLog;
-    console.error = originalConsoleError;
-  }
-  const decoder = new TextDecoder("utf-8");
-  return {
-    stdout: decoder.decode(concatChunks(stdoutChunks)),
-    stderr: decoder.decode(concatChunks(stderrChunks)),
-    exitCode
-  };
-}
-function mockStdin(input) {
-  const originalStdin = process.stdin;
-  const encoded = new TextEncoder().encode(input);
-  const mockStream = {
-    async* [Symbol.asyncIterator]() {
-      yield encoded;
-    },
-    fd: 0,
-    isTTY: false
-  };
-  process.stdin = mockStream;
-  return {
-    restore: () => {
-      process.stdin = originalStdin;
-    }
-  };
-}
-function concatChunks(chunks) {
-  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
-  const result = new Uint8Array(totalLength);
-  let offset = 0;
-  for (const chunk of chunks) {
-    result.set(chunk, offset);
-    offset += chunk.length;
-  }
-  return result;
-}
+import {
+  captureCLI,
+  mockStdin
+} from "./shared/@outfitter/testing-xsfjh1n3.js";
 export {
   mockStdin,
   captureCLI

package/dist/index.d.ts

@@ -1,6 +1,8 @@
+import { TestCommandOptions, TestCommandResult, getTestContext, testCommand } from "./shared/@outfitter/testing-s2fyaxm2.js";
 import { CliTestResult, captureCLI, mockStdin } from "./shared/@outfitter/testing-fyjbwn80.js";
+import { TestToolOptions, TestToolResult, testTool } from "./shared/@outfitter/testing-136ebq11.js";
 import { createFixture, loadFixture, withEnv, withTempDir } from "./shared/@outfitter/testing-98fsks4n.js";
-import { McpHarness, McpTestHarnessOptions, McpToolResponse, createMCPTestHarness, createMcpHarness } from "./shared/@outfitter/testing-5gdrv3f5.js";
+import { McpHarness, McpTestHarnessOptions, McpToolResponse, createMCPTestHarness, createMcpHarness } from "./shared/@outfitter/testing-jc0ppq2z.js";
 import { LogEntry, TestLogger, createTestConfig, createTestContext, createTestLogger } from "./shared/@outfitter/testing-jdfrrv33.js";
 import { CliHarness, CliResult, createCliHarness } from "./shared/@outfitter/testing-xaxkt6c9.js";
-export { withTempDir, withEnv, mockStdin, loadFixture, createTestLogger, createTestContext, createTestConfig, createMCPTestHarness as createMcpTestHarness, createMcpHarness, createMCPTestHarness, createFixture, createCliHarness, captureCLI, TestLogger, McpToolResponse, McpTestHarnessOptions, McpHarness, LogEntry, CliTestResult, CliResult, CliHarness };
+export { withTempDir, withEnv, testTool, testCommand, mockStdin, loadFixture, getTestContext, createTestLogger, createTestContext, createTestConfig, createMCPTestHarness as createMcpTestHarness, createMcpHarness, createMCPTestHarness, createFixture, createCliHarness, captureCLI, TestToolResult, TestToolOptions, TestLogger, TestCommandResult, TestCommandOptions, McpToolResponse, McpTestHarnessOptions, McpHarness, LogEntry, CliTestResult, CliResult, CliHarness };

package/dist/index.js

@@ -2,4 +2,6 @@ export { createFixture, loadFixture, withEnv, withTempDir } from "./fixtures.js"
 export { createCliHarness } from "./cli-harness.js";
 export { captureCLI, mockStdin } from "./cli-helpers.js";
 export { createMCPTestHarness, createMcpHarness, createMcpTestHarness } from "./mcp-harness.js";
+export { getTestContext, testCommand } from "./test-command.js";
+export { testTool } from "./test-tool.js";
 export { createTestConfig, createTestContext, createTestLogger } from "./mock-factories.js";

package/dist/mcp-harness.d.ts

@@ -1,2 +1,2 @@
-import { McpHarness, McpHarnessOptions, McpTestHarnessOptions, McpToolResponse, createMCPTestHarness, createMcpHarness } from "./shared/@outfitter/testing-5gdrv3f5.js";
+import { McpHarness, McpHarnessOptions, McpTestHarnessOptions, McpToolResponse, createMCPTestHarness, createMcpHarness } from "./shared/@outfitter/testing-jc0ppq2z.js";
 export { createMCPTestHarness as createMcpTestHarness, createMcpHarness, createMCPTestHarness, McpToolResponse, McpTestHarnessOptions, McpHarnessOptions, McpHarness };

package/dist/mcp-harness.js

@@ -15,6 +15,9 @@ function createMcpHarness(server, options = {}) {
     listTools() {
       return server.getTools();
     },
+    listResources() {
+      return server.getResources();
+    },
     searchTools(query) {
       const normalized = query.trim().toLowerCase();
       const tools = server.getTools();

package/dist/mock-factories.js

@@ -1,112 +1,9 @@
 // @bun
-// packages/testing/src/mock-factories.ts
 import {
-  generateRequestId
-} from "@outfitter/contracts";
-function createTestLogger(context = {}) {
-  return createTestLoggerWithContext(context, []);
-}
-function createTestLoggerWithContext(context, logs) {
-  const write = (level, message, data) => {
-    const merged = { ...context, ...data };
-    const entry = {
-      level,
-      message
-    };
-    if (Object.keys(merged).length > 0) {
-      entry.data = merged;
-    }
-    logs.push(entry);
-  };
-  return {
-    logs,
-    clear() {
-      logs.length = 0;
-    },
-    trace: (message, metadata) => {
-      write("trace", message, metadata);
-    },
-    debug: (message, metadata) => {
-      write("debug", message, metadata);
-    },
-    info: (message, metadata) => {
-      write("info", message, metadata);
-    },
-    warn: (message, metadata) => {
-      write("warn", message, metadata);
-    },
-    error: (message, metadata) => {
-      write("error", message, metadata);
-    },
-    fatal: (message, metadata) => {
-      write("fatal", message, metadata);
-    },
-    child(childContext) {
-      return createTestLoggerWithContext({ ...context, ...childContext }, logs);
-    }
-  };
-}
-function createTestConfig(schema, values) {
-  const parsed = schema.safeParse(values);
-  let data;
-  if (parsed.success) {
-    data = parsed.data;
-  } else {
-    const maybePartial = schema.partial;
-    if (typeof maybePartial !== "function") {
-      throw parsed.error;
-    }
-    const partialSchema = maybePartial.call(schema);
-    const partialParsed = partialSchema.safeParse(values);
-    if (!partialParsed.success) {
-      throw partialParsed.error;
-    }
-    data = partialParsed.data;
-  }
-  return {
-    get(key) {
-      return getPath(data, key);
-    },
-    getRequired(key) {
-      const value = getPath(data, key);
-      if (value === undefined) {
-        throw new Error(`Missing required config value: ${key}`);
-      }
-      return value;
-    }
-  };
-}
-function createTestContext(overrides = {}) {
-  const logger = overrides.logger ?? createTestLogger();
-  const requestId = overrides.requestId ?? generateRequestId();
-  const context = {
-    requestId,
-    logger,
-    cwd: overrides.cwd ?? process.cwd(),
-    env: overrides.env ?? { ...process.env }
-  };
-  if (overrides.config !== undefined) {
-    context.config = overrides.config;
-  }
-  if (overrides.signal !== undefined) {
-    context.signal = overrides.signal;
-  }
-  if (overrides.workspaceRoot !== undefined) {
-    context.workspaceRoot = overrides.workspaceRoot;
-  }
-  return context;
-}
-function getPath(obj, key) {
-  const parts = key.split(".").filter((part) => part.length > 0);
-  let current = obj;
-  for (const part of parts) {
-    if (current === null || typeof current !== "object") {
-      return;
-    }
-    current = current[part];
-  }
-  return current;
-}
+  createTestConfig,
+  createTestContext,
+  createTestLogger
+} from "./shared/@outfitter/testing-xcd5p1gm.js";
 export {
   createTestLogger,
   createTestContext,

package/dist/shared/@outfitter/testing-136ebq11.d.ts

@@ -0,0 +1,123 @@
+import { HandlerContext, MCPHint, OutfitterError, Result, ValidationError } from "@outfitter/contracts";
+import { ToolDefinition } from "@outfitter/mcp";
+/**
+* Options for testTool().
+*/
+interface TestToolOptions {
+	/**
+	* Custom working directory for the handler context.
+	* @deprecated Use `context.cwd` instead.
+	*/
+	readonly cwd?: string;
+	/**
+	* Custom environment variables for the handler context.
+	* @deprecated Use `context.env` instead.
+	*/
+	readonly env?: Readonly<Record<string, string | undefined>>;
+	/**
+	* Custom request ID for the handler context.
+	* @deprecated Use `context.requestId` instead.
+	*/
+	readonly requestId?: string;
+	/**
+	* Full HandlerContext overrides.
+	*
+	* When provided, these values are merged with the default test context.
+	* Takes priority over the individual `cwd`, `env`, and `requestId` options.
+	*
+	* @example
+	* ```typescript
+	* await testTool(tool, input, {
+	*   context: {
+	*     requestId: "test-req-001",
+	*     cwd: "/test/dir",
+	*     logger: createTestLogger(),
+	*   },
+	* });
+	* ```
+	*/
+	readonly context?: Partial<HandlerContext>;
+	/**
+	* Hint generation function for asserting on hints.
+	*
+	* When provided, called with the handler's success result and the result
+	* is attached to the returned `TestToolResult.hints` for assertion.
+	* Returns `MCPHint[]` for MCP tool testing.
+	*
+	* @example
+	* ```typescript
+	* const result = await testTool(tool, input, {
+	*   hints: (result) => [{
+	*     description: "View details",
+	*     tool: "get-details",
+	*     input: { id: result.id },
+	*   }],
+	* });
+	* expect(result.hints).toHaveLength(1);
+	* ```
+	*/
+	readonly hints?: (result: unknown) => MCPHint[];
+}
+/**
+* Enhanced result from testTool() with optional hints.
+*
+* Extends the base `Result` with a `hints` field that contains
+* generated hints when a `hints` function was provided in options.
+*/
+type TestToolResult<
+	TOutput,
+	TError extends OutfitterError
+> = Result<TOutput, TError | InstanceType<typeof ValidationError>> & {
+	/**
+	* Generated hints from the `hints` option function.
+	*
+	* Present when `hints` option is provided and the handler succeeds.
+	* Undefined when no hints option was given or when hints array is empty.
+	*/
+	readonly hints?: MCPHint[] | undefined;
+};
+/**
+* Execute an MCP tool definition with given input.
+*
+* Validates input against the tool's Zod schema. If validation fails,
+* returns an `Err<ValidationError>` without invoking the handler.
+* If validation succeeds, invokes the handler exactly once with a
+* test `HandlerContext` and returns the handler's `Result`.
+*
+* ### v0.5 Enhancements
+*
+* - **`context`**: Full `HandlerContext` overrides (not just cwd/env/requestId).
+*   Takes priority over individual options.
+* - **`hints`**: Hint generation function for asserting on hints.
+*   When provided, the function is called with the handler's success result
+*   and the generated hints are attached to `result.hints`.
+*
+* @param tool - An MCP tool definition with inputSchema and handler
+* @param input - Raw input to validate and pass to the handler
+* @param options - Optional context overrides and hint function
+* @returns The handler's Result with optional hints, or Err<ValidationError> on schema failure
+*
+* @example
+* ```typescript
+* // Basic usage (backward compatible)
+* const result = await testTool(myTool, { a: 2, b: 3 });
+* expect(result.unwrap().sum).toBe(5);
+*
+* // With full context injection
+* const result = await testTool(myTool, input, {
+*   context: { requestId: "test-001", logger: testLogger },
+* });
+*
+* // With hints assertion
+* const result = await testTool(myTool, input, {
+*   hints: (r) => [{ description: "Next step", tool: "other" }],
+* });
+* expect(result.hints).toHaveLength(1);
+* ```
+*/
+declare function testTool<
+	TInput,
+	TOutput,
+	TError extends OutfitterError
+>(tool: ToolDefinition<TInput, TOutput, TError>, input: unknown, options?: TestToolOptions): Promise<TestToolResult<TOutput, TError>>;
+export { TestToolOptions, TestToolResult, testTool };

package/dist/shared/@outfitter/{testing-5gdrv3f5.d.ts → testing-jc0ppq2z.d.ts}

@@ -1,5 +1,5 @@
 import { OutfitterError, Result } from "@outfitter/contracts";
-import { McpError, McpServer, SerializedTool, ToolDefinition } from "@outfitter/mcp";
+import { McpError, McpServer, ResourceDefinition, SerializedTool, ToolDefinition } from "@outfitter/mcp";
 /**
 * MCP tool response content.
 * Matches the MCP protocol shape used in the spec.
@@ -18,9 +18,12 @@ interface McpToolResponse {
 interface McpHarness {
 	/**
 	* Call a tool by name with input parameters.
-	* Returns the MCP-formatted response.
+	* Returns the raw handler output (not MCP-wrapped content).
+	*
+	* Callers who know the handler's return shape can pass a type parameter
+	* to avoid manual narrowing: `harness.callTool<MyOutput>("tool", input)`.
 	*/
-	callTool(name: string, input: Record<string, unknown>): Promise<Result<McpToolResponse, InstanceType<typeof McpError>>>;
+	callTool<T = unknown>(name: string, input: Record<string, unknown>): Promise<Result<T, InstanceType<typeof McpError>>>;
 	/**
 	* List all registered tools with schemas.
 	*/
@@ -34,6 +37,10 @@ interface McpHarness {
 	*/
 	reset(): void;
 	/**
+	* List all registered resources.
+	*/
+	listResources(): ResourceDefinition[];
+	/**
 	* Search tools by name or description (case-insensitive).
 	*/
 	searchTools(query: string): SerializedTool[];

package/dist/shared/@outfitter/testing-s2fyaxm2.d.ts

@@ -0,0 +1,134 @@
+import { CliTestResult } from "./testing-fyjbwn80.js";
+import { CLI } from "@outfitter/cli/command";
+import { CommandEnvelope } from "@outfitter/cli/envelope";
+/**
+* Options for testCommand().
+*/
+interface TestCommandOptions {
+	/**
+	* Environment variables to set during CLI execution.
+	* Variables are restored to their original values after execution.
+	*/
+	readonly env?: Readonly<Record<string, string>>;
+	/**
+	* Pre-parsed input object to convert to CLI arguments.
+	*
+	* Each key-value pair is converted to a `--key value` argument:
+	* - `string` → `--key value`
+	* - `number` → `--key value` (stringified)
+	* - `boolean` → `--key` (true) or omitted (false)
+	* - `string[]` → repeated `--key value1 --key value2`
+	*
+	* Input args are appended after the explicit `args` parameter,
+	* allowing both positional args and input overrides.
+	*
+	* @example
+	* ```typescript
+	* // Converts to: ["greet", "--name", "World"]
+	* await testCommand(cli, ["greet"], { input: { name: "World" } });
+	* ```
+	*/
+	readonly input?: Readonly<Record<string, unknown>>;
+	/**
+	* Mock context object to inject into the command execution.
+	*
+	* When provided, the context is stored in a test injection point
+	* and can be retrieved by context factories via `getTestContext()`.
+	* The context is cleaned up after execution.
+	*
+	* @example
+	* ```typescript
+	* await testCommand(cli, ["status"], {
+	*   context: { db: mockDb, config: testConfig },
+	* });
+	* ```
+	*/
+	readonly context?: Readonly<Record<string, unknown>>;
+	/**
+	* Force JSON output mode by setting OUTFITTER_JSON=1.
+	*
+	* When true, the CLI produces JSON output which is automatically
+	* parsed into the `envelope` field of the result.
+	*/
+	readonly json?: boolean;
+}
+/**
+* Enhanced CLI test result with optional envelope parsing.
+*
+* Extends the base `CliTestResult` with an `envelope` field that
+* contains the parsed `CommandEnvelope` when JSON output is detected.
+*/
+interface TestCommandResult extends CliTestResult {
+	/**
+	* Parsed command envelope from JSON output.
+	*
+	* Present when the command outputs a JSON envelope (either via
+	* `runHandler()` with JSON format or when `json: true` is set).
+	* Undefined for non-JSON output.
+	*/
+	readonly envelope?: CommandEnvelope | undefined;
+}
+/**
+* Retrieve the injected test context, if any.
+*
+* Context factories in builder-pattern commands can call this
+* to use the test-provided context instead of constructing a real one.
+*
+* @returns The injected context, or `undefined` if not in a test
+*
+* @example
+* ```typescript
+* // In your command definition:
+* command("status")
+*   .context(async (input) => {
+*     // Use test context if available, otherwise create real one
+*     const testCtx = getTestContext();
+*     if (testCtx) return testCtx;
+*     return { db: await connectDb() };
+*   })
+* ```
+*/
+declare function getTestContext<T extends Record<string, unknown> = Record<string, unknown>>(): T | undefined;
+/**
+* Execute a CLI instance with given arguments and capture output.
+*
+* Creates a fresh CLI instance from the same program, configured with
+* `onExit` to capture exit codes cleanly. Wraps `captureCLI()` to
+* intercept stdout, stderr, and process.exit during execution.
+* No side effects leak to real stdout, stderr, or process.exit.
+* Global process state is fully restored after each call.
+*
+* ### v0.5 Enhancements
+*
+* - **`input`**: Pre-parsed input object auto-converted to CLI args.
+*   Keys become `--key value` flags, booleans become presence/absence flags.
+* - **`context`**: Mock context object injectable via `getTestContext()`.
+*   Context factories can use this to skip real resource construction in tests.
+* - **`json`**: Forces JSON output mode (OUTFITTER_JSON=1) so the result
+*   includes a parsed `envelope` field.
+* - **`envelope`**: Parsed `CommandEnvelope` from JSON output, available on
+*   the result for structured assertion.
+*
+* @param cli - A CLI instance created by `createCLI()`
+* @param args - Command-line arguments (without the program name prefix)
+* @param options - Optional configuration for the test execution
+* @returns Captured stdout, stderr, exitCode, and optional envelope
+*
+* @example
+* ```typescript
+* // Basic usage (backward compatible)
+* const result = await testCommand(cli, ["hello"]);
+* expect(result.stdout).toContain("Hello!");
+*
+* // With pre-parsed input
+* const result = await testCommand(cli, ["greet"], {
+*   input: { name: "World" },
+* });
+*
+* // With JSON envelope
+* const result = await testCommand(cli, ["info"], { json: true });
+* expect(result.envelope?.ok).toBe(true);
+* ```
+*/
+declare function testCommand(cli: CLI, args: string[], options?: TestCommandOptions): Promise<TestCommandResult>;
+export { TestCommandOptions, TestCommandResult, getTestContext, testCommand };

package/dist/shared/@outfitter/testing-xcd5p1gm.js

@@ -0,0 +1,111 @@
+// @bun
+// packages/testing/src/mock-factories.ts
+import {
+  generateRequestId
+} from "@outfitter/contracts";
+function createTestLogger(context = {}) {
+  return createTestLoggerWithContext(context, []);
+}
+function createTestLoggerWithContext(context, logs) {
+  const write = (level, message, data) => {
+    const merged = { ...context, ...data };
+    const entry = {
+      level,
+      message
+    };
+    if (Object.keys(merged).length > 0) {
+      entry.data = merged;
+    }
+    logs.push(entry);
+  };
+  return {
+    logs,
+    clear() {
+      logs.length = 0;
+    },
+    trace: (message, metadata) => {
+      write("trace", message, metadata);
+    },
+    debug: (message, metadata) => {
+      write("debug", message, metadata);
+    },
+    info: (message, metadata) => {
+      write("info", message, metadata);
+    },
+    warn: (message, metadata) => {
+      write("warn", message, metadata);
+    },
+    error: (message, metadata) => {
+      write("error", message, metadata);
+    },
+    fatal: (message, metadata) => {
+      write("fatal", message, metadata);
+    },
+    child(childContext) {
+      return createTestLoggerWithContext({ ...context, ...childContext }, logs);
+    }
+  };
+}
+function createTestConfig(schema, values) {
+  const parsed = schema.safeParse(values);
+  let data;
+  if (parsed.success) {
+    data = parsed.data;
+  } else {
+    const maybePartial = schema.partial;
+    if (typeof maybePartial !== "function") {
+      throw parsed.error;
+    }
+    const partialSchema = maybePartial.call(schema);
+    const partialParsed = partialSchema.safeParse(values);
+    if (!partialParsed.success) {
+      throw partialParsed.error;
+    }
+    data = partialParsed.data;
+  }
+  return {
+    get(key) {
+      return getPath(data, key);
+    },
+    getRequired(key) {
+      const value = getPath(data, key);
+      if (value === undefined) {
+        throw new Error(`Missing required config value: ${key}`);
+      }
+      return value;
+    }
+  };
+}
+function createTestContext(overrides = {}) {
+  const logger = overrides.logger ?? createTestLogger();
+  const requestId = overrides.requestId ?? generateRequestId();
+  const context = {
+    requestId,
+    logger,
+    cwd: overrides.cwd ?? process.cwd(),
+    env: overrides.env ?? { ...process.env }
+  };
+  if (overrides.config !== undefined) {
+    context.config = overrides.config;
+  }
+  if (overrides.signal !== undefined) {
+    context.signal = overrides.signal;
+  }
+  if (overrides.workspaceRoot !== undefined) {
+    context.workspaceRoot = overrides.workspaceRoot;
+  }
+  return context;
+}
+function getPath(obj, key) {
+  const parts = key.split(".").filter((part) => part.length > 0);
+  let current = obj;
+  for (const part of parts) {
+    if (current === null || typeof current !== "object") {
+      return;
+    }
+    current = current[part];
+  }
+  return current;
+}
+
+export { createTestLogger, createTestConfig, createTestContext };

package/dist/shared/@outfitter/testing-xsfjh1n3.js

@@ -0,0 +1,94 @@
+// @bun
+// packages/testing/src/cli-helpers.ts
+class ExitError extends Error {
+  code;
+  constructor(code) {
+    super(`Process exited with code ${code}`);
+    this.code = code;
+  }
+}
+async function captureCLI(fn) {
+  const stdoutChunks = [];
+  const stderrChunks = [];
+  const originalStdoutWrite = process.stdout.write.bind(process.stdout);
+  const originalStderrWrite = process.stderr.write.bind(process.stderr);
+  const originalExit = process.exit.bind(process);
+  const originalConsoleLog = console.log;
+  const originalConsoleError = console.error;
+  process.stdout.write = (chunk, _encoding, cb) => {
+    stdoutChunks.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
+    if (typeof cb === "function")
+      cb();
+    return true;
+  };
+  process.stderr.write = (chunk, _encoding, cb) => {
+    stderrChunks.push(typeof chunk === "string" ? new TextEncoder().encode(chunk) : chunk);
+    if (typeof cb === "function")
+      cb();
+    return true;
+  };
+  console.log = (...args) => {
+    const line = `${args.map(String).join(" ")}
+`;
+    stdoutChunks.push(new TextEncoder().encode(line));
+  };
+  console.error = (...args) => {
+    const line = `${args.map(String).join(" ")}
+`;
+    stderrChunks.push(new TextEncoder().encode(line));
+  };
+  process.exit = (code) => {
+    throw new ExitError(code ?? 0);
+  };
+  let exitCode = 0;
+  try {
+    await fn();
+  } catch (error) {
+    if (error instanceof ExitError) {
+      exitCode = error.code;
+    } else {
+      exitCode = 1;
+    }
+  } finally {
+    process.stdout.write = originalStdoutWrite;
+    process.stderr.write = originalStderrWrite;
+    process.exit = originalExit;
+    console.log = originalConsoleLog;
+    console.error = originalConsoleError;
+  }
+  const decoder = new TextDecoder("utf-8");
+  return {
+    stdout: decoder.decode(concatChunks(stdoutChunks)),
+    stderr: decoder.decode(concatChunks(stderrChunks)),
+    exitCode
+  };
+}
+function mockStdin(input) {
+  const originalStdin = process.stdin;
+  const encoded = new TextEncoder().encode(input);
+  const mockStream = {
+    async* [Symbol.asyncIterator]() {
+      yield encoded;
+    },
+    fd: 0,
+    isTTY: false
+  };
+  process.stdin = mockStream;
+  return {
+    restore: () => {
+      process.stdin = originalStdin;
+    }
+  };
+}
+function concatChunks(chunks) {
+  const totalLength = chunks.reduce((sum, chunk) => sum + chunk.length, 0);
+  const result = new Uint8Array(totalLength);
+  let offset = 0;
+  for (const chunk of chunks) {
+    result.set(chunk, offset);
+    offset += chunk.length;
+  }
+  return result;
+}
+
+export { captureCLI, mockStdin };

package/dist/test-command.d.ts

@@ -0,0 +1,3 @@
+import { TestCommandOptions, TestCommandResult, getTestContext, testCommand } from "./shared/@outfitter/testing-s2fyaxm2.js";
+import "./shared/@outfitter/testing-fyjbwn80.js";
+export { testCommand, getTestContext, TestCommandResult, TestCommandOptions };

package/dist/test-command.js

@@ -0,0 +1,114 @@
+// @bun
+import {
+  captureCLI
+} from "./shared/@outfitter/testing-xsfjh1n3.js";
+
+// packages/testing/src/test-command.ts
+var injectedTestContext;
+var executionChain = Promise.resolve();
+function getTestContext() {
+  return injectedTestContext;
+}
+async function withProcessLock(run) {
+  const prior = executionChain;
+  let release;
+  executionChain = new Promise((resolve) => {
+    release = resolve;
+  });
+  await prior;
+  try {
+    return await run();
+  } finally {
+    release?.();
+  }
+}
+function inputToArgs(input) {
+  const args = [];
+  for (const [key, value] of Object.entries(input)) {
+    const kebabKey = key.replace(/([a-z0-9])([A-Z])/g, "$1-$2").replace(/([A-Z])([A-Z][a-z])/g, "$1-$2").toLowerCase();
+    const flag = `--${kebabKey}`;
+    if (typeof value === "boolean") {
+      if (value) {
+        args.push(flag);
+      }
+    } else if (Array.isArray(value)) {
+      for (const item of value) {
+        args.push(flag, String(item));
+      }
+    } else if (value !== undefined && value !== null) {
+      args.push(flag, String(value));
+    }
+  }
+  return args;
+}
+function parseEnvelope(stdout, stderr) {
+  const stdoutEnvelope = tryParseEnvelope(stdout);
+  if (stdoutEnvelope)
+    return stdoutEnvelope;
+  const stderrEnvelope = tryParseEnvelope(stderr);
+  if (stderrEnvelope)
+    return stderrEnvelope;
+  return;
+}
+function tryParseEnvelope(text) {
+  const trimmed = text.trim();
+  if (!trimmed.startsWith("{"))
+    return;
+  try {
+    const parsed = JSON.parse(trimmed);
+    if (typeof parsed["ok"] === "boolean" && typeof parsed["command"] === "string") {
+      return parsed;
+    }
+  } catch {}
+  return;
+}
+async function testCommand(cli, args, options) {
+  return withProcessLock(async () => {
+    const originalEnv = { ...process.env };
+    if (options?.env) {
+      for (const [key, value] of Object.entries(options.env)) {
+        process.env[key] = value;
+      }
+    }
+    if (options?.json) {
+      process.env["OUTFITTER_JSON"] = "1";
+    }
+    if (options?.context) {
+      injectedTestContext = { ...options.context };
+    }
+    const inputArgs = options?.input ? inputToArgs(options.input) : [];
+    const fullArgs = [...args, ...inputArgs];
+    const savedArgv = process.argv;
+    const testArgv = ["node", "test", ...fullArgs];
+    process.argv = testArgv;
+    try {
+      const cliResult = await captureCLI(async () => {
+        await cli.parse(testArgv);
+      });
+      const envelope = parseEnvelope(cliResult.stdout, cliResult.stderr);
+      return {
+        ...cliResult,
+        envelope
+      };
+    } finally {
+      process.argv = savedArgv;
+      for (const key of Object.keys(process.env)) {
+        if (!(key in originalEnv)) {
+          delete process.env[key];
+        }
+      }
+      for (const [key, value] of Object.entries(originalEnv)) {
+        if (value === undefined) {
+          delete process.env[key];
+        } else {
+          process.env[key] = value;
+        }
+      }
+      injectedTestContext = undefined;
+    }
+  });
+}
+export {
+  testCommand,
+  getTestContext
+};

package/dist/test-tool.d.ts

@@ -0,0 +1,2 @@
+import { TestToolOptions, TestToolResult, testTool } from "./shared/@outfitter/testing-136ebq11.js";
+export { testTool, TestToolResult, TestToolOptions };

package/dist/test-tool.js

@@ -0,0 +1,58 @@
+// @bun
+import {
+  createTestContext
+} from "./shared/@outfitter/testing-xcd5p1gm.js";
+
+// packages/testing/src/test-tool.ts
+import {
+  formatZodIssues,
+  Result,
+  ValidationError
+} from "@outfitter/contracts";
+async function testTool(tool, input, options) {
+  const parseResult = tool.inputSchema.safeParse(input);
+  if (!parseResult.success) {
+    const errorMessages = formatZodIssues(parseResult.error.issues);
+    return Result.err(new ValidationError({
+      message: `Invalid input: ${errorMessages}`
+    }));
+  }
+  const ctxOverrides = {};
+  if (options?.requestId !== undefined) {
+    ctxOverrides.requestId = options.requestId;
+  }
+  if (options?.cwd !== undefined) {
+    ctxOverrides.cwd = options.cwd;
+  }
+  if (options?.env !== undefined) {
+    ctxOverrides.env = options.env;
+  }
+  if (options?.context) {
+    Object.assign(ctxOverrides, options.context);
+  }
+  const ctx = createTestContext(ctxOverrides);
+  const result = await tool.handler(parseResult.data, ctx);
+  if (options?.hints && result.isOk()) {
+    const hints = options.hints(result.value);
+    if (hints.length > 0) {
+      const enhanced = Object.create(Object.getPrototypeOf(result));
+      for (const key of Reflect.ownKeys(result)) {
+        const descriptor = Object.getOwnPropertyDescriptor(result, key);
+        if (descriptor) {
+          Object.defineProperty(enhanced, key, descriptor);
+        }
+      }
+      Object.defineProperty(enhanced, "hints", {
+        value: hints,
+        enumerable: true,
+        configurable: true,
+        writable: false
+      });
+      return enhanced;
+    }
+  }
+  return result;
+}
+export {
+  testTool
+};

package/package.json

@@ -1,25 +1,11 @@
 {
   "name": "@outfitter/testing",
-  "version": "0.2.5",
   "description": "Test harnesses, fixtures, and utilities for Outfitter packages",
-  "keywords": [
-    "fixtures",
-    "harness",
-    "outfitter",
-    "testing",
-    "typescript"
-  ],
-  "license": "MIT",
-  "repository": {
-    "type": "git",
-    "url": "https://github.com/outfitter-dev/outfitter.git",
-    "directory": "packages/testing"
-  },
+  "version": "0.3.0",
+  "type": "module",
   "files": [
     "dist"
   ],
-  "type": "module",
-  "sideEffects": false,
   "module": "./dist/index.js",
   "types": "./dist/index.d.ts",
   "exports": {
@@ -59,13 +45,39 @@
         "default": "./dist/mock-factories.js"
       }
     },
-    "./package.json": "./package.json"
+    "./package.json": "./package.json",
+    "./test-command": {
+      "import": {
+        "types": "./dist/test-command.d.ts",
+        "default": "./dist/test-command.js"
+      }
+    },
+    "./test-tool": {
+      "import": {
+        "types": "./dist/test-tool.d.ts",
+        "default": "./dist/test-tool.js"
+      }
+    }
   },
+  "keywords": [
+    "fixtures",
+    "harness",
+    "outfitter",
+    "testing",
+    "typescript"
+  ],
+  "license": "MIT",
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/outfitter-dev/outfitter.git",
+    "directory": "packages/testing"
+  },
+  "sideEffects": false,
   "publishConfig": {
     "access": "public"
   },
   "scripts": {
-    "build": "cd ../.. && bunup --filter @outfitter/testing",
+    "build": "cd ../.. && bash ./scripts/run-bunup-with-lock.sh bunup --filter @outfitter/testing",
     "lint": "oxlint ./src",
     "lint:fix": "oxlint --fix ./src",
     "test": "bun test",
@@ -74,8 +86,9 @@
     "prepublishOnly": "bun ../../scripts/check-publish-manifest.ts"
   },
   "dependencies": {
-    "@outfitter/contracts": "0.4.2",
-    "@outfitter/mcp": "0.4.3",
+    "@outfitter/cli": "1.0.0",
+    "@outfitter/contracts": "0.5.0",
+    "@outfitter/mcp": "0.5.0",
     "zod": "^4.3.5"
   },
   "devDependencies": {