@anyproto/anytype-mcp 1.1.2 → 1.2.0

package/package.json

@@ -7,7 +7,7 @@
     "mcp",
     "server"
   ],
-  "version": "1.1.2",
+  "version": "1.2.0",
   "license": "MIT",
   "type": "module",
   "scripts": {
@@ -26,7 +26,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "1.26.0",
-    "axios": "1.13.4",
+    "axios": "1.13.5",
     "form-data": "4.0.5",
     "mustache": "4.2.0",
     "node-fetch": "3.3.2",
@@ -40,14 +40,14 @@
     "@eslint/js": "9.39.2",
     "@types/json-schema": "7.0.15",
     "@types/mustache": "4.2.6",
-    "@types/node": "25.2.1",
+    "@types/node": "25.2.3",
     "@types/which": "3.0.4",
     "@vitest/coverage-v8": "4.0.18",
-    "@typescript-eslint/eslint-plugin": "8.54.0",
-    "@typescript-eslint/parser": "8.54.0",
+    "@typescript-eslint/eslint-plugin": "8.56.0",
+    "@typescript-eslint/parser": "8.56.0",
     "eslint": "9.39.2",
     "esbuild": "0.27.3",
-    "openai": "6.18.0",
+    "openai": "6.22.0",
     "prettier": "3.8.1",
     "prettier-plugin-organize-imports": "4.3.0",
     "tsx": "4.21.0",

package/scripts/start-server.ts

@@ -1,9 +1,10 @@
 import { AppKeyGenerator } from "../src/auth/get-key";
 import { initProxy, loadOpenApiSpec, ValidationError } from "../src/init-server";
+import { determineBaseUrl } from "../src/utils/base-url";
 
 async function generateAppKey(specPath?: string) {
   const openApiSpec = await loadOpenApiSpec(specPath);
-  const baseUrl = openApiSpec.servers?.[0]?.url || "http://127.0.0.1:31009";
+  const baseUrl = determineBaseUrl(openApiSpec);
   const generator = new AppKeyGenerator(baseUrl);
   await generator.generateAppKey();
 }

package/src/init-server.ts

@@ -4,6 +4,7 @@ import fs from "node:fs";
 import path from "node:path";
 import { OpenAPIV3 } from "openapi-types";
 import { MCPProxy } from "./mcp/proxy";
+import { getDefaultSpecUrl } from "./utils/base-url";
 
 export class ValidationError extends Error {
   constructor(public errors: any[]) {
@@ -13,7 +14,7 @@ export class ValidationError extends Error {
 }
 
 export async function loadOpenApiSpec(specPath?: string): Promise<OpenAPIV3.Document> {
-  const finalSpec = specPath || "http://127.0.0.1:31009/docs/openapi.json";
+  const finalSpec = specPath || getDefaultSpecUrl();
   let rawSpec: string;
 
   if (finalSpec.startsWith("http://") || finalSpec.startsWith("https://")) {

package/src/mcp/__tests__/proxy.test.ts

@@ -13,41 +13,37 @@ describe("MCPProxy", () => {
   let proxy: MCPProxy;
   let mockOpenApiSpec: OpenAPIV3.Document;
 
-  beforeEach(() => {
-    // Reset all mocks
-    vi.clearAllMocks();
-
-    // Setup minimal OpenAPI spec for testing
-    mockOpenApiSpec = {
-      openapi: "3.0.0",
-      servers: [{ url: "http://localhost:3000" }],
-      info: {
-        title: "Test API",
-        version: "1.0.0",
-      },
-      paths: {
-        "/test": {
-          get: {
-            operationId: "getTest",
-            responses: {
-              "200": {
-                description: "Success",
-              },
-            },
-          },
+  const getHandlers = (proxy: MCPProxy) => {
+    const server = (proxy as any).server;
+    return server.setRequestHandler.mock.calls
+      .flatMap((x: unknown[]) => x)
+      .filter((x: unknown) => typeof x === "function");
+  };
+
+  const createMockOpenApiSpec = (overrides?: Partial<OpenAPIV3.Document>): OpenAPIV3.Document => ({
+    openapi: "3.0.0",
+    servers: [{ url: "http://localhost:3000" }],
+    info: { title: "Test API", version: "1.0.0" },
+    paths: {
+      "/test": {
+        get: {
+          operationId: "getTest",
+          responses: { "200": { description: "Success" } },
         },
       },
-    };
+    },
+    ...overrides,
+  });
 
+  beforeEach(() => {
+    vi.clearAllMocks();
+    mockOpenApiSpec = createMockOpenApiSpec();
     proxy = new MCPProxy("test-proxy", mockOpenApiSpec);
   });
 
   describe("listTools handler", () => {
     it("should return converted tools from OpenAPI spec", async () => {
-      const server = (proxy as any).server;
-      const listToolsHandler = server.setRequestHandler.mock.calls[0].filter(
-        (x: unknown) => typeof x === "function",
-      )[0];
+      const [listToolsHandler] = getHandlers(proxy);
       const result = await listToolsHandler();
 
       expect(result).toHaveProperty("tools");
@@ -55,24 +51,18 @@ describe("MCPProxy", () => {
     });
 
     it("should truncate tool names exceeding 64 characters", async () => {
-      // Setup OpenAPI spec with long tool names
-      mockOpenApiSpec.paths = {
-        "/test": {
-          get: {
-            operationId: "a".repeat(65),
-            responses: {
-              "200": {
-                description: "Success",
-              },
+      const specWithLongName = createMockOpenApiSpec({
+        paths: {
+          "/test": {
+            get: {
+              operationId: "a".repeat(65),
+              responses: { "200": { description: "Success" } },
             },
           },
         },
-      };
-      proxy = new MCPProxy("test-proxy", mockOpenApiSpec);
-      const server = (proxy as any).server;
-      const listToolsHandler = server.setRequestHandler.mock.calls[0].filter(
-        (x: unknown) => typeof x === "function",
-      )[0];
+      });
+      const testProxy = new MCPProxy("test-proxy", specWithLongName);
+      const [listToolsHandler] = getHandlers(testProxy);
       const result = await listToolsHandler();
 
       expect(result.tools[0].name.length).toBeLessThanOrEqual(64);
@@ -80,18 +70,15 @@ describe("MCPProxy", () => {
   });
 
   describe("callTool handler", () => {
+    const mockSuccessResponse = {
+      data: { message: "success" },
+      status: 200,
+      headers: new Headers({ "content-type": "application/json" }),
+    };
+
     it("should execute operation and return formatted response", async () => {
-      // Mock HttpClient response
-      const mockResponse = {
-        data: { message: "success" },
-        status: 200,
-        headers: new Headers({
-          "content-type": "application/json",
-        }),
-      };
-      (HttpClient.prototype.executeOperation as ReturnType<typeof vi.fn>).mockResolvedValue(mockResponse);
+      (HttpClient.prototype.executeOperation as ReturnType<typeof vi.fn>).mockResolvedValue(mockSuccessResponse);
 
-      // Set up the openApiLookup with our test operation
       (proxy as any).openApiLookup = {
         "API-getTest": {
           operationId: "getTest",
@@ -101,58 +88,25 @@ describe("MCPProxy", () => {
         },
       };
 
-      const server = (proxy as any).server;
-      const handlers = server.setRequestHandler.mock.calls
-        .flatMap((x: unknown[]) => x)
-        .filter((x: unknown) => typeof x === "function");
-      const callToolHandler = handlers[1];
-
-      const result = await callToolHandler({
-        params: {
-          name: "API-getTest",
-          arguments: {},
-        },
-      });
+      const [, callToolHandler] = getHandlers(proxy);
+      const result = await callToolHandler({ params: { name: "API-getTest", arguments: {} } });
 
       expect(result).toEqual({
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ message: "success" }),
-          },
-        ],
+        content: [{ type: "text", text: JSON.stringify({ message: "success" }) }],
       });
     });
 
     it("should throw error for non-existent operation", async () => {
-      const server = (proxy as any).server;
-      const handlers = server.setRequestHandler.mock.calls
-        .flatMap((x: unknown[]) => x)
-        .filter((x: unknown) => typeof x === "function");
-      const callToolHandler = handlers[1];
-
-      await expect(
-        callToolHandler({
-          params: {
-            name: "nonExistentMethod",
-            arguments: {},
-          },
-        }),
-      ).rejects.toThrow("Method nonExistentMethod not found");
+      const [, callToolHandler] = getHandlers(proxy);
+
+      await expect(callToolHandler({ params: { name: "nonExistentMethod", arguments: {} } })).rejects.toThrow(
+        "Method nonExistentMethod not found",
+      );
     });
 
     it("should handle tool names exceeding 64 characters", async () => {
-      // Mock HttpClient response
-      const mockResponse = {
-        data: { message: "success" },
-        status: 200,
-        headers: new Headers({
-          "content-type": "application/json",
-        }),
-      };
-      (HttpClient.prototype.executeOperation as ReturnType<typeof vi.fn>).mockResolvedValue(mockResponse);
+      (HttpClient.prototype.executeOperation as ReturnType<typeof vi.fn>).mockResolvedValue(mockSuccessResponse);
 
-      // Set up the openApiLookup with a long tool name
       const longToolName = "a".repeat(65);
       const truncatedToolName = longToolName.slice(0, 64);
       (proxy as any).openApiLookup = {
@@ -164,26 +118,11 @@ describe("MCPProxy", () => {
         },
       };
 
-      const server = (proxy as any).server;
-      const handlers = server.setRequestHandler.mock.calls
-        .flatMap((x: unknown[]) => x)
-        .filter((x: unknown) => typeof x === "function");
-      const callToolHandler = handlers[1];
-
-      const result = await callToolHandler({
-        params: {
-          name: truncatedToolName,
-          arguments: {},
-        },
-      });
+      const [, callToolHandler] = getHandlers(proxy);
+      const result = await callToolHandler({ params: { name: truncatedToolName, arguments: {} } });
 
       expect(result).toEqual({
-        content: [
-          {
-            type: "text",
-            text: JSON.stringify({ message: "success" }),
-          },
-        ],
+        content: [{ type: "text", text: JSON.stringify({ message: "success" }) }],
       });
     });
   });
@@ -202,6 +141,9 @@ describe("MCPProxy", () => {
 
   describe("parseHeadersFromEnv", () => {
     const originalEnv = process.env;
+    const expectHeaders = (headers: Record<string, string>) => {
+      expect(HttpClient).toHaveBeenCalledWith(expect.objectContaining({ headers }), expect.anything());
+    };
 
     beforeEach(() => {
       process.env = { ...originalEnv };
@@ -216,42 +158,21 @@ describe("MCPProxy", () => {
         Authorization: "Bearer token123",
         "X-Custom-Header": "test",
       });
-
-      const proxy = new MCPProxy("test-proxy", mockOpenApiSpec);
-      expect(HttpClient).toHaveBeenCalledWith(
-        expect.objectContaining({
-          headers: {
-            Authorization: "Bearer token123",
-            "X-Custom-Header": "test",
-          },
-        }),
-        expect.anything(),
-      );
+      new MCPProxy("test-proxy", mockOpenApiSpec);
+      expectHeaders({ Authorization: "Bearer token123", "X-Custom-Header": "test" });
     });
 
     it("should return empty object when env var is not set", () => {
       delete process.env.OPENAPI_MCP_HEADERS;
-
-      const proxy = new MCPProxy("test-proxy", mockOpenApiSpec);
-      expect(HttpClient).toHaveBeenCalledWith(
-        expect.objectContaining({
-          headers: {},
-        }),
-        expect.anything(),
-      );
+      new MCPProxy("test-proxy", mockOpenApiSpec);
+      expectHeaders({});
     });
 
     it("should return empty object and warn on invalid JSON", () => {
       const consoleSpy = vi.spyOn(console, "warn");
       process.env.OPENAPI_MCP_HEADERS = "invalid json";
-
-      const proxy = new MCPProxy("test-proxy", mockOpenApiSpec);
-      expect(HttpClient).toHaveBeenCalledWith(
-        expect.objectContaining({
-          headers: {},
-        }),
-        expect.anything(),
-      );
+      new MCPProxy("test-proxy", mockOpenApiSpec);
+      expectHeaders({});
       expect(consoleSpy).toHaveBeenCalledWith(
         "Failed to parse OPENAPI_MCP_HEADERS environment variable:",
         expect.any(Error),
@@ -261,20 +182,48 @@ describe("MCPProxy", () => {
     it("should return empty object and warn on non-object JSON", () => {
       const consoleSpy = vi.spyOn(console, "warn");
       process.env.OPENAPI_MCP_HEADERS = '"string"';
-
-      const proxy = new MCPProxy("test-proxy", mockOpenApiSpec);
-      expect(HttpClient).toHaveBeenCalledWith(
-        expect.objectContaining({
-          headers: {},
-        }),
-        expect.anything(),
-      );
+      new MCPProxy("test-proxy", mockOpenApiSpec);
+      expectHeaders({});
       expect(consoleSpy).toHaveBeenCalledWith(
         "OPENAPI_MCP_HEADERS environment variable must be a JSON object, got:",
         "string",
       );
     });
   });
+
+  describe("base URL integration", () => {
+    const originalEnv = process.env;
+    const expectBaseUrl = (url: string) => {
+      expect(HttpClient).toHaveBeenCalledWith(expect.objectContaining({ baseUrl: url }), expect.anything());
+    };
+
+    beforeEach(() => {
+      process.env = { ...originalEnv };
+    });
+
+    afterEach(() => {
+      process.env = originalEnv;
+    });
+
+    it("should use ANYTYPE_API_BASE_URL when set", () => {
+      process.env.ANYTYPE_API_BASE_URL = "http://localhost:31012";
+      new MCPProxy("test-proxy", mockOpenApiSpec);
+      expectBaseUrl("http://localhost:31012");
+    });
+
+    it("should use spec servers when env var not set", () => {
+      delete process.env.ANYTYPE_API_BASE_URL;
+      new MCPProxy("test-proxy", mockOpenApiSpec);
+      expectBaseUrl("http://localhost:3000");
+    });
+
+    it("should use default when neither env var nor spec servers available", () => {
+      delete process.env.ANYTYPE_API_BASE_URL;
+      new MCPProxy("test-proxy", createMockOpenApiSpec({ servers: undefined }));
+      expectBaseUrl("http://127.0.0.1:31009");
+    });
+  });
+
   describe("connect", () => {
     it("should connect to transport", async () => {
       const mockTransport = {} as Transport;

package/src/mcp/proxy.ts

@@ -6,6 +6,7 @@ import { Headers } from "node-fetch";
 import { OpenAPIV3 } from "openapi-types";
 import { HttpClient, HttpClientError } from "../client/http-client";
 import { OpenAPIToMCPConverter } from "../openapi/parser";
+import { determineBaseUrl } from "../utils/base-url";
 
 type PathItemObject = OpenAPIV3.PathItemObject & {
   get?: OpenAPIV3.OperationObject;
@@ -32,7 +33,7 @@ export class MCPProxy {
 
   constructor(name: string, openApiSpec: OpenAPIV3.Document) {
     this.server = new Server({ name, version: "1.0.0" }, { capabilities: { tools: {} } });
-    const baseUrl = openApiSpec.servers?.[0].url || "http://127.0.0.1:31009";
+    const baseUrl = determineBaseUrl(openApiSpec);
     this.httpClient = new HttpClient(
       {
         baseUrl,

package/src/utils/__tests__/base-url.test.ts

@@ -0,0 +1,136 @@
+import { OpenAPIV3 } from "openapi-types";
+import { afterEach, beforeEach, describe, expect, it, vi } from "vitest";
+import { determineBaseUrl, getDefaultSpecUrl, parseBaseUrlFromEnv } from "../base-url";
+
+describe("base-url utilities", () => {
+  const originalEnv = process.env;
+
+  beforeEach(() => {
+    process.env = { ...originalEnv };
+  });
+
+  afterEach(() => {
+    process.env = originalEnv;
+  });
+
+  describe("parseBaseUrlFromEnv", () => {
+    it("should parse valid HTTP URL from env", () => {
+      process.env.ANYTYPE_API_BASE_URL = "http://localhost:31012";
+      expect(parseBaseUrlFromEnv()).toBe("http://localhost:31012");
+    });
+
+    it("should parse valid HTTPS URL from env", () => {
+      process.env.ANYTYPE_API_BASE_URL = "https://api.example.com:8080";
+      expect(parseBaseUrlFromEnv()).toBe("https://api.example.com:8080");
+    });
+
+    it("should strip path from URL and return origin only", () => {
+      process.env.ANYTYPE_API_BASE_URL = "http://localhost:31012/api/v1";
+      expect(parseBaseUrlFromEnv()).toBe("http://localhost:31012");
+    });
+
+    it("should return null when env var is not set", () => {
+      delete process.env.ANYTYPE_API_BASE_URL;
+      expect(parseBaseUrlFromEnv()).toBeNull();
+    });
+
+    it("should return null and warn on invalid URL", () => {
+      const consoleSpy = vi.spyOn(console, "warn");
+      process.env.ANYTYPE_API_BASE_URL = "not-a-valid-url";
+
+      expect(parseBaseUrlFromEnv()).toBeNull();
+      expect(consoleSpy).toHaveBeenCalledWith(
+        "Failed to parse ANYTYPE_API_BASE_URL environment variable:",
+        expect.any(Error),
+      );
+    });
+
+    it("should return null and warn on unsupported protocol", () => {
+      const consoleSpy = vi.spyOn(console, "warn");
+      process.env.ANYTYPE_API_BASE_URL = "ftp://localhost:31012";
+
+      expect(parseBaseUrlFromEnv()).toBeNull();
+      expect(consoleSpy).toHaveBeenCalledWith(
+        "ANYTYPE_API_BASE_URL must use http:// or https:// protocol, got: ftp:. Ignoring and using fallback.",
+      );
+    });
+  });
+
+  describe("determineBaseUrl", () => {
+    const mockOpenApiSpec: OpenAPIV3.Document = {
+      openapi: "3.0.0",
+      servers: [{ url: "http://localhost:3000" }],
+      info: {
+        title: "Test API",
+        version: "1.0.0",
+      },
+      paths: {},
+    };
+
+    it("should prioritize ANYTYPE_API_BASE_URL over spec servers", () => {
+      const consoleSpy = vi.spyOn(console, "error");
+      process.env.ANYTYPE_API_BASE_URL = "http://localhost:31012";
+
+      expect(determineBaseUrl(mockOpenApiSpec)).toBe("http://localhost:31012");
+      expect(consoleSpy).toHaveBeenCalledWith("Using base URL from ANYTYPE_API_BASE_URL: http://localhost:31012");
+    });
+
+    it("should use spec servers[0].url when env var is not set", () => {
+      const consoleSpy = vi.spyOn(console, "error");
+      delete process.env.ANYTYPE_API_BASE_URL;
+
+      expect(determineBaseUrl(mockOpenApiSpec)).toBe("http://localhost:3000");
+      expect(consoleSpy).toHaveBeenCalledWith("Using base URL from OpenAPI spec: http://localhost:3000");
+    });
+
+    it("should use default fallback when neither env var nor spec servers are available", () => {
+      const consoleSpy = vi.spyOn(console, "error");
+      delete process.env.ANYTYPE_API_BASE_URL;
+      const specWithoutServers = {
+        ...mockOpenApiSpec,
+        servers: undefined,
+      };
+
+      expect(determineBaseUrl(specWithoutServers)).toBe("http://127.0.0.1:31009");
+      expect(consoleSpy).toHaveBeenCalledWith("Using default base URL: http://127.0.0.1:31009");
+    });
+
+    it("should use default fallback when spec is not provided", () => {
+      const consoleSpy = vi.spyOn(console, "error");
+      delete process.env.ANYTYPE_API_BASE_URL;
+
+      expect(determineBaseUrl()).toBe("http://127.0.0.1:31009");
+      expect(consoleSpy).toHaveBeenCalledWith("Using default base URL: http://127.0.0.1:31009");
+    });
+
+    it("should fallback to spec servers when env var is invalid", () => {
+      const consoleSpy = vi.spyOn(console, "error");
+      process.env.ANYTYPE_API_BASE_URL = "invalid-url";
+
+      expect(determineBaseUrl(mockOpenApiSpec)).toBe("http://localhost:3000");
+      expect(consoleSpy).toHaveBeenCalledWith("Using base URL from OpenAPI spec: http://localhost:3000");
+    });
+  });
+
+  describe("getDefaultSpecUrl", () => {
+    it("should use ANYTYPE_API_BASE_URL with /docs/openapi.json suffix when set", () => {
+      process.env.ANYTYPE_API_BASE_URL = "http://localhost:31012";
+      expect(getDefaultSpecUrl()).toBe("http://localhost:31012/docs/openapi.json");
+    });
+
+    it("should strip path from endpoint before adding suffix", () => {
+      process.env.ANYTYPE_API_BASE_URL = "http://localhost:31012/some/path";
+      expect(getDefaultSpecUrl()).toBe("http://localhost:31012/docs/openapi.json");
+    });
+
+    it("should return default URL when env var is not set", () => {
+      delete process.env.ANYTYPE_API_BASE_URL;
+      expect(getDefaultSpecUrl()).toBe("http://127.0.0.1:31009/docs/openapi.json");
+    });
+
+    it("should return default URL when env var is invalid", () => {
+      process.env.ANYTYPE_API_BASE_URL = "invalid-url";
+      expect(getDefaultSpecUrl()).toBe("http://127.0.0.1:31009/docs/openapi.json");
+    });
+  });
+});

package/src/utils/base-url.ts

@@ -0,0 +1,67 @@
+import { URL } from "node:url";
+import { OpenAPIV3 } from "openapi-types";
+
+/**
+ * Parses the ANYTYPE_API_BASE_URL environment variable and returns the origin.
+ * Returns null if not set, invalid, or uses an unsupported protocol.
+ */
+export function parseBaseUrlFromEnv(): string | null {
+  const endpoint = process.env.ANYTYPE_API_BASE_URL;
+  if (!endpoint) {
+    return null;
+  }
+
+  try {
+    const url = new URL(endpoint);
+    if (url.protocol !== "http:" && url.protocol !== "https:") {
+      console.warn(
+        `ANYTYPE_API_BASE_URL must use http:// or https:// protocol, got: ${url.protocol}. Ignoring and using fallback.`,
+      );
+      return null;
+    }
+    return url.origin;
+  } catch (error) {
+    console.warn("Failed to parse ANYTYPE_API_BASE_URL environment variable:", error);
+    return null;
+  }
+}
+
+/**
+ * Determines the base URL using priority order:
+ * 1. ANYTYPE_API_BASE_URL environment variable
+ * 2. OpenAPI spec servers[0].url
+ * 3. Default fallback: http://127.0.0.1:31009
+ */
+export function determineBaseUrl(openApiSpec?: OpenAPIV3.Document): string {
+  // Priority 1: Environment variable
+  const envEndpoint = parseBaseUrlFromEnv();
+  if (envEndpoint) {
+    console.error(`Using base URL from ANYTYPE_API_BASE_URL: ${envEndpoint}`);
+    return envEndpoint;
+  }
+
+  // Priority 2: OpenAPI spec servers[0].url
+  const specUrl = openApiSpec?.servers?.[0]?.url;
+  if (specUrl) {
+    console.error(`Using base URL from OpenAPI spec: ${specUrl}`);
+    return specUrl;
+  }
+
+  // Priority 3: Default fallback
+  const defaultUrl = "http://127.0.0.1:31009";
+  console.error(`Using default base URL: ${defaultUrl}`);
+  return defaultUrl;
+}
+
+/**
+ * Gets the default OpenAPI spec URL.
+ * If ANYTYPE_API_BASE_URL is set, uses it with /docs/openapi.json suffix.
+ * Otherwise, returns the default spec URL.
+ */
+export function getDefaultSpecUrl(): string {
+  const endpoint = parseBaseUrlFromEnv();
+  if (endpoint) {
+    return `${endpoint}/docs/openapi.json`;
+  }
+  return "http://127.0.0.1:31009/docs/openapi.json";
+}