@esaio/esa-mcp-server 0.2.0 → 0.2.2

package/src/api_client/__tests__/with-context.test.ts

@@ -1,98 +0,0 @@
-import { beforeEach, describe, expect, it, vi } from "vitest";
-import { createEsaClient } from "../index.js";
-import { withContext } from "../with-context.js";
-
-// Mock createEsaClient to test context handling without real API client creation
-vi.mock("../index.js", () => ({
-  createEsaClient: vi.fn(),
-}));
-
-describe("withContext", () => {
-  const mockCreateEsaClient = vi.mocked(createEsaClient);
-
-  // Mock client instance to verify it's passed to handlers correctly
-  const mockClient: Partial<ReturnType<typeof createEsaClient>> = {};
-
-  // Mock handler function to verify arguments and return values
-  const mockHandler = vi.fn();
-
-  // Create test context with default values and optional overrides
-  const createTestContext = (overrides?: {
-    apiAccessToken?: string;
-    apiBaseUrl?: string;
-  }) => ({
-    apiAccessToken: overrides?.apiAccessToken ?? "test-token",
-    apiBaseUrl: overrides?.apiBaseUrl ?? "https://api.esa.example.com",
-  });
-
-  beforeEach(() => {
-    vi.clearAllMocks();
-    mockCreateEsaClient.mockReturnValue(
-      mockClient as ReturnType<typeof createEsaClient>,
-    );
-  });
-
-  it("should create client and call handler for StdioContext", async () => {
-    const context = createTestContext();
-    const expectedResult = { success: true };
-    mockHandler.mockResolvedValue(expectedResult);
-
-    const result = await withContext(context, mockHandler, "arg1", "arg2");
-
-    expect(mockCreateEsaClient).toHaveBeenCalledWith(
-      context.apiAccessToken,
-      context.apiBaseUrl,
-    );
-    expect(mockHandler).toHaveBeenCalledWith(mockClient, "arg1", "arg2");
-    expect(result).toBe(expectedResult);
-  });
-
-  it("should work with different apiBaseUrl", async () => {
-    const context = createTestContext({
-      apiBaseUrl: "https://api.example.com",
-    });
-
-    await withContext(context, mockHandler);
-
-    expect(mockCreateEsaClient).toHaveBeenCalledWith(
-      context.apiAccessToken,
-      context.apiBaseUrl,
-    );
-  });
-
-  it("should throw error for unsupported context type", async () => {
-    // Create invalid context missing required apiAccessToken property
-    const invalidContext = {
-      someOtherProperty: "value",
-    };
-
-    await expect(
-      withContext(
-        invalidContext as unknown as Parameters<typeof withContext>[0],
-        mockHandler,
-      ),
-    ).rejects.toThrow(
-      "Unsupported context type. Only StdioContext is currently supported.",
-    );
-  });
-
-  it("should handle handler errors correctly", async () => {
-    const context = createTestContext();
-    const handlerError = new Error("Handler failed");
-    mockHandler.mockRejectedValue(handlerError);
-
-    await expect(withContext(context, mockHandler)).rejects.toThrow(
-      "Handler failed",
-    );
-  });
-
-  it("should pass through handler arguments correctly", async () => {
-    const context = createTestContext();
-    const args = [{ page: 1 }, { per_page: 20 }, "extra"];
-    mockHandler.mockResolvedValue("success");
-
-    await withContext(context, mockHandler, ...args);
-
-    expect(mockHandler).toHaveBeenCalledWith(mockClient, ...args);
-  });
-});

package/src/api_client/index.ts

@@ -1,29 +0,0 @@
-import createClient from "openapi-fetch";
-import packageJson from "../../package.json" with { type: "json" };
-import type { paths } from "../generated/api-types.js";
-import { createAuthMiddleware } from "./middleware.js";
-
-const packageVersion = packageJson.version;
-
-function createUserAgentMiddleware(version: string) {
-  return {
-    async onRequest({ request }: { request: Request }) {
-      request.headers.set("User-Agent", `esa-mcp-server/${version} (official)`);
-      return request;
-    },
-  };
-}
-
-export function createEsaClient(
-  apiAccessToken: string,
-  apiBaseUrl: string = "https://api.esa.io",
-) {
-  const client = createClient<paths>({
-    baseUrl: apiBaseUrl,
-  });
-
-  client.use(createUserAgentMiddleware(packageVersion));
-  client.use(createAuthMiddleware(apiAccessToken));
-
-  return client;
-}

package/src/api_client/middleware.ts

@@ -1,21 +0,0 @@
-import type { Middleware } from "openapi-fetch";
-
-export function createAuthMiddleware(apiAccessToken: string): Middleware {
-  return {
-    async onRequest({ request }) {
-      request.headers.set("Authorization", `Bearer ${apiAccessToken}`);
-      return request;
-    },
-    async onResponse({ response }) {
-      const rateLimit = response.headers.get("x-ratelimit-limit");
-      const remaining = response.headers.get("x-ratelimit-remaining");
-      if (rateLimit && remaining) {
-        console.error(`Rate limit: ${remaining}/${rateLimit}`);
-      }
-      return response;
-    },
-    async onError({ error }) {
-      console.error("Network Error:", error);
-    },
-  };
-}

package/src/api_client/with-context.ts

@@ -1,26 +0,0 @@
-import { createEsaClient } from "../api_client/index.js";
-import type { MCPContext } from "../context/mcp-context.js";
-
-export async function withContext<T extends unknown[], R>(
-  context: MCPContext,
-  handler: (
-    client: ReturnType<typeof createEsaClient>,
-    ...args: T
-  ) => Promise<R>,
-  ...args: T
-): Promise<R> {
-  let client: ReturnType<typeof createEsaClient>;
-
-  if ("apiAccessToken" in context && "apiBaseUrl" in context) {
-    client = createEsaClient(
-      context.apiAccessToken as string,
-      context.apiBaseUrl as string,
-    );
-  } else {
-    throw new Error(
-      "Unsupported context type. Only StdioContext is currently supported.",
-    );
-  }
-
-  return handler(client, ...args);
-}

package/src/config/__tests__/index.test.ts

@@ -1,65 +0,0 @@
-import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
-import packageJson from "../../../package.json" with { type: "json" };
-
-describe("config", () => {
-  beforeEach(() => {
-    vi.resetModules();
-    vi.stubEnv("ESA_ACCESS_TOKEN", undefined);
-    vi.stubEnv("ESA_API_BASE_URL", undefined);
-  });
-
-  afterEach(() => {
-    vi.unstubAllEnvs();
-  });
-
-  describe("config object", () => {
-    it("should have correct default values", async () => {
-      const { config } = await import("../index.js");
-
-      expect(config.esa.apiBaseUrl).toBe("https://api.esa.io");
-      expect(config.server.name).toBe("esa-mcp-server");
-      expect(config.server.version).toBe(packageJson.version);
-      expect(config.server.description).toBe("Official MCP server for esa.io");
-    });
-
-    it("should use environment variables when set", async () => {
-      vi.stubEnv("ESA_ACCESS_TOKEN", "test-token");
-      vi.stubEnv("ESA_API_BASE_URL", "https://api.esa.localhost");
-
-      const { config } = await import("../index.js");
-
-      expect(config.esa.apiAccessToken).toBe("test-token");
-      expect(config.esa.apiBaseUrl).toBe("https://api.esa.localhost");
-    });
-  });
-
-  describe("validateConfig", () => {
-    it("should throw error when ESA_ACCESS_TOKEN is not set", async () => {
-      vi.stubEnv("ESA_ACCESS_TOKEN", undefined);
-
-      const { validateConfig } = await import("../index.js");
-
-      expect(() => validateConfig()).toThrow(
-        "ESA_ACCESS_TOKEN environment variable is required",
-      );
-    });
-
-    it("should not throw error when ESA_ACCESS_TOKEN is set", async () => {
-      vi.stubEnv("ESA_ACCESS_TOKEN", "valid-token");
-
-      const { validateConfig } = await import("../index.js");
-
-      expect(() => validateConfig()).not.toThrow();
-    });
-
-    it("should throw error when ESA_ACCESS_TOKEN is empty string", async () => {
-      vi.stubEnv("ESA_ACCESS_TOKEN", "");
-
-      const { validateConfig } = await import("../index.js");
-
-      expect(() => validateConfig()).toThrow(
-        "ESA_ACCESS_TOKEN environment variable is required",
-      );
-    });
-  });
-});

package/src/config/index.ts

@@ -1,20 +0,0 @@
-import packageJson from "../../package.json" with { type: "json" };
-import type { StdioContext } from "../context/stdio-context.js";
-
-export const config = {
-  esa: {
-    apiAccessToken: process.env.ESA_ACCESS_TOKEN || "",
-    apiBaseUrl: process.env.ESA_API_BASE_URL || "https://api.esa.io",
-  } satisfies StdioContext,
-  server: {
-    name: "esa-mcp-server",
-    version: packageJson.version,
-    description: "Official MCP server for esa.io",
-  },
-} as const;
-
-export function validateConfig(): void {
-  if (!config.esa.apiAccessToken) {
-    throw new Error("ESA_ACCESS_TOKEN environment variable is required");
-  }
-}

package/src/context/mcp-context.ts

@@ -1 +0,0 @@
-export type MCPContext = Record<string, unknown>;

package/src/context/stdio-context.ts

@@ -1,6 +0,0 @@
-import type { MCPContext } from "./mcp-context.js";
-
-export interface StdioContext extends MCPContext {
-  apiAccessToken: string;
-  apiBaseUrl: string;
-}

package/src/errors/missing-team-name-error.ts

@@ -1,8 +0,0 @@
-export class MissingTeamNameError extends Error {
-  constructor() {
-    super(
-      "Missing required parameter 'teamName'. Use esa_get_teams to list available teams, then retry with teamName specified.",
-    );
-    this.name = "MissingTeamNameError";
-  }
-}

package/src/formatters/__tests__/mcp-response.test.ts

@@ -1,106 +0,0 @@
-import { describe, expect, it } from "vitest";
-import {
-  formatPromptError,
-  formatPromptResponse,
-  formatResourceError,
-  formatResourceResponse,
-  formatToolError,
-  formatToolResponse,
-} from "../mcp-response.js";
-
-describe("response formatters", () => {
-  describe("formatToolResponse", () => {
-    it("should format data as JSON text content", () => {
-      const data = { key: "value", count: 42 };
-      const result = formatToolResponse(data);
-
-      expect(result.content[0].type).toBe("text");
-      expect(result.content[0].text).toBe(JSON.stringify(data, null, 2));
-    });
-  });
-
-  describe("formatResourceResponse", () => {
-    it("should format data as JSON resource with URI and mimeType", () => {
-      const data = { resource: "data" };
-      const uri = "esa://resource/123";
-      const result = formatResourceResponse(data, uri);
-
-      expect(result.contents[0]).toEqual({
-        uri,
-        mimeType: "application/json",
-        text: JSON.stringify(data, null, 2),
-      });
-    });
-  });
-
-  describe("formatPromptResponse", () => {
-    it("should format message as user role content", () => {
-      const message = "This is a prompt message";
-      const result = formatPromptResponse(message);
-
-      expect(result.messages[0]).toEqual({
-        role: "user",
-        content: {
-          type: "text",
-          text: message,
-        },
-      });
-    });
-  });
-});
-
-describe("error formatters", () => {
-  it("should format Error instances consistently", () => {
-    const error = new Error("test error");
-
-    expect(formatToolError(error).content[0].text).toBe("Error: test error");
-    expect(formatResourceError(error, "uri").contents[0].text).toBe(
-      "Error: test error",
-    );
-    expect(formatPromptError(error).messages[0].content.text).toBe(
-      "Error: test error",
-    );
-  });
-
-  it("should format status codes as API responses", () => {
-    const status = 404;
-
-    expect(formatToolError(status).content[0].text).toBe(
-      "Error: API Response(status: 404)",
-    );
-    expect(formatResourceError(status, "uri").contents[0].text).toBe(
-      "Error: API Response(status: 404)",
-    );
-  });
-
-  it("should format object errors as JSON strings", () => {
-    const error = { code: "NOT_FOUND", message: "Resource not found" };
-    const expectedText = `Error: ${JSON.stringify(error, null, 2)}`;
-
-    expect(formatToolError(error).content[0].text).toBe(expectedText);
-    expect(formatResourceError(error, "uri").contents[0].text).toBe(
-      expectedText,
-    );
-    expect(formatPromptError(error).messages[0].content.text).toBe(
-      expectedText,
-    );
-  });
-
-  it("should maintain correct structure for each error formatter", () => {
-    const error = new Error("test");
-    const uri = "test://uri";
-
-    const toolResult = formatToolError(error);
-    expect(toolResult).toHaveProperty("content");
-    expect(Array.isArray(toolResult.content)).toBe(true);
-
-    const resourceResult = formatResourceError(error, uri);
-    expect(resourceResult).toHaveProperty("contents");
-    expect(resourceResult.contents[0].uri).toBe(uri);
-    expect(resourceResult.contents[0].mimeType).toBe("application/json");
-
-    const promptResult = formatPromptError(error);
-    expect(promptResult).toHaveProperty("messages");
-    expect(promptResult.messages[0].role).toBe("user");
-  });
-});

package/src/formatters/mcp-response.ts

@@ -1,95 +0,0 @@
-import type {
-  CallToolResult,
-  GetPromptResult,
-  ReadResourceResult,
-} from "@modelcontextprotocol/sdk/types.js";
-
-function formatErrorText(error: unknown): string {
-  return error instanceof Error
-    ? `Error: ${error.message}`
-    : typeof error === "number" && error !== null
-      ? `Error: API Response(status: ${error})`
-      : typeof error === "object" && error !== null
-        ? `Error: ${JSON.stringify(error, null, 2)}`
-        : `Error: ${String(error)}`;
-}
-
-export function formatToolResponse(data: unknown): CallToolResult {
-  return {
-    content: [
-      {
-        type: "text",
-        text: JSON.stringify(data, null, 2),
-      },
-    ],
-  };
-}
-
-export function formatResourceResponse(
-  data: unknown,
-  uri: string,
-): ReadResourceResult {
-  return {
-    contents: [
-      {
-        uri,
-        mimeType: "application/json",
-        text: JSON.stringify(data, null, 2),
-      },
-    ],
-  };
-}
-
-export function formatPromptResponse(message: string): GetPromptResult {
-  return {
-    messages: [
-      {
-        role: "user",
-        content: {
-          type: "text",
-          text: message,
-        },
-      },
-    ],
-  };
-}
-
-export function formatToolError(error: unknown): CallToolResult {
-  return {
-    content: [
-      {
-        type: "text",
-        text: formatErrorText(error),
-      },
-    ],
-  };
-}
-
-export function formatResourceError(
-  error: unknown,
-  uri: string,
-): ReadResourceResult {
-  return {
-    contents: [
-      {
-        uri,
-        mimeType: "application/json",
-        text: formatErrorText(error),
-      },
-    ],
-  };
-}
-
-export function formatPromptError(error: unknown): GetPromptResult {
-  return {
-    messages: [
-      {
-        role: "user",
-        content: {
-          type: "text",
-          text: formatErrorText(error),
-        },
-      },
-    ],
-  };
-}