@openephemeris/mcp-server 3.2.12 → 3.3.0

package/dist/scripts/test-all-tools.js

@@ -1,104 +0,0 @@
-import { toolRegistry, initTools } from "../src/tools/index.js";
-import { backendClient } from "../src/backend/client.js";
-const API_KEY = process.env.OPENEPHEMERIS_API_KEY || "";
-const API_URL = process.env.OPENEPHEMERIS_API_URL || "https://api.openephemeris.com";
-// Hardcoded valid inputs matching the MCP Tool Zod Schemas (not the REST API JSON structures)
-const toolFixtures = {
-    dev_call: { method: "GET", path: "/health", query: {} },
-    dev_list_allowed: {},
-    ephemeris_natal_chart: {
-        datetime: "1990-04-15T14:30:00Z",
-        latitude: 41.87,
-        longitude: -87.62,
-        house_system: "placidus"
-    },
-    ephemeris_transits: {
-        natal_datetime: "1990-04-15T14:30:00Z",
-        natal_latitude: 41.87,
-        natal_longitude: -87.62,
-        start_date: "2026-03-20",
-        end_date: "2026-03-27",
-        transiting_planets: ["saturn"]
-    },
-    ephemeris_moon_phase: { datetime: "2026-03-20T12:00:00Z" },
-    ephemeris_next_eclipse: { date: "2026-03-20", eclipse_type: "solar", latitude: 41.87, longitude: -87.62 },
-    ephemeris_synastry: {
-        person_a_datetime: "1990-04-15T14:30:00Z",
-        person_a_latitude: 41.87,
-        person_a_longitude: -87.62,
-        person_b_datetime: "1992-08-20T10:00:00Z",
-        person_b_latitude: 34.05,
-        person_b_longitude: -118.24
-    },
-    ephemeris_relocation: {
-        natal_datetime: "1990-04-15T14:30:00Z",
-        natal_latitude: 41.87,
-        natal_longitude: -87.62,
-        relocation_latitude: 51.5,
-        relocation_longitude: -0.12
-    },
-    ephemeris_electional: {
-        start_date: "2026-03-20T00:00:00Z",
-        end_date: "2026-03-30T00:00:00Z",
-        latitude: 41.87,
-        longitude: -87.62,
-        aspects: ["sun trine moon"]
-    },
-    human_design_chart: {
-        datetime: "1990-04-15T14:30:00Z",
-        latitude: 41.87,
-        longitude: -87.62
-    }
-};
-async function main() {
-    if (!API_KEY) {
-        console.error("Please set OPENEPHEMERIS_API_KEY");
-        process.exit(1);
-    }
-    console.log(`Starting recursive test loop against: ${API_URL}`);
-    await initTools("dev");
-    // Use the default singleton imported from `backendClient`
-    backendClient.setApiKey(API_KEY);
-    const passed = [];
-    const failed = [];
-    for (const [name, tool] of Object.entries(toolRegistry)) {
-        if (name.startsWith("auth_"))
-            continue;
-        console.log(`\nTesting tool: ${name}`);
-        const args = toolFixtures[name];
-        if (!args) {
-            console.log(`  ⏭️ Skipped (no fixture data)`);
-            continue;
-        }
-        try {
-            // Just run the tool handler directly
-            const parsedArgs = args;
-            // Set up the singleton backendClient API key so the imported modules use it
-            backendClient.setApiKey(API_KEY);
-            const result = await tool.handler(parsedArgs);
-            if (result.isError) {
-                throw new Error(`Tool responded with isError=true.\n    Output: ${JSON.stringify(result.content)}`);
-            }
-            const snippet = result.content?.[0]?.text?.substring(0, 80).replace(/\n/g, "") || "No content";
-            console.log(`  ✅ Passed (${snippet}...)`);
-            passed.push(name);
-        }
-        catch (e) {
-            let errorMsg = e.message;
-            if (e.errors) {
-                // Zod validation error on testing inputs
-                errorMsg = "Schema Validation Failed: " + JSON.stringify(e.errors.map((err) => `${err.path.join('.')}: ${err.message}`));
-            }
-            console.log(`  ❌ Failed: ${errorMsg}`);
-            failed.push({ name, error: errorMsg });
-        }
-    }
-    console.log(`\n${"-".repeat(50)}`);
-    console.log(`Results: ${passed.length} passed, ${failed.length} failed`);
-    if (failed.length > 0) {
-        console.log("Failed tools:");
-        failed.forEach(f => console.log(` - ${f.name}: ${f.error}`));
-        process.exit(1);
-    }
-}
-main().catch(console.log);

package/dist/scripts/test-client.js

@@ -1,69 +0,0 @@
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { StdioClientTransport } from "@modelcontextprotocol/sdk/client/stdio.js";
-import path from "node:path";
-import { fileURLToPath } from "node:url";
-const __dirname = path.dirname(fileURLToPath(import.meta.url));
-async function main() {
-    console.log("🚀 Starting MCP Integration Test...");
-    // Path to the primary entrypoint
-    const serverPath = path.resolve(__dirname, "../src/index.ts");
-    // Spin up the stdio transport simulating a client like Claude/Cursor
-    const transport = new StdioClientTransport({
-        command: "npx",
-        args: ["tsx", serverPath],
-        env: {
-            ...process.env,
-            // Pass the profile explicitly for predictable responses
-            OPENEPHEMERIS_PROFILE: "dev",
-        },
-    });
-    const client = new Client({ name: "test-client", version: "1.0.0" }, { capabilities: {} });
-    console.log("🔌 Connecting to local MCP server via stdio...");
-    await client.connect(transport);
-    console.log("✅ Handshake complete. Protocol negotiated successfully.");
-    // Test 1: List Tools
-    console.log("\n📡 Polling server tools...");
-    const toolsResponse = await client.listTools();
-    console.log(`✅ Discovered ${toolsResponse.tools.length} tools.`);
-    // Verify core tools exist
-    const toolNames = toolsResponse.tools.map((t) => t.name);
-    const coreTools = ["auth.login", "dev.call", "ephemeris.moon_phase", "ephemeris.natal_chart"];
-    for (const name of coreTools) {
-        if (!toolNames.includes(name)) {
-            throw new Error(`❌ Missing expected tool: ${name}`);
-        }
-    }
-    // Test 2: Call an open endpoint that doesn't strictly require API Key for simple responses, 
-    // or handle the graceful 401 prompt gracefully if it does.
-    // Tools returning standard 401s with markdown prompts are still valid successful MCP JSON-RPC calls.
-    console.log("\n⚙️ Testing 'ephemeris.moon_phase' tool call...");
-    try {
-        const result = await client.callTool({
-            name: "ephemeris.moon_phase",
-            arguments: {}, // Defaults to current time
-        });
-        // An MCP tool response is usually { content: [ { type: 'text', text: '...' } ], isError: boolean }
-        const res = result;
-        if (res.isError) {
-            console.log("⚠️ Tool execution returned an expected application error (e.g. 401 Unauthorized expected without valid credentials):\n");
-            console.log(res.content);
-        }
-        else {
-            console.log("✅ Tool executed successfully! Response preview:");
-            const content = res.content[0];
-            console.log(content.text ? content.text.slice(0, 300) + "..." : res.content);
-        }
-    }
-    catch (err) {
-        console.error("❌ Exception during tool execution:", err);
-        process.exit(1);
-    }
-    console.log("\n🎉 Integration Test Passed. Client and Server are communicating perfectly.");
-    // Cleanup gracefully
-    await transport.close();
-    process.exit(0);
-}
-main().catch((err) => {
-    console.error("Fatal Error:", err);
-    process.exit(1);
-});

package/dist/scripts/test-sse-client.js

@@ -1,221 +0,0 @@
-/**
- * test-sse-client.ts — Integration tests for the Remote SSE MCP server.
- *
- * Usage:
- *   Internal (local):
- *     Start the SSE server first:  npm run dev:sse
- *     Then run:                    npx tsx scripts/test-sse-client.ts
- *
- *   External (production):
- *     OPENEPHEMERIS_SSE_URL=https://mcp.openephemeris.com \
- *     OPENEPHEMERIS_API_KEY=opene-xxx \
- *     npx tsx scripts/test-sse-client.ts
- *
- * Tests:
- *   1. Health endpoint responds correctly
- *   2. SSE connection without API key is rejected (401)
- *   3. SSE connection with invalid API key is rejected (403)
- *   4. SSE connection + MCP handshake succeeds with valid key
- *   5. Tool discovery returns expected core tools
- *   6. Tool call (moon phase) executes end-to-end
- */
-import { Client } from "@modelcontextprotocol/sdk/client/index.js";
-import { SSEClientTransport } from "@modelcontextprotocol/sdk/client/sse.js";
-import axios from "axios";
-const SSE_BASE = process.env.OPENEPHEMERIS_SSE_URL?.replace(/\/+$/, "") ||
-    "http://localhost:3001";
-const API_KEY = process.env.OPENEPHEMERIS_API_KEY || "";
-const passed = [];
-const failed = [];
-function ok(name) {
-    passed.push(name);
-    console.log(`  ✅ ${name}`);
-}
-function fail(name, err) {
-    failed.push(name);
-    console.error(`  ❌ ${name}: ${err instanceof Error ? err.message : String(err)}`);
-}
-// ---------------------------------------------------------------------------
-// Test 1: Health endpoint
-// ---------------------------------------------------------------------------
-async function testHealth() {
-    const name = "Health endpoint responds";
-    try {
-        const res = await axios.get(`${SSE_BASE}/health`, { timeout: 5_000 });
-        if (res.data.ok !== true)
-            throw new Error(`Expected ok:true, got ${JSON.stringify(res.data)}`);
-        if (!res.data.version)
-            throw new Error("Missing version in health response");
-        if (res.data.transport !== "sse")
-            throw new Error(`Expected transport:sse, got ${res.data.transport}`);
-        ok(name);
-    }
-    catch (err) {
-        fail(name, err);
-    }
-}
-// ---------------------------------------------------------------------------
-// Test 2: No API key → 401
-// ---------------------------------------------------------------------------
-async function testNoApiKey() {
-    const name = "SSE without API key returns 401";
-    try {
-        const res = await axios.get(`${SSE_BASE}/sse`, {
-            timeout: 5_000,
-            validateStatus: () => true,
-        });
-        if (res.status !== 401)
-            throw new Error(`Expected 401, got ${res.status}`);
-        if (res.data.error !== "api_key_required")
-            throw new Error(`Unexpected error code: ${res.data.error}`);
-        ok(name);
-    }
-    catch (err) {
-        fail(name, err);
-    }
-}
-// ---------------------------------------------------------------------------
-// Test 3: Invalid API key → 403 (or accepted if backend can't validate)
-// ---------------------------------------------------------------------------
-async function testInvalidApiKey() {
-    const name = "SSE with invalid API key is handled";
-    try {
-        const controller = new AbortController();
-        // Give the server 3s to respond with 403 or start SSE
-        const timeout = setTimeout(() => controller.abort(), 3_000);
-        const res = await axios.get(`${SSE_BASE}/sse?apiKey=opene-clearly-invalid-key-000`, {
-            validateStatus: () => true,
-            signal: controller.signal,
-            // Disable response buffering so the SSE stream doesn't hang
-            responseType: "stream",
-        });
-        clearTimeout(timeout);
-        if (res.status === 403) {
-            // Backend validated and rejected the key — ideal
-            ok(name + " (403 rejected)");
-        }
-        else if (res.status === 200) {
-            // Backend couldn't distinguish keys or endpoint doesn't require auth —
-            // SSE stream started. This is acceptable, the tool calls will fail later.
-            console.log(`  ⚠️  ${name}: Key accepted (backend may not validate at this layer)`);
-            passed.push(name);
-        }
-        else {
-            ok(name + ` (${res.status})`);
-        }
-        // Clean up the stream
-        try {
-            res.data?.destroy?.();
-        }
-        catch { /* ignore */ }
-    }
-    catch (err) {
-        if (err.code === "ERR_CANCELED" || err.name === "CanceledError") {
-            // The SSE stream started (200) and we aborted — that's valid
-            console.log(`  ⚠️  ${name}: SSE stream started (key was accepted), aborted cleanly`);
-            passed.push(name);
-        }
-        else {
-            fail(name, err);
-        }
-    }
-}
-// ---------------------------------------------------------------------------
-// Test 4-6: Full SSE client connection + tool discovery + tool call
-// ---------------------------------------------------------------------------
-async function testFullSseFlow() {
-    if (!API_KEY) {
-        const skip = "Full SSE flow (skipped — no OPENEPHEMERIS_API_KEY set)";
-        console.log(`  ⏭️  ${skip}`);
-        return;
-    }
-    // Test 4: Connect
-    const connectName = "SSE connection + MCP handshake";
-    let client = null;
-    let transport = null;
-    try {
-        const sseUrl = new URL(`${SSE_BASE}/sse?apiKey=${API_KEY}`);
-        transport = new SSEClientTransport(sseUrl);
-        client = new Client({ name: "sse-test-client", version: "1.0.0" }, { capabilities: {} });
-        await client.connect(transport);
-        ok(connectName);
-    }
-    catch (err) {
-        fail(connectName, err);
-        return; // Can't continue without a connection
-    }
-    // Test 5: Tool discovery
-    const discoveryName = "Tool discovery returns core tools";
-    try {
-        const tools = await client.listTools();
-        const names = tools.tools.map((t) => t.name);
-        const required = ["auth_login", "dev_call", "ephemeris_moon_phase", "ephemeris_natal_chart"];
-        const missing = required.filter((r) => !names.includes(r));
-        if (missing.length > 0)
-            throw new Error(`Missing tools: ${missing.join(", ")}`);
-        console.log(`    Found ${tools.tools.length} tools`);
-        ok(discoveryName);
-    }
-    catch (err) {
-        fail(discoveryName, err);
-    }
-    // Test 6: Tool call
-    const callName = "Tool call (moon_phase) returns data";
-    try {
-        const result = await client.callTool({
-            name: "ephemeris_moon_phase",
-            arguments: {},
-        });
-        const res = result;
-        if (res.isError) {
-            // A 401 error is acceptable if the server's own key isn't set
-            const text = res.content?.[0]?.text || "";
-            if (text.includes("401") || text.includes("auth")) {
-                console.log(`    ⚠️ Tool returned auth error (server service key may not be configured)`);
-                ok(callName + " (auth expected)");
-            }
-            else {
-                throw new Error(`Tool returned error: ${text.slice(0, 200)}`);
-            }
-        }
-        else {
-            const text = res.content?.[0]?.text || "";
-            console.log(`    Response preview: ${text.slice(0, 150)}...`);
-            ok(callName);
-        }
-    }
-    catch (err) {
-        fail(callName, err);
-    }
-    // Cleanup
-    try {
-        await transport?.close();
-    }
-    catch {
-        // ignore
-    }
-}
-// ---------------------------------------------------------------------------
-// Runner
-// ---------------------------------------------------------------------------
-async function main() {
-    console.log(`\n🧪 SSE MCP Server Integration Tests`);
-    console.log(`   Target: ${SSE_BASE}`);
-    console.log(`   API Key: ${API_KEY ? API_KEY.slice(0, 10) + "..." : "(none — full flow skipped)"}\n`);
-    await testHealth();
-    await testNoApiKey();
-    await testInvalidApiKey();
-    await testFullSseFlow();
-    console.log(`\n${"─".repeat(50)}`);
-    console.log(`  Passed: ${passed.length}  |  Failed: ${failed.length}`);
-    if (failed.length > 0) {
-        console.error(`\n❌ ${failed.length} test(s) failed.`);
-        process.exit(1);
-    }
-    console.log(`\n🎉 All tests passed!`);
-    process.exit(0);
-}
-main().catch((err) => {
-    console.error("Fatal:", err);
-    process.exit(1);
-});

package/dist/src/backend/client.d.ts

@@ -1,67 +0,0 @@
-export interface BackendConfig {
-    baseURL: string;
-    userId?: string;
-    jwt?: string;
-    serviceKey?: string;
-    apiKey?: string;
-    /** Back-compat: previous name for JWT token (Bearer). */
-    authToken?: string;
-}
-export type HttpMethod = "GET" | "POST" | "PUT" | "PATCH" | "DELETE";
-export interface BackendRequestOptions {
-    params?: Record<string, unknown>;
-    data?: unknown;
-    headers?: Record<string, string>;
-    /** Override per-request timeout in milliseconds. */
-    timeoutMs?: number;
-}
-export interface BinaryBackendResponse {
-    content_type: string;
-    content_length: number;
-    encoding: "base64";
-    data_base64: string;
-}
-export declare class BackendError extends Error {
-    readonly status: number;
-    readonly code: string;
-    readonly retryable: boolean;
-    readonly upgradeUrl?: string | undefined;
-    constructor(message: string, status: number, code: string, retryable: boolean, upgradeUrl?: string | undefined);
-}
-export declare class BackendClient {
-    private client;
-    private userId;
-    private jwt?;
-    private serviceKey?;
-    private apiKey?;
-    private credentialManager;
-    private _pendingAuthFlow;
-    private _authFlowResult;
-    constructor(config: BackendConfig);
-    /**
-     * Override the API key at runtime. Used by the SSE server to inject the
-     * per-session user's key so that all tool calls are authenticated and
-     * metered against the correct user account.
-     */
-    setApiKey(key: string): void;
-    /**
-     * Start the device auth flow in the background if not already running.
-     * Called automatically when no credentials are found in the interceptor.
-     * Idempotent — only starts once per client lifetime.
-     */
-    private autoStartDeviceAuth;
-    private expectsBinaryResponse;
-    private toBuffer;
-    private decodePayload;
-    private extractMessage;
-    private normalizeContentType;
-    private isBinaryContentType;
-    /** Maps an AxiosError to a structured BackendError. */
-    private mapError;
-    get<T>(path: string, params?: Record<string, any>, timeoutMs?: number): Promise<T>;
-    post<T>(path: string, data?: any, timeoutMs?: number): Promise<T>;
-    delete<T>(path: string): Promise<T>;
-    request<T>(method: HttpMethod, path: string, options?: BackendRequestOptions): Promise<T>;
-    getUserId(): string;
-}
-export declare const backendClient: BackendClient;