@kynver-app/mcp-estimator 0.2.14 → 0.2.16

package/dist/lib/kynver-client.js

@@ -36,8 +36,13 @@ function getHeaders() {
     const userId = ctx?.userId ?? process.env.KYNVER_USER_ID?.trim();
     const serviceSecret = process.env.KYNVER_SERVICE_SECRET?.trim();
     if (userId) {
+        const runnerToken = process.env.KYNVER_RUNNER_TOKEN?.trim();
+        if (runnerToken) {
+            headers["X-Kynver-Runner-Token"] = runnerToken;
+            return headers;
+        }
         if (!serviceSecret) {
-            throw new Error("X-Kynver-User-Id was set in context but KYNVER_SERVICE_SECRET is missing; refusing to send an unscoped request.");
+            throw new Error("User context requires authentication: set KYNVER_RUNNER_TOKEN (preferred) or KYNVER_SERVICE_SECRET in the MCP server environment.");
         }
         headers["X-Kynver-User-Id"] = userId;
         headers["X-Kynver-Service-Secret"] = serviceSecret;

package/dist/lib/mcp-sse-server.d.ts

@@ -1,4 +1,4 @@
-import { type IncomingMessage } from "node:http";
+import { createServer, type IncomingMessage } from "node:http";
 import type { McpServer } from "@modelcontextprotocol/sdk/server/mcp.js";
 export declare const MAX_SSE_BODY_BYTES: number;
 export type SessionAuth = {
@@ -40,5 +40,5 @@ type RateLimiter = {
 export declare function createFixedWindowRateLimiter(limit: number, windowMs: number): RateLimiter;
 export declare function parseJsonBody(req: IncomingMessage, maxBytes?: number): Promise<unknown>;
 export declare function validateMcporterServerName(name: string): string;
-export declare function startKynverMcpSseServer(options: StartKynverMcpSseServerOptions): void;
+export declare function startKynverMcpSseServer(options: StartKynverMcpSseServerOptions): ReturnType<typeof createServer>;
 export {};

package/dist/lib/mcp-sse-server.js

@@ -1,10 +1,18 @@
 // @generated — synced from packages/kynver-mcp-sse-lib/src/index.ts via scripts/sync-mcp-sse-server.mjs
 // Do not edit by hand; change the canonical file and re-run the sync script.
 import { createServer } from "node:http";
-import { timingSafeEqual } from "node:crypto";
+import { randomUUID, timingSafeEqual } from "node:crypto";
 import { SSEServerTransport } from "@modelcontextprotocol/sdk/server/sse.js";
+import { StreamableHTTPServerTransport } from "@modelcontextprotocol/sdk/server/streamableHttp.js";
 export const MAX_SSE_BODY_BYTES = 1 * 1024 * 1024;
 const FORBIDDEN_QUERY_KEYS = ["apiKey", "secret", "userId"];
+const TRUTHY_ENV = new Set(["1", "true", "yes", "on"]);
+function isServiceSecretImpersonationRejectedInProduction() {
+    const override = process.env.KYNVER_ALLOW_SERVICE_SECRET_IMPERSONATION?.trim().toLowerCase();
+    if (override !== undefined && TRUTHY_ENV.has(override))
+        return false;
+    return process.env.NODE_ENV === "production" || process.env.VERCEL_ENV === "production";
+}
 export function headerValue(req, name) {
     const v = req.headers[name];
     return typeof v === "string" ? v : Array.isArray(v) ? (v[0] ?? null) : null;
@@ -121,6 +129,8 @@ function resolveInternalAuth(req, serviceSecret) {
     const internalSecret = headerValue(req, "x-kynver-service-secret");
     if (!internalUserId || !serviceSecret || !internalSecret)
         return null;
+    if (isServiceSecretImpersonationRejectedInProduction())
+        return null;
     if (!timingSafeEqualString(internalSecret, serviceSecret))
         return null;
     return { userId: internalUserId, auth: { kind: "internal", userId: internalUserId } };
@@ -162,13 +172,15 @@ export function startKynverMcpSseServer(options) {
     const serviceSecret = process.env.KYNVER_SERVICE_SECRET ?? "";
     const host = resolveListenHost();
     const sessions = {};
+    const streamableSessions = {};
     // Resource / abuse limits (env-overridable; in-process per server).
     const maxSessions = intFromEnv("MCP_SSE_MAX_SESSIONS", 200);
     const maxSessionsPerUser = intFromEnv("MCP_SSE_MAX_SESSIONS_PER_USER", 20);
     const idleTimeoutMs = intFromEnv("MCP_SSE_IDLE_TIMEOUT_MS", 5 * 60 * 1000);
     const rateLimitPerMin = intFromEnv("MCP_SSE_RATE_LIMIT_PER_MIN", 120);
     const rateLimiter = createFixedWindowRateLimiter(rateLimitPerMin, 60 * 1000);
-    // Close idle SSE sessions so a flood of half-open connections can't pin memory.
+    // Close idle sessions (both transports) so a flood of half-open connections
+    // can't pin memory.
     const idleSweep = setInterval(() => {
         const now = Date.now();
         for (const [sid, entry] of Object.entries(sessions)) {
@@ -177,8 +189,17 @@ export function startKynverMcpSseServer(options) {
                 void entry.transport.close().catch(() => { });
             }
         }
+        for (const [sid, entry] of Object.entries(streamableSessions)) {
+            if (now - entry.lastActivity > idleTimeoutMs) {
+                delete streamableSessions[sid];
+                void entry.transport.close().catch(() => { });
+            }
+        }
     }, 60 * 1000);
     idleSweep.unref?.();
+    const activeSessionCount = () => Object.keys(sessions).length + Object.keys(streamableSessions).length;
+    const activeSessionCountForUser = (userId) => Object.values(sessions).filter((s) => s.userId === userId).length +
+        Object.values(streamableSessions).filter((s) => s.userId === userId).length;
     const httpServer = createServer(async (req, res) => {
         const url = parseUrl(req, port);
         const path = url.pathname;
@@ -215,14 +236,14 @@ export function startKynverMcpSseServer(options) {
                 });
                 return;
             }
-            // Connection caps — bound total + per-user concurrent SSE sessions so an
-            // authenticated caller can't exhaust memory/sockets by opening many.
-            const allEntries = Object.values(sessions);
-            if (allEntries.length >= maxSessions) {
+            // Connection caps — bound total + per-user concurrent sessions (across
+            // both transports) so an authenticated caller can't exhaust
+            // memory/sockets by opening many.
+            if (activeSessionCount() >= maxSessions) {
                 json(res, 503, { error: "Server at capacity. Try again shortly." });
                 return;
             }
-            if (allEntries.filter((s) => s.userId === userId).length >= maxSessionsPerUser) {
+            if (activeSessionCountForUser(userId) >= maxSessionsPerUser) {
                 json(res, 429, { error: "Too many concurrent connections for this account." });
                 return;
             }
@@ -266,6 +287,146 @@ export function startKynverMcpSseServer(options) {
             }
             return;
         }
+        // Streamable HTTP transport (MCP spec 2025-03-26+) — the transport modern
+        // connector clients (Grok, ChatGPT, Gemini, Claude) expect for remote
+        // servers. One path, three verbs: POST carries JSON-RPC (initialize opens a
+        // session; the response's mcp-session-id header identifies it), GET opens
+        // the standalone server→client SSE stream, DELETE terminates the session.
+        // Auth model mirrors the legacy /sse pair: credentials are verified on the
+        // initialize POST, bound to the session, and every subsequent request must
+        // re-present the same credentials.
+        if (path === "/mcp") {
+            if (req.method !== "POST" && req.method !== "GET" && req.method !== "DELETE") {
+                res.writeHead(405, { "Content-Type": "application/json", Allow: "GET, POST, DELETE" });
+                res.end(JSON.stringify({ error: "Method not allowed" }));
+                return;
+            }
+            if (hasForbiddenQueryAuth(url)) {
+                json(res, 400, {
+                    error: "Internal auth via query params is not allowed. Use X-Kynver-User-Id and X-Kynver-Service-Secret headers.",
+                });
+                return;
+            }
+            const sessionId = headerValue(req, "mcp-session-id");
+            if (sessionId) {
+                const entry = streamableSessions[sessionId];
+                if (!entry) {
+                    // 404 (not 400) per spec so a well-behaved client re-initializes.
+                    json(res, 404, { error: "Unknown or expired MCP session. Re-initialize." });
+                    return;
+                }
+                if (!verifyPostAuth(req, url, entry.auth, serviceSecret)) {
+                    json(res, 401, {
+                        error: "Unauthorized. Re-send the same credentials used to initialize the MCP session.",
+                    });
+                    return;
+                }
+                if (!rateLimiter.check(`msg:${entry.userId}`)) {
+                    json(res, 429, { error: "Too many requests. Slow down and retry." });
+                    return;
+                }
+                entry.lastActivity = Date.now();
+                try {
+                    const body = req.method === "POST" ? await parseJsonBody(req) : undefined;
+                    await options.requestContext.run({ userId: entry.userId }, async () => {
+                        await entry.transport.handleRequest(req, res, body);
+                    });
+                }
+                catch (error) {
+                    if (!res.headersSent) {
+                        json(res, 400, {
+                            error: error instanceof Error ? error.message : "Invalid request body",
+                        });
+                    }
+                }
+                return;
+            }
+            // No session header — only an initialize POST may open a session. (The
+            // transport itself rejects a sessionless non-initialize POST with 400.)
+            if (req.method !== "POST") {
+                json(res, 400, {
+                    error: "Missing mcp-session-id header. Open a session with an initialize POST first.",
+                });
+                return;
+            }
+            // Pre-auth rate limit by client IP (we don't know the user yet).
+            if (!rateLimiter.check(`mcp:${clientIp(req)}`)) {
+                json(res, 429, { error: "Too many requests. Slow down and retry." });
+                return;
+            }
+            let userId = null;
+            let auth = null;
+            const internal = serviceSecret ? resolveInternalAuth(req, serviceSecret) : null;
+            if (internal) {
+                userId = internal.userId;
+                auth = internal.auth;
+            }
+            else {
+                const apiKey = bearerToken(req);
+                if (apiKey) {
+                    userId = await resolveUserFromApiKey(baseUrl, apiKey);
+                    if (userId)
+                        auth = { kind: "apiKey", apiKey };
+                }
+            }
+            if (!userId || !auth) {
+                json(res, 401, {
+                    error: "Unauthorized. Pass API key via Authorization: Bearer <key> or internal X-Kynver-User-Id + X-Kynver-Service-Secret headers.",
+                });
+                return;
+            }
+            if (activeSessionCount() >= maxSessions) {
+                json(res, 503, { error: "Server at capacity. Try again shortly." });
+                return;
+            }
+            if (activeSessionCountForUser(userId) >= maxSessionsPerUser) {
+                json(res, 429, { error: "Too many concurrent connections for this account." });
+                return;
+            }
+            let body;
+            try {
+                body = await parseJsonBody(req);
+            }
+            catch (error) {
+                json(res, 400, {
+                    error: error instanceof Error ? error.message : "Invalid request body",
+                });
+                return;
+            }
+            const boundUserId = userId;
+            const boundAuth = auth;
+            const transport = new StreamableHTTPServerTransport({
+                sessionIdGenerator: () => randomUUID(),
+                onsessioninitialized: (sid) => {
+                    streamableSessions[sid] = {
+                        transport,
+                        userId: boundUserId,
+                        auth: boundAuth,
+                        lastActivity: Date.now(),
+                    };
+                    console.log(`[MCP HTTP] New session (${options.label}, user: ${boundUserId.slice(0, 8)}...)`);
+                },
+            });
+            transport.onclose = () => {
+                if (transport.sessionId)
+                    delete streamableSessions[transport.sessionId];
+            };
+            const server = await options.createMcpServer();
+            await server.connect(transport);
+            try {
+                await options.requestContext.run({ userId: boundUserId }, async () => {
+                    await transport.handleRequest(req, res, body);
+                });
+            }
+            catch (error) {
+                if (!res.headersSent) {
+                    json(res, 400, {
+                        error: error instanceof Error ? error.message : "Invalid request",
+                    });
+                }
+            }
+            return;
+        }
         if (req.method === "GET" && path === "/health") {
             res.writeHead(200, { "Content-Type": "text/plain" });
             res.end("ok");
@@ -276,4 +437,5 @@ export function startKynverMcpSseServer(options) {
     httpServer.listen(port, host, () => {
         console.log(`[MCP SSE] ${options.label} listening on ${host}:${port}`);
     });
+    return httpServer;
 }

package/dist/sse.js

@@ -3,7 +3,7 @@ import { createEstimatorServer } from "./server.js";
 import { requestContext } from "./lib/kynver-client.js";
 startKynverMcpSseServer({
     label: "Estimator server",
-    defaultPort: 3100,
+    defaultPort: 3104,
     createMcpServer: createEstimatorServer,
     requestContext,
 });

package/dist/tools/email-pdf-tools.d.ts

@@ -2,11 +2,13 @@ import { z } from "zod";
 declare const emailPdfSchema: z.ZodObject<{
     estimateId: z.ZodString;
     recipient: z.ZodOptional<z.ZodString>;
+    ccRecipients: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
     subject: z.ZodOptional<z.ZodString>;
     message: z.ZodOptional<z.ZodString>;
     confirmExternalRecipient: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
 }, "strip", z.ZodTypeAny, {
     estimateId: string;
+    ccRecipients: string[];
     confirmExternalRecipient: boolean;
     message?: string | undefined;
     recipient?: string | undefined;
@@ -15,6 +17,7 @@ declare const emailPdfSchema: z.ZodObject<{
     estimateId: string;
     message?: string | undefined;
     recipient?: string | undefined;
+    ccRecipients?: string[] | undefined;
     subject?: string | undefined;
     confirmExternalRecipient?: boolean | undefined;
 }>;
@@ -24,11 +27,13 @@ export declare const emailPdf: {
     inputSchemaZod: z.ZodObject<{
         estimateId: z.ZodString;
         recipient: z.ZodOptional<z.ZodString>;
+        ccRecipients: z.ZodDefault<z.ZodOptional<z.ZodArray<z.ZodString, "many">>>;
         subject: z.ZodOptional<z.ZodString>;
         message: z.ZodOptional<z.ZodString>;
         confirmExternalRecipient: z.ZodDefault<z.ZodOptional<z.ZodBoolean>>;
     }, "strip", z.ZodTypeAny, {
         estimateId: string;
+        ccRecipients: string[];
         confirmExternalRecipient: boolean;
         message?: string | undefined;
         recipient?: string | undefined;
@@ -37,6 +42,7 @@ export declare const emailPdf: {
         estimateId: string;
         message?: string | undefined;
         recipient?: string | undefined;
+        ccRecipients?: string[] | undefined;
         subject?: string | undefined;
         confirmExternalRecipient?: boolean | undefined;
     }>;

package/dist/tools/email-pdf-tools.js

@@ -3,13 +3,14 @@ import * as client from "../lib/kynver-client.js";
 const emailPdfSchema = z.object({
     estimateId: z.string(),
     recipient: z.string().email().optional(),
+    ccRecipients: z.array(z.string().email()).max(10).optional().default([]),
     subject: z.string().min(1).max(200).optional(),
     message: z.string().min(1).max(10_000).optional(),
     confirmExternalRecipient: z.boolean().optional().default(false),
 });
 export const emailPdf = {
     name: "estimator_email_pdf",
-    description: "Email an estimate PDF to a recipient. Fetches and attaches the PDF server-side (no secrets exposed). Defaults to the account owner's email when recipient is omitted. Estimate client emails and linked client records are trusted without extra confirmation; any other address requires confirmExternalRecipient=true after explicit user confirmation. Respects the estimate approval gate before customer send. Returns send status and audit metadata.",
+    description: "Email an estimate PDF to a primary recipient with optional CC recipients in one group email. Fetches and attaches the PDF server-side (no secrets exposed). Defaults to the account owner's email when recipient is omitted. Estimate client emails and linked client records are trusted without extra confirmation; any external To or CC address requires confirmExternalRecipient=true after explicit user confirmation. Respects the estimate approval gate before customer send. Returns send status and audit metadata.",
     inputSchemaZod: emailPdfSchema,
     execute: async (args) => {
         if (!client.hasApiKey())

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@kynver-app/mcp-estimator",
-  "version": "0.2.14",
+  "version": "0.2.16",
   "files": [
     "dist",
     "!dist/**/__tests__/**",
@@ -22,7 +22,7 @@
     "node": ">=18"
   },
   "dependencies": {
-    "@modelcontextprotocol/sdk": "^1.27.0",
+    "@modelcontextprotocol/sdk": "^1.29.0",
     "zod": "^3.23.0"
   },
   "devDependencies": {