@sammorrowdrums/mcpi-ext 0.1.0 → 0.2.0

package/src/tool-cli/cli.ts

@@ -1,232 +0,0 @@
-#!/usr/bin/env node
-
-import { writeFileSync } from "node:fs";
-import { rpcCall } from "./rpc-client.js";
-
-interface ServerInfo {
-  name: string;
-  toolCount: number;
-  examples: string[];
-}
-
-interface ToolSummary {
-  name: string;
-  description: string;
-  hasStructuredOutput: boolean;
-}
-
-interface ToolDetails {
-  name: string;
-  description: string;
-  inputSchema: Record<string, unknown>;
-  outputSchema?: Record<string, unknown>;
-  annotations?: Record<string, unknown>;
-}
-
-async function main(): Promise<void> {
-  const rawArgs = process.argv.slice(2);
-
-  // Extract --out <file> flag (can appear anywhere)
-  let outFile: string | undefined;
-  const args: string[] = [];
-  for (let i = 0; i < rawArgs.length; i++) {
-    if (rawArgs[i] === "--out" && i + 1 < rawArgs.length) {
-      outFile = rawArgs[++i];
-    } else {
-      args.push(rawArgs[i]);
-    }
-  }
-
-  try {
-    // No args or --help → list servers
-    if (args.length === 0 || (args.length === 1 && isHelp(args[0]))) {
-      await listServers();
-      return;
-    }
-
-    const server = args[0];
-
-    // <server> --help or just <server> → list tools
-    if (args.length === 1 || (args.length === 2 && isHelp(args[1]))) {
-      await listTools(server);
-      return;
-    }
-
-    const tool = args[1];
-
-    // <server> <tool> --help or just <server> <tool> → describe tool
-    if (args.length === 2 || (args.length === 3 && isHelp(args[2]))) {
-      await describeTool(server, tool);
-      return;
-    }
-
-    // <server> <tool> <json-args> → call tool
-    await callTool(server, tool, args[2], outFile);
-  } catch (err) {
-    const message = err instanceof Error ? err.message : String(err);
-    if (message.includes("ECONNREFUSED") || message.includes("fetch failed")) {
-      console.error("Error: tool-cli server not running. Is mcpi-ext loaded?");
-    } else {
-      console.error(`Error: ${message}`);
-    }
-    process.exit(1);
-  }
-}
-
-async function listServers(): Promise<void> {
-  const result = (await rpcCall("listServers")) as { servers: ServerInfo[] };
-  const { servers } = result;
-
-  if (servers.length === 0) {
-    console.log("No MCP servers connected.");
-    return;
-  }
-
-  console.log("Available servers:");
-  for (const s of servers) {
-    const examples = s.examples.length > 0 ? ` (e.g. ${s.examples.join(", ")})` : "";
-    console.log(`  ${s.name.padEnd(20)} ${s.toolCount} tool(s)${examples}`);
-  }
-  console.log("");
-  console.log("Use: tool-cli <server> to list tools");
-}
-
-async function listTools(server: string): Promise<void> {
-  const result = (await rpcCall("listTools", { server })) as {
-    server: string;
-    tools: ToolSummary[];
-  };
-
-  if (result.tools.length === 0) {
-    console.log(`${server} — no tools`);
-    return;
-  }
-
-  console.log(`${server} — ${result.tools.length} tool(s):`);
-  for (const t of result.tools) {
-    const badge = t.hasStructuredOutput ? " [json]" : "";
-    console.log(`  ${t.name.padEnd(30)} ${t.description}${badge}`);
-  }
-  console.log("");
-  console.log("Use: tool-cli <server> <tool> for full schema");
-}
-
-async function describeTool(server: string, tool: string): Promise<void> {
-  const result = (await rpcCall("describeTool", { server, tool })) as ToolDetails;
-
-  console.log(`${result.name} — ${result.description}`);
-  console.log("");
-  console.log("Input schema:");
-  console.log(formatSchema(result.inputSchema));
-
-  if (result.outputSchema) {
-    console.log("");
-    console.log("Output schema (structured JSON output):");
-    console.log(formatSchema(result.outputSchema));
-  }
-
-  if (result.annotations && Object.keys(result.annotations).length > 0) {
-    console.log("");
-    console.log("Annotations:");
-    for (const [key, val] of Object.entries(result.annotations)) {
-      console.log(`  ${key}: ${JSON.stringify(val)}`);
-    }
-  }
-
-  console.log("");
-  console.log(`Use: tool-cli ${server} ${tool} '{"key":"value"}' to call`);
-}
-
-async function callTool(
-  server: string,
-  tool: string,
-  argsJson: string,
-  outFile?: string,
-): Promise<void> {
-  let toolArgs: Record<string, unknown>;
-  try {
-    toolArgs = JSON.parse(argsJson) as Record<string, unknown>;
-  } catch {
-    console.error(`Error: invalid JSON arguments: ${argsJson}`);
-    process.exit(1);
-  }
-
-  const result = (await rpcCall("callTool", { server, tool, arguments: toolArgs })) as {
-    content: unknown[];
-    isError?: boolean;
-    structuredContent?: Record<string, unknown>;
-  };
-
-  if (result.isError) {
-    // Error content goes to stderr so stdout stays clean for piping
-    if (result.structuredContent) {
-      console.error(JSON.stringify(result.structuredContent, null, 2));
-    } else if (result.content) {
-      for (const item of result.content) {
-        const entry = item as Record<string, unknown>;
-        if (entry.type === "text") {
-          console.error(entry.text);
-        } else {
-          console.error(JSON.stringify(entry, null, 2));
-        }
-      }
-    }
-    process.exit(1);
-    return;
-  }
-
-  const output = formatOutput(result.structuredContent, result.content);
-  if (!output) return;
-
-  if (outFile) {
-    writeFileSync(outFile, output, "utf-8");
-    console.log(`Written to: ${outFile}`);
-  } else {
-    console.log(output);
-  }
-}
-
-/** Build the output string from structured or raw content. */
-function formatOutput(structuredContent?: Record<string, unknown>, content?: unknown[]): string {
-  if (structuredContent) {
-    return JSON.stringify(structuredContent, null, 2);
-  }
-  if (content) {
-    const parts: string[] = [];
-    for (const item of content) {
-      const entry = item as Record<string, unknown>;
-      if (entry.type === "text") {
-        parts.push(entry.text as string);
-      } else {
-        parts.push(JSON.stringify(entry, null, 2));
-      }
-    }
-    return parts.join("\n");
-  }
-  return "";
-}
-
-/** Format a JSON Schema as a compact, readable summary. */
-function formatSchema(schema: Record<string, unknown>): string {
-  const props = schema.properties as Record<string, Record<string, unknown>> | undefined;
-  const required = (schema.required as string[]) ?? [];
-
-  if (!props || Object.keys(props).length === 0) {
-    return "  (no parameters)";
-  }
-
-  const lines: string[] = [];
-  for (const [name, prop] of Object.entries(props)) {
-    const type = (prop.type as string) ?? "unknown";
-    const req = required.includes(name) ? ", required" : "";
-    const desc = prop.description ? `: ${prop.description as string}` : "";
-    lines.push(`  ${name} (${type}${req})${desc}`);
-  }
-  return lines.join("\n");
-}
-
-function isHelp(arg: string): boolean {
-  return arg === "--help" || arg === "-h";
-}
-
-void main();

package/src/tool-cli/constants.ts

@@ -1,15 +0,0 @@
-/** Default port for the tool-cli JSON-RPC server. */
-export const DEFAULT_PORT = 7179;
-
-/** Environment variable to override the default port. */
-export const PORT_ENV_VAR = "TOOL_CLI_PORT";
-
-/** Resolve the port from environment or default. */
-export function resolvePort(): number {
-  const envPort = process.env[PORT_ENV_VAR];
-  if (envPort) {
-    const parsed = parseInt(envPort, 10);
-    if (!isNaN(parsed) && parsed > 0 && parsed < 65536) return parsed;
-  }
-  return DEFAULT_PORT;
-}

package/src/tool-cli/rpc-client.ts

@@ -1,39 +0,0 @@
-import { resolvePort } from "./constants.js";
-
-interface JsonRpcResponse {
-  jsonrpc: "2.0";
-  result?: unknown;
-  error?: { code: number; message: string; data?: unknown };
-  id: number | string | null;
-}
-
-/**
- * Send a JSON-RPC 2.0 request to the tool-cli RPC server.
- * Throws on network errors and JSON-RPC error responses.
- */
-export async function rpcCall(
-  method: string,
-  params: Record<string, unknown> = {},
-): Promise<unknown> {
-  const port = resolvePort();
-  const url = `http://127.0.0.1:${port}`;
-
-  const response = await fetch(url, {
-    method: "POST",
-    headers: { "Content-Type": "application/json" },
-    body: JSON.stringify({
-      jsonrpc: "2.0",
-      method,
-      params,
-      id: 1,
-    }),
-  });
-
-  const json = (await response.json()) as JsonRpcResponse;
-
-  if (json.error) {
-    throw new Error(json.error.message);
-  }
-
-  return json.result;
-}

package/src/tool-cli/rpc-server.test.ts

@@ -1,193 +0,0 @@
-import { describe, it, expect, beforeAll, afterAll } from "vitest";
-import { ToolCliRpcServer } from "./rpc-server.js";
-import type { McpClientManager } from "../mcp/index.js";
-
-/** Minimal mock of McpClientManager for RPC server testing. */
-function createMockManager(): McpClientManager {
-  const tools = [
-    {
-      name: "get_weather",
-      description: "Get current weather for a city",
-      inputSchema: {
-        type: "object",
-        properties: { city: { type: "string", description: "City name" } },
-        required: ["city"],
-      },
-      annotations: { readOnlyHint: true },
-      serverName: "weather",
-    },
-    {
-      name: "set_alarm",
-      description: "Set a weather alarm",
-      inputSchema: {
-        type: "object",
-        properties: {
-          city: { type: "string" },
-          threshold: { type: "number" },
-        },
-        required: ["city", "threshold"],
-      },
-      annotations: { readOnlyHint: false, destructiveHint: false },
-      serverName: "weather",
-    },
-    {
-      name: "search_docs",
-      description: "Search documentation",
-      inputSchema: {
-        type: "object",
-        properties: { query: { type: "string", description: "Search query" } },
-        required: ["query"],
-      },
-      outputSchema: {
-        type: "object",
-        properties: { results: { type: "array" } },
-      },
-      annotations: { readOnlyHint: true },
-      serverName: "docs",
-    },
-  ];
-
-  return {
-    getConnectedServers: () => ["weather", "docs"],
-    getToolsForServer: (name: string) => tools.filter((t) => t.serverName === name),
-    getTools: () => tools,
-    getClient: (name: string) => {
-      if (name === "weather" || name === "docs") {
-        return {
-          callTool: async (params: { name: string; arguments?: Record<string, unknown> }) => ({
-            content: [{ type: "text", text: `Called ${params.name}` }],
-          }),
-        };
-      }
-      return undefined;
-    },
-  } as unknown as McpClientManager;
-}
-
-// Use port 0 so the OS assigns a free port — avoids collisions when src + dist tests run together
-describe("ToolCliRpcServer", () => {
-  let server: ToolCliRpcServer;
-  let port: number;
-
-  beforeAll(async () => {
-    const manager = createMockManager();
-    server = new ToolCliRpcServer(manager, 0);
-    await server.start();
-    port = server.getPort();
-  });
-
-  afterAll(async () => {
-    await server.stop();
-  });
-
-  async function rpc(method: string, params: Record<string, unknown> = {}): Promise<unknown> {
-    const res = await fetch(`http://127.0.0.1:${port}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: JSON.stringify({ jsonrpc: "2.0", method, params, id: 1 }),
-    });
-    return res.json();
-  }
-
-  it("lists connected servers with tool counts", async () => {
-    const resp = (await rpc("listServers")) as {
-      result: { servers: { name: string; toolCount: number; examples: string[] }[] };
-    };
-    const { servers } = resp.result;
-    expect(servers).toHaveLength(2);
-
-    const weather = servers.find((s) => s.name === "weather");
-    expect(weather).toBeDefined();
-    expect(weather?.toolCount).toBe(2);
-    expect(weather?.examples.length).toBeGreaterThan(0);
-
-    const docs = servers.find((s) => s.name === "docs");
-    expect(docs).toBeDefined();
-    expect(docs?.toolCount).toBe(1);
-  });
-
-  it("lists tools for a specific server", async () => {
-    const resp = (await rpc("listTools", { server: "weather" })) as {
-      result: { server: string; tools: { name: string; description: string }[] };
-    };
-    expect(resp.result.server).toBe("weather");
-    expect(resp.result.tools).toHaveLength(2);
-    expect(resp.result.tools[0].name).toBe("get_weather");
-    expect(resp.result.tools[1].name).toBe("set_alarm");
-  });
-
-  it("describes a tool with full schema", async () => {
-    const resp = (await rpc("describeTool", { server: "weather", tool: "get_weather" })) as {
-      result: {
-        name: string;
-        description: string;
-        inputSchema: Record<string, unknown>;
-        annotations: Record<string, unknown>;
-      };
-    };
-    expect(resp.result.name).toBe("get_weather");
-    expect(resp.result.description).toBe("Get current weather for a city");
-    expect(resp.result.inputSchema).toHaveProperty("properties");
-    expect(resp.result.annotations).toEqual({ readOnlyHint: true });
-  });
-
-  it("calls a tool and returns result", async () => {
-    const resp = (await rpc("callTool", {
-      server: "weather",
-      tool: "get_weather",
-      arguments: { city: "London" },
-    })) as {
-      result: { content: { type: string; text: string }[] };
-    };
-    expect(resp.result.content).toHaveLength(1);
-    expect(resp.result.content[0].text).toBe("Called get_weather");
-  });
-
-  it("returns error for unknown server", async () => {
-    const resp = (await rpc("listTools", { server: "nonexistent" })) as {
-      error: { code: number; message: string };
-    };
-    expect(resp.error).toBeDefined();
-    expect(resp.error.code).toBe(-32602);
-    expect(resp.error.message).toContain("not found");
-  });
-
-  it("returns error for unknown tool", async () => {
-    const resp = (await rpc("describeTool", { server: "weather", tool: "nonexistent" })) as {
-      error: { code: number; message: string };
-    };
-    expect(resp.error).toBeDefined();
-    expect(resp.error.message).toContain("not found");
-  });
-
-  it("returns error for unknown method", async () => {
-    const resp = (await rpc("unknownMethod")) as {
-      error: { code: number; message: string };
-    };
-    expect(resp.error).toBeDefined();
-    expect(resp.error.code).toBe(-32601);
-  });
-
-  it("returns error for missing required params", async () => {
-    const resp = (await rpc("listTools", {})) as {
-      error: { code: number; message: string };
-    };
-    expect(resp.error).toBeDefined();
-    expect(resp.error.code).toBe(-32602);
-  });
-
-  it("rejects non-POST requests", async () => {
-    const res = await fetch(`http://127.0.0.1:${port}`, { method: "GET" });
-    expect(res.status).toBe(405);
-  });
-
-  it("handles malformed JSON gracefully", async () => {
-    const res = await fetch(`http://127.0.0.1:${port}`, {
-      method: "POST",
-      headers: { "Content-Type": "application/json" },
-      body: "not json at all",
-    });
-    const json = (await res.json()) as { error: { code: number } };
-    expect(json.error.code).toBe(-32700);
-  });
-});