@nestpilot/mcp-app 1.0.0

package/dist/cli/export-import.js

@@ -0,0 +1,132 @@
+/**
+ * `nestpilot export` / `nestpilot import` — plan portability.
+ *
+ * Export decrypts plans and packages them as portable JSON.
+ * Import re-encrypts with the local encryption key.
+ *
+ * Export bundle format:
+ * ```json
+ * {
+ *   "version": "1.0",
+ *   "exported": "2026-03-02T...",
+ *   "source": "machine-name",
+ *   "plans": [{ id, plan, forecasts, scenarios }]
+ * }
+ * ```
+ *
+ * @feature FEAT-0088
+ */
+import fs from "node:fs/promises";
+import os from "node:os";
+import path from "node:path";
+import { loadLocalConfig, plansDir, } from "../src/local/local-config.js";
+import { createKeychainProvider } from "../src/local/keychain.js";
+import { EncryptionService } from "../src/local/encryption.js";
+import { LocalPlanStore } from "../src/local/local-plan-store.js";
+// ── Export command ────────────────────────────────────────────────────────
+export async function exportCommand(opts) {
+    const config = loadLocalConfig();
+    const keychain = createKeychainProvider(config.dataDir);
+    const encryption = new EncryptionService(keychain);
+    const store = new LocalPlanStore(config.dataDir, encryption);
+    console.log("\n📦 NestPilot Export\n");
+    let plans = [];
+    if (opts.plan) {
+        // Export specific plan
+        try {
+            const plan = await store.get(opts.plan);
+            plans = [plan];
+        }
+        catch (e) {
+            console.error(`❌ Plan not found: ${opts.plan}. ${e instanceof Error ? e.message : ""}`);
+            process.exit(1);
+        }
+    }
+    else if (opts.all) {
+        // Export all plans
+        const summaries = await store.list();
+        if (summaries.length === 0) {
+            console.log("No plans to export.");
+            return;
+        }
+        for (const summary of summaries) {
+            plans.push(await store.get(summary.id));
+        }
+    }
+    else {
+        console.error("Specify --plan <id> or --all");
+        process.exit(1);
+    }
+    const bundle = {
+        version: "1.0",
+        exported: new Date().toISOString(),
+        source: os.hostname(),
+        plans: plans.map((p) => ({
+            id: p.id,
+            plan: p.plan,
+            forecasts: p.forecasts,
+            scenarios: p.scenarios,
+        })),
+    };
+    const outputPath = opts.output ??
+        path.join(process.cwd(), `nestpilot-export-${new Date().toISOString().slice(0, 10)}.json`);
+    await fs.writeFile(outputPath, JSON.stringify(bundle, null, 2));
+    console.log(`✅ Exported ${plans.length} plan(s) to ${outputPath}`);
+    console.log(`\nImport on another machine: nestpilot import ${path.basename(outputPath)}\n`);
+}
+// ── Import command ───────────────────────────────────────────────────────
+export async function importCommand(file) {
+    const config = loadLocalConfig();
+    const keychain = createKeychainProvider(config.dataDir);
+    const encryption = new EncryptionService(keychain);
+    const store = new LocalPlanStore(config.dataDir, encryption);
+    console.log("\n📥 NestPilot Import\n");
+    // Resolve file path
+    const filePath = path.resolve(file);
+    let raw;
+    try {
+        raw = await fs.readFile(filePath, "utf-8");
+    }
+    catch (e) {
+        console.error(`❌ Cannot read file: ${filePath}. ${e instanceof Error ? e.message : ""}`);
+        process.exit(1);
+    }
+    let bundle;
+    try {
+        bundle = JSON.parse(raw);
+    }
+    catch {
+        console.error("❌ Invalid JSON file.");
+        process.exit(1);
+    }
+    if (bundle.version !== "1.0") {
+        console.error(`❌ Unsupported export version: ${bundle.version}`);
+        process.exit(1);
+    }
+    console.log(`Source: ${bundle.source}`);
+    console.log(`Exported: ${bundle.exported}`);
+    console.log(`Plans: ${bundle.plans.length}\n`);
+    let imported = 0;
+    let skipped = 0;
+    for (const planData of bundle.plans) {
+        try {
+            // Check if plan already exists
+            try {
+                await store.get(planData.id);
+                console.log(`  ⏭ ${planData.id} — already exists (skipped)`);
+                skipped++;
+                continue;
+            }
+            catch {
+                // Plan doesn't exist — import it
+            }
+            await store.create(planData.plan);
+            console.log(`  ✓ ${planData.id} — imported`);
+            imported++;
+        }
+        catch (e) {
+            console.error(`  ❌ ${planData.id} — failed: ${e instanceof Error ? e.message : String(e)}`);
+        }
+    }
+    console.log(`\n✅ Imported ${imported} plan(s), skipped ${skipped} existing.\n`);
+}

package/dist/cli/index.d.ts

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

package/dist/cli/index.js

@@ -0,0 +1,168 @@
+#!/usr/bin/env node
+/**
+ * NestPilot MCP Server CLI — unified entry point for the npm package.
+ *
+ * Commands:
+ *   serve (default)  — Start MCP server (stdio or HTTP)
+ *   init             — Initialize ~/.nestpilot/ and provision API key
+ *   config           — Interactive configuration
+ *   export           — Export plans to portable JSON
+ *   import           — Import plans from export file
+ *   status           — Show local data summary
+ *   doctor           — Diagnose common issues
+ *
+ * @feature FEAT-0088
+ */
+import { Command } from "commander";
+import { initCommand } from "./init.js";
+import { doctorCommand } from "./doctor.js";
+import { exportCommand, importCommand } from "./export-import.js";
+const VERSION = "1.0.0";
+const program = new Command("nestpilot-mcp-server");
+program
+    .description("NestPilot MCP Server — Local-first retirement planning appliance")
+    .version(VERSION);
+// ── serve (default command) ──────────────────────────────────────────────
+program
+    .command("serve", { isDefault: true })
+    .description("Start MCP server (stdio transport by default)")
+    .option("--http", "Use HTTP transport instead of stdio")
+    .option("--port <port>", "HTTP port (default: 3001)", "3001")
+    .action(async (opts) => {
+    // Set environment before importing main
+    process.env.NESTPILOT_MODE = process.env.NESTPILOT_MODE ?? "local";
+    if (opts.http) {
+        process.env.PORT = opts.port;
+    }
+    else {
+        process.argv.push("--stdio");
+    }
+    // Dynamic import to avoid loading server code during CLI-only commands
+    await import("../main.js");
+});
+// ── init ─────────────────────────────────────────────────────────────────
+program
+    .command("init")
+    .description("Initialize ~/.nestpilot/ directory and provision API key")
+    .action(initCommand);
+// ── config ───────────────────────────────────────────────────────────────
+program
+    .command("config")
+    .description("Show or update configuration")
+    .option("--set <key=value>", "Set a configuration value")
+    .action(async (opts) => {
+    const { loadLocalConfig, configFilePath } = await import("../src/local/local-config.js");
+    const fs = await import("node:fs/promises");
+    const config = loadLocalConfig();
+    const configPath = configFilePath(config.dataDir);
+    if (opts.set) {
+        const [key, value] = opts.set.split("=");
+        if (!key || value === undefined) {
+            console.error("Usage: nestpilot config --set key=value");
+            process.exit(1);
+        }
+        let existing = {};
+        try {
+            existing = JSON.parse(await fs.readFile(configPath, "utf-8"));
+        }
+        catch {
+            // No existing config
+        }
+        existing[key] = value;
+        await fs.writeFile(configPath, JSON.stringify(existing, null, 2));
+        console.log(`✓ Set ${key} = ${value}`);
+    }
+    else {
+        console.log("\nNestPilot Configuration:");
+        console.log(`  Mode:       ${config.mode}`);
+        console.log(`  Data dir:   ${config.dataDir}`);
+        console.log(`  Cloud API:  ${config.cloudApiUrl}`);
+        console.log(`  Encryption: ${config.encryptionEnabled ? "enabled" : "disabled"}`);
+        console.log(`  API key:    ${config.apiKey ? "configured" : "not set"}`);
+        console.log(`\nConfig file: ${configPath}`);
+    }
+});
+// ── export ───────────────────────────────────────────────────────────────
+program
+    .command("export")
+    .description("Export plans to portable JSON")
+    .option("--plan <planId>", "Export specific plan by ID")
+    .option("--all", "Export all plans")
+    .option("-o, --output <file>", "Output file path")
+    .action(exportCommand);
+// ── import ───────────────────────────────────────────────────────────────
+program
+    .command("import")
+    .description("Import plans from export file")
+    .argument("<file>", "Path to exported JSON file")
+    .action(importCommand);
+// ── status ───────────────────────────────────────────────────────────────
+program
+    .command("status")
+    .description("Show local data summary")
+    .action(async () => {
+    const { loadLocalConfig, plansDir, forecastsDir } = await import("../src/local/local-config.js");
+    const fs = await import("node:fs/promises");
+    const path = await import("node:path");
+    const config = loadLocalConfig();
+    let planCount = 0;
+    let forecastCount = 0;
+    let totalSize = 0;
+    try {
+        const plans = await fs.readdir(plansDir(config.dataDir));
+        planCount = plans.filter((f) => f.endsWith(".json")).length;
+        for (const file of plans) {
+            const stat = await fs.stat(path.join(plansDir(config.dataDir), file));
+            totalSize += stat.size;
+        }
+    }
+    catch {
+        // Directory may not exist yet
+    }
+    try {
+        const forecasts = await fs.readdir(forecastsDir(config.dataDir));
+        forecastCount = forecasts.filter((f) => f.endsWith(".json")).length;
+        for (const file of forecasts) {
+            const stat = await fs.stat(path.join(forecastsDir(config.dataDir), file));
+            totalSize += stat.size;
+        }
+    }
+    catch {
+        // Directory may not exist yet
+    }
+    const sizeKb = (totalSize / 1024).toFixed(1);
+    console.log("\n📊 NestPilot Status");
+    console.log("══════════════════");
+    console.log(`  Mode:            ${config.mode}`);
+    console.log(`  Data directory:  ${config.dataDir}`);
+    console.log(`  Plans:           ${planCount}`);
+    console.log(`  Cached forecasts: ${forecastCount}`);
+    console.log(`  Disk usage:      ${sizeKb} KB`);
+    console.log(`  Cloud API:       ${config.cloudApiUrl}`);
+    console.log(`  API key:         ${config.apiKey ? "✓ configured" : "✗ not set"}`);
+});
+// ── doctor ───────────────────────────────────────────────────────────────
+program
+    .command("doctor")
+    .description("Diagnose common issues")
+    .action(doctorCommand);
+// ── Parse ────────────────────────────────────────────────────────────────
+// Non-blocking update check (fires and forgets)
+void checkForUpdates();
+program.parse();
+// ── Auto-update check ────────────────────────────────────────────────────
+async function checkForUpdates() {
+    try {
+        const response = await fetch("https://registry.npmjs.org/nestpilot-mcp-server/latest", { signal: AbortSignal.timeout(3_000) });
+        if (!response.ok)
+            return;
+        const { version: latest } = (await response.json());
+        if (latest && latest !== VERSION) {
+            console.error(`[nestpilot] Update available: ${VERSION} → ${latest}`);
+            console.error("[nestpilot] Run: npm update -g nestpilot-mcp-server");
+        }
+    }
+    catch {
+        // Silent fail — don't block startup
+    }
+}

package/dist/cli/init.d.ts

@@ -0,0 +1 @@
+export declare function initCommand(): Promise<void>;

package/dist/cli/init.js

@@ -0,0 +1,171 @@
+/**
+ * `nestpilot init` — bootstraps the local NestPilot environment.
+ *
+ * Steps:
+ *   1. Create ~/.nestpilot/ directory structure
+ *   2. Generate encryption key and store in OS keychain
+ *   3. Optionally provision API key via cloud endpoint
+ *   4. Write config.json with preferences
+ *   5. Copy host config templates
+ *   6. Print success message with next steps
+ *
+ * @feature FEAT-0088
+ */
+import fs from "node:fs/promises";
+import path from "node:path";
+import * as readline from "node:readline/promises";
+import { stdin, stdout } from "node:process";
+import { loadLocalConfig, DATA_SUBDIRS, configFilePath, } from "../src/local/local-config.js";
+import { createKeychainProvider } from "../src/local/keychain.js";
+import { EncryptionService } from "../src/local/encryption.js";
+// ── Init command ─────────────────────────────────────────────────────────
+export async function initCommand() {
+    console.log("\n🏠 NestPilot Local Setup");
+    console.log("========================\n");
+    const config = loadLocalConfig();
+    const { dataDir } = config;
+    // Step 1: Create directory structure
+    console.log("1. Creating data directory structure...");
+    for (const sub of DATA_SUBDIRS) {
+        const dir = path.join(dataDir, sub);
+        await fs.mkdir(dir, { recursive: true });
+        console.log(`   ✓ ${dir}`);
+    }
+    // Also create host-configs output directory
+    const hostConfigDir = path.join(dataDir, "host-configs");
+    await fs.mkdir(hostConfigDir, { recursive: true });
+    console.log(`   ✓ ${hostConfigDir}`);
+    console.log();
+    // Step 2: Encryption setup
+    console.log("2. Encryption Setup");
+    const keychain = createKeychainProvider(dataDir);
+    const encryption = new EncryptionService(keychain);
+    if (await encryption.hasKey()) {
+        console.log("   ✓ Encryption key already exists in keychain");
+    }
+    else {
+        await encryption.generateAndStoreKey();
+        console.log("   ✓ Encryption key generated and stored in OS keychain");
+    }
+    console.log();
+    // Step 3: API Key provisioning (optional)
+    console.log("3. API Key Provisioning");
+    const existingKey = await keychain.get("nestpilot", "api-key");
+    if (existingKey) {
+        console.log("   ✓ API key already configured");
+    }
+    else {
+        const rl = readline.createInterface({ input: stdin, output: stdout });
+        try {
+            const email = await rl.question("   Enter your email for free tier (10 forecasts/mo), or press Enter to skip: ");
+            if (email.trim()) {
+                try {
+                    const response = await fetch(`${config.cloudApiUrl}/api/auth/provision-key`, {
+                        method: "POST",
+                        headers: { "Content-Type": "application/json" },
+                        body: JSON.stringify({ email: email.trim() }),
+                        signal: AbortSignal.timeout(10_000),
+                    });
+                    if (response.ok) {
+                        const data = (await response.json());
+                        await keychain.set("nestpilot", "api-key", data.apiKey);
+                        console.log("   ✓ API key provisioned (10 forecasts/mo free)");
+                        console.log("   ✓ API key stored in OS keychain");
+                    }
+                    else {
+                        console.log("   ⚠ Could not provision API key (cloud API unavailable).");
+                        console.log("   Set NESTPILOT_API_KEY env var manually, or run init again later.");
+                    }
+                }
+                catch {
+                    console.log("   ⚠ Could not reach cloud API for key provisioning.");
+                    console.log("   Set NESTPILOT_API_KEY env var manually, or run init again later.");
+                }
+            }
+            else {
+                console.log("   ⏭ Skipped. Set NESTPILOT_API_KEY env var later.");
+            }
+        }
+        finally {
+            rl.close();
+        }
+    }
+    console.log();
+    // Step 4: Write config.json
+    console.log("4. Configuration");
+    const configPath = configFilePath(dataDir);
+    const configData = {
+        mode: "local",
+        cloudApiUrl: config.cloudApiUrl,
+        encryptionEnabled: true,
+        created: new Date().toISOString(),
+        version: "1.0.0",
+    };
+    await fs.writeFile(configPath, JSON.stringify(configData, null, 2));
+    console.log(`   ✓ ${configPath} created`);
+    console.log();
+    // Step 5: Copy host config templates
+    console.log("5. Host Configuration Templates");
+    await writeHostConfigs(hostConfigDir);
+    console.log(`   ✓ Goose config:   ${path.join(hostConfigDir, "goose.yaml")}`);
+    console.log(`   ✓ Cowork config:  ${path.join(hostConfigDir, "cowork.json")}`);
+    console.log(`   ✓ OpenClaw config: ${path.join(hostConfigDir, "openclaw-manifest.json")}`);
+    console.log();
+    // Step 6: Success
+    console.log("✅ NestPilot is ready!\n");
+    console.log("Next steps:");
+    console.log(`  • Goose:    Add config from ${path.join(hostConfigDir, "goose.yaml")}`);
+    console.log(`  • Claude:   Add config from ${path.join(hostConfigDir, "cowork.json")}`);
+    console.log(`  • OpenClaw: Import from ${path.join(hostConfigDir, "openclaw-manifest.json")}`);
+    console.log();
+    console.log("Quick test: npx nestpilot-mcp-server status");
+    console.log();
+}
+// ── Host config writer ───────────────────────────────────────────────────
+async function writeHostConfigs(dir) {
+    // Goose
+    const gooseConfig = `# NestPilot MCP Server — Goose Configuration
+# Add this to ~/.config/goose/profiles.yaml under extensions:
+
+extensions:
+  nestpilot:
+    type: mcp
+    transport: stdio
+    command: npx
+    args: ["nestpilot-mcp-server"]
+    env:
+      NESTPILOT_MODE: local
+`;
+    await fs.writeFile(path.join(dir, "goose.yaml"), gooseConfig);
+    // Cowork
+    const coworkConfig = {
+        mcpServers: {
+            nestpilot: {
+                command: "npx",
+                args: ["nestpilot-mcp-server"],
+                env: {
+                    NESTPILOT_MODE: "local",
+                },
+            },
+        },
+    };
+    await fs.writeFile(path.join(dir, "cowork.json"), JSON.stringify(coworkConfig, null, 2));
+    // OpenClaw
+    const openclawManifest = {
+        name: "nestpilot",
+        version: "1.0.0",
+        description: "Local-first retirement planning — your data stays on your machine",
+        transport: "stdio",
+        command: "npx",
+        args: ["nestpilot-mcp-server"],
+        env: {
+            NESTPILOT_MODE: "local",
+        },
+        capabilities: {
+            tools: true,
+            resources: true,
+            apps: true,
+        },
+    };
+    await fs.writeFile(path.join(dir, "openclaw-manifest.json"), JSON.stringify(openclawManifest, null, 2));
+}

package/dist/host-configs/cowork.json

@@ -0,0 +1,11 @@
+{
+  "mcpServers": {
+    "nestpilot": {
+      "command": "npx",
+      "args": ["nestpilot-mcp-server"],
+      "env": {
+        "NESTPILOT_MODE": "local"
+      }
+    }
+  }
+}

package/dist/host-configs/goose.yaml

@@ -0,0 +1,22 @@
+# NestPilot MCP Server — Goose Host Configuration
+#
+# Add this to your Goose profile configuration:
+#   ~/.config/goose/profiles.yaml
+#
+# Under the `extensions:` section of your active profile,
+# paste the following block.
+#
+# @feature FEAT-0088
+
+extensions:
+  nestpilot:
+    type: mcp
+    transport: stdio
+    command: npx
+    args: ["nestpilot-mcp-server"]
+    env:
+      NESTPILOT_MODE: local
+      # Optional overrides:
+      # NESTPILOT_DATA_DIR: "~/.nestpilot"
+      # NESTPILOT_CLOUD_API_URL: "https://api.nestpilot.com"
+      # NESTPILOT_API_KEY: "your-api-key"

package/dist/host-configs/openclaw-manifest.json

@@ -0,0 +1,16 @@
+{
+  "name": "nestpilot",
+  "version": "1.0.0",
+  "description": "Local-first retirement planning — your data stays on your machine",
+  "transport": "stdio",
+  "command": "npx",
+  "args": ["nestpilot-mcp-server"],
+  "env": {
+    "NESTPILOT_MODE": "local"
+  },
+  "capabilities": {
+    "tools": true,
+    "resources": true,
+    "apps": true
+  }
+}

package/dist/main.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import "dotenv/config";

package/dist/main.js

@@ -0,0 +1,128 @@
+#!/usr/bin/env node
+/**
+ * NestPilot MCP Server — unified entry point.
+ *
+ * Supports two transports:
+ *   --stdio   → Claude Desktop / any MCP client with stdio transport
+ *   (default) → Streamable HTTP on PORT (default 3001)
+ *
+ * Production features:
+ *   - Bearer token authentication (configurable via MCP_AUTH_* env)
+ *   - Per-user rate limiting
+ *   - OpenTelemetry tracing
+ *   - CORS support
+ *
+ * Run with:
+ *   npx tsx main.ts          # HTTP transport
+ *   npx tsx main.ts --stdio  # stdio transport
+ */
+import { createMcpExpressApp } from "@modelcontextprotocol/sdk/server/express.js";
+import { StdioServerTransport } from "@modelcontextprotocol/sdk/server/stdio.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
+import cors from "cors";
+import "dotenv/config";
+import { loadConfig } from "./src/config.js";
+import { InMemoryRateLimiter } from "./src/rate-limit.js";
+import { authenticateRequest } from "./src/security.js";
+import { initializeTelemetry, shutdownTelemetry } from "./src/telemetry.js";
+import { createServer } from "./server.js";
+const config = loadConfig();
+initializeTelemetry(config);
+const rateLimiter = new InMemoryRateLimiter(config.rateLimitWindowMs, config.rateLimitMaxRequests);
+function writeMcpJsonRpcError(res, statusCode, message) {
+    if (res.headersSent)
+        return;
+    res.status(statusCode).json({
+        jsonrpc: "2.0",
+        error: { code: -32000, message },
+        id: null,
+    });
+}
+/**
+ * Starts an MCP server with Streamable HTTP transport.
+ * Includes auth, rate limiting, and CORS from mcp-edge.
+ */
+async function startStreamableHTTPServer(factory) {
+    const app = createMcpExpressApp({ host: "0.0.0.0" });
+    app.use(cors());
+    app.options("/mcp", cors());
+    app.all("/mcp", async (req, res) => {
+        // ── Authentication ──────────────────────────────────────────────
+        const auth = authenticateRequest(req.headers, config);
+        if (!auth.ok) {
+            writeMcpJsonRpcError(res, auth.statusCode, auth.message);
+            return;
+        }
+        // ── Rate limiting ───────────────────────────────────────────────
+        const rate = rateLimiter.check(auth.userId);
+        res.setHeader("X-RateLimit-Limit", String(config.rateLimitMaxRequests));
+        res.setHeader("X-RateLimit-Remaining", String(rate.remaining));
+        res.setHeader("X-RateLimit-Reset", String(rate.resetAtMs));
+        if (!rate.allowed) {
+            res.setHeader("Retry-After", String(rate.retryAfterSeconds));
+            writeMcpJsonRpcError(res, 429, `Rate limit exceeded. Retry in ${rate.retryAfterSeconds} seconds.`);
+            return;
+        }
+        // ── MCP request handling ────────────────────────────────────────
+        const authCtx = {
+            userId: auth.userId,
+            bearerToken: auth.bearerToken,
+        };
+        const server = factory(authCtx);
+        const transport = new StreamableHTTPServerTransport({
+            sessionIdGenerator: undefined,
+        });
+        res.on("close", () => {
+            transport.close().catch(() => { });
+            server.close().catch(() => { });
+        });
+        try {
+            await server.connect(transport);
+            await transport.handleRequest(req, res, req.body);
+        }
+        catch (error) {
+            console.error("[mcp-app] MCP error:", error);
+            writeMcpJsonRpcError(res, 500, "Internal server error");
+        }
+    });
+    const httpServer = app.listen(config.port, () => {
+        console.log(`NestPilot MCP server listening on http://localhost:${config.port}/mcp`);
+        const authLabel = config.authMode === "jwt-passthrough"
+            ? "jwt-passthrough"
+            : config.requireAuth || config.authTokens.size > 0
+                ? "enabled (token)"
+                : "disabled (open)";
+        console.log(`  Auth: ${authLabel}`);
+        console.log(`  Rate limit: ${config.rateLimitMaxRequests} req / ${config.rateLimitWindowMs / 1000}s`);
+    });
+    const shutdown = () => {
+        console.log("\nShutting down...");
+        void shutdownTelemetry();
+        httpServer.close(() => process.exit(0));
+    };
+    process.on("SIGINT", shutdown);
+    process.on("SIGTERM", shutdown);
+}
+/**
+ * Starts an MCP server with stdio transport (for Claude Desktop).
+ */
+async function startStdioServer(factory) {
+    await factory().connect(new StdioServerTransport());
+}
+async function main() {
+    if (process.argv.includes("--stdio")) {
+        await startStdioServer(createServer);
+    }
+    else {
+        if (config.authMode === "token" &&
+            config.requireAuth &&
+            config.authTokens.size === 0) {
+            throw new Error("Authentication is enabled but MCP_AUTH_TOKENS is empty. Set MCP_AUTH_TOKENS to one or more comma-separated bearer tokens.");
+        }
+        await startStreamableHTTPServer(createServer);
+    }
+}
+main().catch((e) => {
+    console.error(e);
+    process.exit(1);
+});