@openephemeris/mcp-server 3.1.0 → 3.2.2

package/dist/src/auth/device-auth.js

@@ -0,0 +1,147 @@
+import { CredentialManager } from "./credentials.js";
+/** Polling interval in milliseconds. */
+const POLL_INTERVAL_MS = 5_000;
+/** Maximum time to poll before giving up (10 minutes = device code TTL). */
+const MAX_POLL_DURATION_MS = 10 * 60 * 1000;
+/**
+ * Custom error thrown when the MCP server needs authentication
+ * but no credentials are available and device auth hasn't been started.
+ */
+export class NeedsAuthError extends Error {
+    verificationUri;
+    userCode;
+    constructor(verificationUri, userCode) {
+        super(`Authentication required. Visit ${verificationUri} and enter code: ${userCode}`);
+        this.name = "NeedsAuthError";
+        this.verificationUri = verificationUri;
+        this.userCode = userCode;
+    }
+}
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+/**
+ * DeviceAuthFlow implements RFC 8628 Device Authorization Grant
+ * for connecting the MCP server to a user's OpenEphemeris account.
+ */
+export class DeviceAuthFlow {
+    baseURL;
+    credentialManager;
+    constructor(baseURL, credentialManager) {
+        this.baseURL =
+            baseURL ||
+                process.env.NEXT_PUBLIC_APP_URL ||
+                process.env.OPENEPHEMERIS_FRONTEND_URL ||
+                "https://openephemeris.com";
+        this.credentialManager = credentialManager || new CredentialManager(this.baseURL);
+    }
+    /**
+     * Start the device authorization flow.
+     * Calls POST /api/device/authorize to get a device code + user code.
+     */
+    async start(clientName) {
+        const response = await fetch(`${this.baseURL}/api/device/authorize`, {
+            method: "POST",
+            headers: { "Content-Type": "application/json" },
+            body: JSON.stringify({
+                client_name: clientName || "openephemeris-mcp",
+            }),
+        });
+        if (!response.ok) {
+            const errorData = await response.json().catch(() => ({}));
+            throw new Error(`Failed to start device authorization: ${errorData.error_description || response.statusText}`);
+        }
+        return (await response.json());
+    }
+    /**
+     * Poll the token endpoint until the user authorizes the device code
+     * or the code expires.
+     *
+     * @param deviceCode - The device_code from start()
+     * @param onPending - Optional callback fired on each "authorization_pending" poll
+     * @returns The token result with access_token and refresh_token
+     */
+    async poll(deviceCode, onPending) {
+        const startedAt = Date.now();
+        let attempt = 0;
+        while (Date.now() - startedAt < MAX_POLL_DURATION_MS) {
+            attempt++;
+            const response = await fetch(`${this.baseURL}/api/device/token`, {
+                method: "POST",
+                headers: { "Content-Type": "application/json" },
+                body: JSON.stringify({
+                    device_code: deviceCode,
+                    grant_type: "urn:ietf:params:oauth:grant-type:device_code",
+                }),
+            });
+            if (response.ok) {
+                // Success! User authorized the device.
+                const result = (await response.json());
+                // Persist credentials
+                const expiresAt = new Date(Date.now() + (result.expires_in || 3600) * 1000).toISOString();
+                this.credentialManager.save({
+                    access_token: result.access_token,
+                    refresh_token: result.refresh_token,
+                    expires_at: expiresAt,
+                    user_id: result.user?.id,
+                    user_email: result.user?.email,
+                    updated_at: new Date().toISOString(),
+                });
+                return result;
+            }
+            // Parse error response
+            const errorData = await response.json().catch(() => ({ error: "unknown" }));
+            if (errorData.error === "authorization_pending") {
+                // Still waiting — keep polling
+                onPending?.(attempt);
+                await sleep(POLL_INTERVAL_MS);
+                continue;
+            }
+            if (errorData.error === "slow_down") {
+                // Server wants us to slow down
+                await sleep(POLL_INTERVAL_MS * 2);
+                continue;
+            }
+            if (errorData.error === "expired_token") {
+                throw new Error("Device code expired. Please run auth.login again to get a new code.");
+            }
+            // Any other error is fatal
+            throw new Error(`Device authorization failed: ${errorData.error_description || errorData.error}`);
+        }
+        throw new Error("Device authorization timed out. Please try again.");
+    }
+    /**
+     * Start the full device auth flow: request code, print instructions, poll for token.
+     * This is the main entry point for interactive use.
+     */
+    async authenticate() {
+        const startResult = await this.start();
+        // Print instructions to stderr (visible to the user in terminal,
+        // but not mixed into the MCP stdio JSON protocol)
+        console.error("");
+        console.error("╔══════════════════════════════════════════════════╗");
+        console.error("║         🔗 OpenEphemeris - Connect Account       ║");
+        console.error("╠══════════════════════════════════════════════════╣");
+        console.error(`║  Visit: ${startResult.verification_uri.padEnd(39)} ║`);
+        console.error(`║  Code:  ${startResult.user_code.padEnd(39)} ║`);
+        console.error("╠══════════════════════════════════════════════════╣");
+        console.error("║  Or open this direct link:                       ║");
+        console.error(`║  ${startResult.verification_uri_complete.slice(0, 48).padEnd(48)} ║`);
+        console.error("╚══════════════════════════════════════════════════╝");
+        console.error("");
+        console.error("By using the OpenEphemeris API, you agree to the Terms of Service");
+        console.error("at https://openephemeris.com/terms");
+        console.error("");
+        console.error("Waiting for authorization...");
+        const result = await this.poll(startResult.device_code, (attempt) => {
+            if (attempt % 6 === 0) {
+                // Remind every 30 seconds
+                console.error(`Still waiting... Visit ${startResult.verification_uri} and enter code: ${startResult.user_code}`);
+            }
+        });
+        console.error(`✅ Authenticated as ${result.user?.email || "user"}`);
+        console.error(`   Credentials saved to ${CredentialManager.credentialsPath}`);
+        console.error("");
+        return result;
+    }
+}

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

@@ -0,0 +1,61 @@
+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);
+    /**
+     * 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;

package/dist/src/backend/client.js

@@ -0,0 +1,335 @@
+import axios, { AxiosError } from "axios";
+import { CredentialManager } from "../auth/credentials.js";
+import { DeviceAuthFlow } from "../auth/device-auth.js";
+const DEFAULT_TIMEOUT_MS = 45_000;
+const RETRY_DELAYS_MS = [1_000, 2_000, 4_000]; // Three retries with backoff
+const RETRYABLE_STATUSES = new Set([429, 502, 503, 504]);
+const RETRYABLE_CODES = new Set(["ECONNRESET", "ETIMEDOUT", "ENOTFOUND", "EAI_AGAIN"]);
+const BINARY_ENDPOINT_PREFIXES = [
+    "/visualization/bi-wheel",
+    "/visualization/chart-wheel",
+    "/comparative/visualization/bi-wheel",
+    "/comparative/visualization/chart-wheel",
+];
+const DASHBOARD_ACCOUNT_URL = "https://openephemeris.com/dashboard?tab=account";
+const LOGIN_SIGNUP_URL = "https://openephemeris.com/login?signup=true&redirect=%2Fdashboard%3Ftab%3Daccount";
+const UPGRADE_URL = "https://openephemeris.com/pay";
+function sleep(ms) {
+    return new Promise((resolve) => setTimeout(resolve, ms));
+}
+export class BackendError extends Error {
+    status;
+    code;
+    retryable;
+    upgradeUrl;
+    constructor(message, status, code, retryable, upgradeUrl) {
+        super(message);
+        this.status = status;
+        this.code = code;
+        this.retryable = retryable;
+        this.upgradeUrl = upgradeUrl;
+        this.name = "BackendError";
+    }
+}
+export class BackendClient {
+    client;
+    userId;
+    jwt;
+    serviceKey;
+    apiKey;
+    credentialManager;
+    _pendingAuthFlow = null;
+    _authFlowResult = null;
+    constructor(config) {
+        this.userId = config.userId || "anonymous";
+        this.jwt =
+            config.jwt ||
+                config.authToken ||
+                process.env.OPENEPHEMERIS_JWT ||
+                process.env.ASTROMCP_JWT ||
+                process.env.MERIDIAN_AUTH_TOKEN;
+        this.serviceKey =
+            config.serviceKey ||
+                process.env.OPENEPHEMERIS_SERVICE_KEY ||
+                process.env.ASTROMCP_SERVICE_KEY ||
+                process.env.MERIDIAN_SERVICE_KEY;
+        this.apiKey =
+            config.apiKey ||
+                process.env.OPENEPHEMERIS_API_KEY ||
+                process.env.ASTROMCP_API_KEY ||
+                process.env.MERIDIAN_API_KEY;
+        this.credentialManager = new CredentialManager();
+        this.client = axios.create({
+            baseURL: config.baseURL ||
+                process.env.OPENEPHEMERIS_BACKEND_URL ||
+                process.env.ASTROMCP_BACKEND_URL ||
+                process.env.MERIDIAN_BACKEND_URL ||
+                "https://api.openephemeris.com",
+            timeout: DEFAULT_TIMEOUT_MS,
+            headers: {
+                "Content-Type": "application/json",
+            },
+        });
+        // Add auth interceptor (priority: service key > API key > JWT env > cached JWT)
+        this.client.interceptors.request.use(async (req) => {
+            req.headers = req.headers ?? {};
+            // Explicit per-request headers win.
+            const hasAuthHeader = typeof req.headers.Authorization === "string" &&
+                req.headers.Authorization.length > 0;
+            const hasServiceKeyHeader = typeof req.headers["X-Service-Key"] === "string" &&
+                req.headers["X-Service-Key"].length > 0;
+            const hasApiKeyHeader = typeof req.headers["X-API-Key"] === "string" &&
+                req.headers["X-API-Key"].length > 0;
+            if (!hasAuthHeader && !hasServiceKeyHeader && !hasApiKeyHeader) {
+                if (this.serviceKey) {
+                    req.headers["X-Service-Key"] = this.serviceKey;
+                }
+                else if (this.apiKey) {
+                    req.headers["X-API-Key"] = this.apiKey;
+                }
+                else if (this.jwt) {
+                    req.headers.Authorization = `Bearer ${this.jwt}`;
+                }
+                else {
+                    // Fall through to cached credentials from device auth flow
+                    const cachedToken = await this.credentialManager.getValidToken();
+                    if (cachedToken) {
+                        req.headers.Authorization = `Bearer ${cachedToken}`;
+                    }
+                    else {
+                        // No credentials anywhere — auto-start device auth
+                        await this.autoStartDeviceAuth();
+                    }
+                }
+            }
+            return req;
+        });
+    }
+    /**
+     * 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.
+     */
+    async autoStartDeviceAuth() {
+        if (this._pendingAuthFlow)
+            return; // Already started
+        try {
+            const flow = new DeviceAuthFlow();
+            const startResult = await flow.start();
+            this._authFlowResult = {
+                verification_uri: startResult.verification_uri,
+                user_code: startResult.user_code,
+                verification_uri_complete: startResult.verification_uri_complete,
+            };
+            // Print to stderr so it's visible in MCP host logs
+            console.error(`\n🔗 OpenEphemeris: Account connection required.\n` +
+                `   Visit: ${startResult.verification_uri}\n` +
+                `   Code:  ${startResult.user_code}\n` +
+                `   Or:    ${startResult.verification_uri_complete}\n`);
+            // Poll in background (don't await)
+            this._pendingAuthFlow = flow
+                .poll(startResult.device_code, (attempt) => {
+                if (attempt % 12 === 0) {
+                    console.error(`   Still waiting... Enter code ${startResult.user_code} at ${startResult.verification_uri}`);
+                }
+            })
+                .then(() => {
+                console.error(`✅ Authenticated! Subsequent requests will use your account.`);
+                this._authFlowResult = null;
+            })
+                .catch((err) => {
+                console.error(`❌ Device auth failed: ${err.message}`);
+                this._pendingAuthFlow = null; // Allow retry
+            });
+        }
+        catch (err) {
+            console.error(`Could not start device auth: ${err.message}`);
+            // Don't block — the request will go out unauthenticated and
+            // the 401 response will surface the error message to the user.
+        }
+    }
+    expectsBinaryResponse(path, options) {
+        const normalizedPath = path.split("?")[0].trim().toLowerCase();
+        if (BINARY_ENDPOINT_PREFIXES.some((prefix) => normalizedPath.startsWith(prefix))) {
+            return true;
+        }
+        const format = options?.params?.format;
+        if (typeof format === "string") {
+            const normalizedFormat = format.trim().toLowerCase();
+            if (normalizedFormat === "png" || normalizedFormat === "svg") {
+                return true;
+            }
+        }
+        const acceptHeader = Object.entries(options?.headers ?? {}).find(([key]) => key.toLowerCase() === "accept")?.[1];
+        if (typeof acceptHeader === "string" && acceptHeader.toLowerCase().includes("image/")) {
+            return true;
+        }
+        return false;
+    }
+    toBuffer(data) {
+        if (data == null)
+            return null;
+        if (Buffer.isBuffer(data))
+            return data;
+        if (data instanceof ArrayBuffer)
+            return Buffer.from(data);
+        if (ArrayBuffer.isView(data)) {
+            return Buffer.from(data.buffer, data.byteOffset, data.byteLength);
+        }
+        if (typeof data === "string")
+            return Buffer.from(data);
+        return null;
+    }
+    decodePayload(data) {
+        const asBuffer = this.toBuffer(data);
+        if (!asBuffer) {
+            return data;
+        }
+        const text = asBuffer.toString("utf8").trim();
+        if (!text)
+            return "";
+        try {
+            return JSON.parse(text);
+        }
+        catch {
+            return text;
+        }
+    }
+    extractMessage(data, fallback) {
+        if (typeof data === "string") {
+            const trimmed = data.trim();
+            return trimmed || fallback;
+        }
+        if (data && typeof data === "object") {
+            const obj = data;
+            for (const key of ["message", "detail", "title", "error"]) {
+                const value = obj[key];
+                if (typeof value === "string" && value.trim()) {
+                    return value.trim();
+                }
+            }
+        }
+        return fallback;
+    }
+    normalizeContentType(value) {
+        if (typeof value !== "string")
+            return "";
+        return value.split(";")[0]?.trim().toLowerCase() || "";
+    }
+    isBinaryContentType(contentType) {
+        return contentType.startsWith("image/") || contentType === "application/octet-stream";
+    }
+    /** Maps an AxiosError to a structured BackendError. */
+    mapError(error) {
+        if (error.response) {
+            const status = error.response.status;
+            const data = this.decodePayload(error.response.data);
+            const msg = this.extractMessage(data, error.message);
+            if (status === 401) {
+                const authInfo = this._authFlowResult;
+                if (authInfo) {
+                    return new BackendError(`🔗 Account connection required. Please visit ${authInfo.verification_uri} ` +
+                        `and enter code: ${authInfo.user_code}\n\n` +
+                        `Or open this direct link: ${authInfo.verification_uri_complete}\n\n` +
+                        `Once you authorize, retry your request — the server is polling in the background. ` +
+                        `If you don't have an account, you can create one at the link above (free tier, no credit card needed).`, 401, "auth_required", true, authInfo.verification_uri_complete);
+                }
+                return new BackendError(`Authentication required: ${msg}. Run auth.login to connect your account, ` +
+                    `or set OPENEPHEMERIS_API_KEY in your MCP server config.`, 401, "auth_required", false, LOGIN_SIGNUP_URL);
+            }
+            if (status === 402) {
+                return new BackendError(`Usage quota exceeded: ${msg}. Review usage and overage settings in ${DASHBOARD_ACCOUNT_URL}, ` +
+                    `or upgrade at ${UPGRADE_URL}.`, 402, "quota_exceeded", false, UPGRADE_URL);
+            }
+            if (status === 403) {
+                return new BackendError(`Access blocked by plan or policy: ${msg}. If this endpoint is tier-gated, upgrade at ${UPGRADE_URL}. ` +
+                    `Manage keys and billing at ${DASHBOARD_ACCOUNT_URL}.`, 403, "tier_required", false, UPGRADE_URL);
+            }
+            if (status === 429) {
+                return new BackendError(`Rate limit exceeded. Your plan credits may be exhausted or requests are too frequent. ` +
+                    `Check usage at ${DASHBOARD_ACCOUNT_URL}, then retry in a moment. (${msg})`, 429, "rate_limited", true);
+            }
+            if (status === 404)
+                return new BackendError(`Resource not found: ${msg}`, 404, "not_found", false);
+            if (status === 400)
+                return new BackendError(`Invalid request: ${msg}`, 400, "bad_request", false);
+            if (status >= 500)
+                return new BackendError(`Backend error (${status}): ${msg}`, status, "server_error", true);
+        }
+        return new BackendError(`Network error: ${error.message}`, 0, "network_error", true);
+    }
+    async get(path, params, timeoutMs) {
+        return this.request("GET", path, { params, timeoutMs });
+    }
+    async post(path, data, timeoutMs) {
+        return this.request("POST", path, { data, timeoutMs });
+    }
+    async delete(path) {
+        return this.request("DELETE", path);
+    }
+    async request(method, path, options) {
+        const timeoutMs = options?.timeoutMs ?? DEFAULT_TIMEOUT_MS;
+        const expectsBinary = this.expectsBinaryResponse(path, options);
+        let lastError = new Error("Unknown error");
+        // Attempt + retries on transient failures (429, 502, 503, 504, network errors)
+        for (let attempt = 0; attempt <= RETRY_DELAYS_MS.length; attempt++) {
+            try {
+                const response = await this.client.request({
+                    method,
+                    url: path,
+                    params: options?.params,
+                    data: options?.data,
+                    headers: options?.headers,
+                    timeout: timeoutMs,
+                    responseType: expectsBinary ? "arraybuffer" : "json",
+                });
+                if (!expectsBinary) {
+                    return response.data;
+                }
+                const contentType = this.normalizeContentType(response.headers?.["content-type"]);
+                if (!this.isBinaryContentType(contentType)) {
+                    return this.decodePayload(response.data);
+                }
+                const bytes = this.toBuffer(response.data) ?? Buffer.alloc(0);
+                const payload = {
+                    content_type: contentType || "application/octet-stream",
+                    content_length: bytes.length,
+                    encoding: "base64",
+                    data_base64: bytes.toString("base64"),
+                };
+                return payload;
+            }
+            catch (err) {
+                if (err instanceof AxiosError) {
+                    const isRetryable = (err.response && RETRYABLE_STATUSES.has(err.response.status)) ||
+                        (!err.response && err.code && RETRYABLE_CODES.has(err.code));
+                    if (isRetryable && attempt < RETRY_DELAYS_MS.length) {
+                        const jitter = Math.random() * 500;
+                        await sleep(RETRY_DELAYS_MS[attempt] + jitter);
+                        continue;
+                    }
+                    lastError = this.mapError(err);
+                }
+                else {
+                    lastError = err instanceof Error ? err : new Error(String(err));
+                }
+                throw lastError;
+            }
+        }
+        throw lastError;
+    }
+    getUserId() {
+        return this.userId;
+    }
+}
+// Singleton instance
+export const backendClient = new BackendClient({
+    baseURL: process.env.OPENEPHEMERIS_BACKEND_URL ||
+        process.env.ASTROMCP_BACKEND_URL ||
+        process.env.MERIDIAN_BACKEND_URL ||
+        "https://api.openephemeris.com",
+    userId: process.env.MCP_USER_ID || "anonymous",
+    jwt: process.env.OPENEPHEMERIS_JWT || process.env.ASTROMCP_JWT || process.env.MERIDIAN_AUTH_TOKEN,
+    serviceKey: process.env.OPENEPHEMERIS_SERVICE_KEY || process.env.ASTROMCP_SERVICE_KEY || process.env.MERIDIAN_SERVICE_KEY,
+    apiKey: process.env.OPENEPHEMERIS_API_KEY || process.env.ASTROMCP_API_KEY || process.env.MERIDIAN_API_KEY,
+});

package/dist/src/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export {};

package/dist/src/index.js

@@ -0,0 +1,98 @@
+#!/usr/bin/env node
+import fs from "node:fs";
+import path from "node:path";
+import { fileURLToPath } from "node:url";
+import { Server } from "@modelcontextprotocol/sdk/server/index.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { CallToolRequestSchema, ListToolsRequestSchema, } from "@modelcontextprotocol/sdk/types.js";
+import { initTools, toolRegistry } from "./tools/index.js";
+function resolveServerVersion() {
+    try {
+        const here = path.dirname(fileURLToPath(import.meta.url));
+        const pkgPath = path.resolve(here, "..", "package.json");
+        const raw = fs.readFileSync(pkgPath, "utf-8");
+        const parsed = JSON.parse(raw);
+        if (typeof parsed.version === "string" && parsed.version.trim()) {
+            return parsed.version.trim();
+        }
+    }
+    catch {
+        // Ignore and fall back to an explicit unknown version.
+    }
+    return "0.0.0-unknown";
+}
+const server = new Server({
+    name: "openephemeris-mcp",
+    version: resolveServerVersion(),
+    icons: [
+        {
+            src: "https://mcp.openephemeris.com/icon.png",
+            mimeType: "image/png",
+        }
+    ]
+}, {
+    capabilities: {
+        tools: {},
+    },
+});
+// List available tools
+server.setRequestHandler(ListToolsRequestSchema, async () => {
+    return {
+        tools: Object.values(toolRegistry).map((tool) => ({
+            name: tool.name,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+            annotations: tool.annotations ?? {
+                title: tool.name,
+                readOnlyHint: true,
+                destructiveHint: false,
+            },
+        })),
+    };
+});
+// Handle tool calls
+server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const toolName = request.params.name;
+    const tool = toolRegistry[toolName];
+    if (!tool) {
+        throw new Error(`Unknown tool: ${toolName}`);
+    }
+    try {
+        const result = await tool.handler(request.params.arguments ?? {});
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify(result, null, 2),
+                },
+            ],
+        };
+    }
+    catch (error) {
+        const errorMessage = error instanceof Error ? error.message : String(error);
+        return {
+            content: [
+                {
+                    type: "text",
+                    text: JSON.stringify({
+                        success: false,
+                        error: "TOOL_EXECUTION_ERROR",
+                        message: errorMessage,
+                    }, null, 2),
+                },
+            ],
+            isError: true,
+        };
+    }
+});
+// Start server
+async function main() {
+    await initTools();
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+    console.error("Open Ephemeris MCP server running on stdio");
+}
+main().catch((error) => {
+    console.error("Fatal error:", error);
+    process.exit(1);
+});