Merge pull request #40 from runbasehq/dev

feat: add terminal UI for test observability

Author: fveiraswww

.github/workflows/release.yml

@@ -39,7 +39,10 @@ jobs:
       - name: Build package
         run: pnpm build
 
-      - name: Publish to npm
-        run: pnpm changeset publish
+      - name: Create GitHub Release and Publish to npm
+        uses: changesets/action@v1
+        with:
+          publish: pnpm changeset publish
         env:
+          GITHUB_TOKEN: ${{ secrets.GITHUB_TOKEN }}
           NODE_AUTH_TOKEN: ${{ secrets.NPM_TOKEN }}

packages/mcp-check/CHANGELOG.md

@@ -1,5 +1,11 @@
 # mcp-testing-library
 
+## 0.2.3
+
+### Patch Changes
+
+- Introduced a terminal UI using Ink to visualize streamed output from different AI models during execution with npx mcp-check.
+
 ## 0.2.2
 
 ### Patch Changes

packages/mcp-check/README.md

@@ -58,19 +58,27 @@ const mcpServer = new McpServer({
 });
 ```
 
-### client(mcpServer, models)
+### client(mcpServer, models, config?)
 
 Create a client instance to execute prompts:
 
 ```typescript
-const agent = client(mcpServer, ["claude-3-haiku-20240307", "gpt-4"])
+const agent = client(mcpServer, ["claude-3-haiku-20240307", "gpt-4"], {
+  // Provider-specific API keys (optional - can also use environment variables)
+  anthropicApiKey: "your-anthropic-key-here",
+  openaiApiKey: "your-openai-key-here"
+})
   .prompt("Your prompt here")
   .execute();
 ```
 
 **Parameters:**
 - `mcpServer`: Configured MCP server instance
 - `models`: Array of AI model names to use
+- `config`: Optional configuration object
+  - `anthropicApiKey`: API key for Anthropic models
+  - `openaiApiKey`: API key for OpenAI models
+
 
 **Supported Models:**
 - Claude models: `claude-3-haiku-20240307`, `claude-3-5-sonnet-20240620`, etc.
@@ -114,10 +122,19 @@ const mcpServer = new McpServer({
 
 describe("MCP Server Tests", () => {
   test("should use expected tools", async () => {
+    // Option 1: Use environment variables (no config needed)
     const agent = await client(mcpServer, ["claude-3-haiku-20240307"])
       .prompt("Update the content using the available tools.")
       .execute();
 
+    // Option 2: Pass API keys directly in config
+    const agentWithConfig = await client(mcpServer, ["claude-3-haiku-20240307", "gpt-4"], {
+      anthropicApiKey: "your-anthropic-key-here",
+      openaiApiKey: "your-openai-key-here"
+    })
+      .prompt("Update the content using the available tools.")
+      .execute();
+
     // Verify tools were used
     expect(agent.usedTools).toHaveProperty("claude-3-haiku-20240307");
     expect(agent.usedTools["claude-3-haiku-20240307"]!).toEqual(
@@ -149,4 +166,4 @@ Set the following environment variables for AI model authentication:
 ANTHROPIC_API_KEY=your_anthropic_key_here
 OPENAI_API_KEY=your_openai_key_here
 MCP_TOKEN=your_mcp_server_token_here
-```
+```

packages/mcp-check/bin/mcp-check

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import('../dist/ui/cli.js');

packages/mcp-check/bin/mcp-check.cjs

@@ -1,13 +1,14 @@
 {
   "name": "mcp-check",
   "module": "index.ts",
-  "version": "0.2.2",
+  "version": "0.2.3",
   "type": "module",
   "main": "dist/index.js",
   "types": "dist/index.d.ts",
   "devDependencies": {
     "@types/bun": "latest",
     "@types/jest": "^30.0.0",
+    "@types/react": "^19.1.8",
     "jest": "^30.0.5",
     "ts-jest": "^29.4.0",
     "ts-node": "^10.9.2"
@@ -18,12 +19,11 @@
   "dependencies": {
     "@anthropic-ai/sdk": "^0.56.0",
     "@modelcontextprotocol/sdk": "^1.16.0",
-    "bun-plugin-dts": "^0.3.0",
-    "dotenv": "^16.4.7",
     "glob": "^11.0.0",
-    "mcp-check-agents": "^0.1.0",
+    "ink": "^6.1.0",
     "openai": "^5.10.1",
-    "tsx": "^4.19.2",
+    "react": "^19.1.1",
+    "string-width": "^7.2.0",
     "zod": "^3.24.4"
   },
   "description": "",
@@ -35,11 +35,13 @@
     }
   },
   "bin": {
-    "mcp-check": "./bin/mcp-check.cjs"
+    "mcp-check": "./bin/mcp-check"
   },
   "scripts": {
     "build": "tsup",
-    "prepublishOnly": "pnpm build"
+    "prepublishOnly": "pnpm build",
+    "test": "./bin/mcp-test",
+    "test:jest": "jest"
   },
   "files": [
     "dist",
@@ -48,5 +50,10 @@
   ],
   "publishConfig": {
     "access": "public"
-  }
+  },
+  "repository": {
+    "type": "git",
+    "url": "https://github.com/runbasehq/mcp-check.git"
+  },
+  "homepage": "https://github.com/runbasehq/mcp-check#readme"
 }

packages/mcp-check/package.json

@@ -0,0 +1,11 @@
+export { ChunkNormalizer } from "./normalizer.js";
+
+export type {
+  ToolCall,
+  StreamResult,
+  NormalizedChunk,
+  NormalizedChunkType,
+  ChunkHandlerConfig,
+  ChunkCallback,
+  ChunkTypeCallback,
+} from "./types.js";

packages/mcp-check/src/chunks/index.ts

@@ -0,0 +1,72 @@
+import type { NormalizedChunk, ChunkHandlerConfig } from "./types.js";
+
+export class ChunkNormalizer {
+  static async processChunk(normalizedChunk: NormalizedChunk, handlers: ChunkHandlerConfig): Promise<void> {
+    // Provider-specific
+    if (normalizedChunk.provider === "anthropic") {
+      if (handlers.anthropic?.onContentBlockDelta && normalizedChunk.originalChunk?.type === "content_block_delta") {
+        await handlers.anthropic.onContentBlockDelta(normalizedChunk.originalChunk);
+      }
+      if (handlers.anthropic?.onContentBlockStart && normalizedChunk.originalChunk?.type === "content_block_start") {
+        await handlers.anthropic.onContentBlockStart(normalizedChunk.originalChunk);
+      }
+      if (handlers.anthropic?.onContentBlockStop && normalizedChunk.originalChunk?.type === "content_block_stop") {
+        await handlers.anthropic.onContentBlockStop(normalizedChunk.originalChunk);
+      }
+    } else if (normalizedChunk.provider === "openai") {
+      if (handlers.openai?.onResponseOutputItemAdded && normalizedChunk.originalChunk?.type === "response.output_item.added") {
+        await handlers.openai.onResponseOutputItemAdded(normalizedChunk.originalChunk);
+      }
+      if (handlers.openai?.onResponseOutputItemDone && normalizedChunk.originalChunk?.type === "response.output_item.done") {
+        await handlers.openai.onResponseOutputItemDone(normalizedChunk.originalChunk);
+      }
+    }
+
+    switch (normalizedChunk.type) {
+      case "text_delta":
+        if (handlers.onTextDelta) {
+          await handlers.onTextDelta(normalizedChunk.data);
+        }
+        break;
+      case "tool_call_start":
+        if (handlers.onToolCallStart) {
+          await handlers.onToolCallStart(normalizedChunk.data);
+        }
+        break;
+      case "tool_call_done":
+        if (handlers.onToolCallDone) {
+          await handlers.onToolCallDone(normalizedChunk.data);
+        }
+        break;
+      case "tool_result":
+        if (handlers.onToolResult) {
+          await handlers.onToolResult(normalizedChunk.data);
+        }
+        break;
+      case "message_start":
+        if (handlers.onMessageStart) {
+          await handlers.onMessageStart(normalizedChunk.data);
+        }
+        break;
+      case "message_done":
+        if (handlers.onMessageDone) {
+          await handlers.onMessageDone(normalizedChunk.data);
+        }
+        break;
+      case "thinking_delta":
+        if (handlers.onThinkingDelta) {
+          await handlers.onThinkingDelta(normalizedChunk.data);
+        }
+        break;
+      case "error":
+        if (handlers.onError) {
+          await handlers.onError(normalizedChunk.data);
+        }
+        break;
+    }
+
+    if (handlers.onAnyChunk) {
+      await handlers.onAnyChunk(normalizedChunk);
+    }
+  }
+}

packages/mcp-check/src/chunks/normalizer.ts

@@ -0,0 +1,61 @@
+export interface ToolCall {
+  args: Record<string, any>;
+  result?: any;
+}
+
+export interface StreamResult {
+  usedTools: string[];
+  content: string;
+  toolCalls: Record<string, ToolCall[]>;
+}
+
+export type NormalizedChunkType = 
+  | 'text_delta'
+  | 'tool_call_start'
+  | 'tool_call_done'
+  | 'tool_result'
+  | 'message_start'
+  | 'message_done'
+  | 'thinking_delta'
+  | 'error';
+
+export interface NormalizedChunk {
+  type: NormalizedChunkType;
+  provider: 'anthropic' | 'openai';
+  timestamp: number;
+  data: {
+    text?: string;
+    toolName?: string;
+    toolArgs?: Record<string, any>;
+    toolResult?: any;
+    error?: string;
+    [key: string]: any;
+  };
+  originalChunk?: any;
+}
+
+export type ChunkCallback = (chunk: NormalizedChunk) => void | Promise<void>;
+export type ChunkTypeCallback = (data: NormalizedChunk['data']) => void | Promise<void>;
+
+export interface ChunkHandlerConfig {
+  onTextDelta?: ChunkTypeCallback;
+  onToolCallStart?: ChunkTypeCallback;
+  onToolCallDone?: ChunkTypeCallback;
+  onToolResult?: ChunkTypeCallback;
+  onMessageStart?: ChunkTypeCallback;
+  onMessageDone?: ChunkTypeCallback;
+  onThinkingDelta?: ChunkTypeCallback;
+  onError?: ChunkTypeCallback;
+  onAnyChunk?: ChunkCallback;
+  
+  // Provider-specific handlers
+  anthropic?: {
+    onContentBlockDelta?: (chunk: any) => void | Promise<void>;
+    onContentBlockStart?: (chunk: any) => void | Promise<void>;
+    onContentBlockStop?: (chunk: any) => void | Promise<void>;
+  };
+  openai?: {
+    onResponseOutputItemAdded?: (chunk: any) => void | Promise<void>;
+    onResponseOutputItemDone?: (chunk: any) => void | Promise<void>;
+  };
+}