@lunora/mcp 1.0.0-alpha.2 → 1.0.0-alpha.21

package/dist/bin.mjs

@@ -1,6 +1,8 @@
 #!/usr/bin/env node
-import { connectStdio } from './packem_shared/connectStdio-C_mvQBs2.mjs';
+import { connectStdio } from './packem_shared/connectStdio-mHv2dT3u.mjs';
 
+const ENABLED_ENV_VALUES = /* @__PURE__ */ new Set(["1", "on", "true", "yes"]);
+const isEnvEnabled = (value) => value !== void 0 && ENABLED_ENV_VALUES.has(value.trim().toLowerCase());
 class BinError extends Error {
   code;
   constructor(message, code) {
@@ -20,7 +22,7 @@ const runBin = async (environment, dependencies = {}) => {
     throw new BinError("LUNORA_URL environment variable is required", 1);
   }
   try {
-    await connect({ token: environment.LUNORA_ADMIN_TOKEN, url });
+    await connect({ allowWrites: isEnvEnabled(environment.LUNORA_MCP_ALLOW_WRITES), token: environment.LUNORA_ADMIN_TOKEN, url });
   } catch (error) {
     const message = error instanceof Error ? error.message : String(error);
     writeError(`lunora-mcp: failed to start — ${message}

package/dist/index.d.mts

@@ -1,6 +1,10 @@
-import { LunoraClient } from '@lunora/client';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { LunoraClient } from '@lunora/client';
+import { X402ChargeConfig, X402Price } from '@lunora/x402/charge';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
 interface LunoraMcpServerOptions {
+  allowWrites?: boolean;
   client?: LunoraClient;
   fetch?: typeof fetch;
   token?: string;
@@ -8,6 +12,8 @@ interface LunoraMcpServerOptions {
 }
 declare const createLunoraMcpServer: (options: LunoraMcpServerOptions) => Server;
 declare const connectStdio: (options: LunoraMcpServerOptions) => Promise<Server>;
+type McpFetchHandler = (request: Request) => Promise<Response>;
+declare const createMcpFetchHandler: (options: LunoraMcpServerOptions) => McpFetchHandler;
 interface ToolInputSchema {
   properties: Record<string, unknown>;
   required?: ReadonlyArray<string>;
@@ -25,6 +31,32 @@ interface ToolResult {
   }[];
   isError?: boolean;
 }
-declare const TOOL_DEFINITIONS: ReadonlyArray<ToolDefinition>;
-declare const callTool: (client: LunoraClient, name: string, input: Record<string, unknown>) => Promise<ToolResult>;
-export { type LunoraMcpServerOptions, TOOL_DEFINITIONS, type ToolDefinition, type ToolInputSchema, type ToolResult, callTool, connectStdio, createLunoraMcpServer };
+declare const READ_ONLY_TOOL_DEFINITIONS: ReadonlyArray<ToolDefinition>;
+declare const WRITE_TOOL_DEFINITIONS: ReadonlyArray<ToolDefinition>;
+declare const toolDefinitions: (allowWrites: boolean) => ReadonlyArray<ToolDefinition>;
+declare const callTool: (client: LunoraClient, name: string, input: Record<string, unknown>, allowWrites?: boolean) => Promise<ToolResult>;
+type ToolHandler = (arguments_: Record<string, unknown>) => Promise<ToolResult> | ToolResult;
+interface RegisterToolOptions {
+  annotations?: Tool["annotations"];
+  description: string;
+  inputSchema: ToolInputSchema;
+  name: string;
+}
+interface RegisterPaidToolOptions extends RegisterToolOptions {
+  price: X402Price;
+}
+type PaidMcpChargeConfig = Omit<X402ChargeConfig, "price">;
+interface PaidMcpServerConfig {
+  charge: PaidMcpChargeConfig;
+  serverInfo?: {
+    name: string;
+    version: string;
+  };
+}
+interface PaidMcpServer {
+  readonly fetchHandler: McpFetchHandler;
+  paidTool: (options: RegisterPaidToolOptions, handler: ToolHandler) => void;
+  tool: (options: RegisterToolOptions, handler: ToolHandler) => void;
+}
+declare const createPaidMcpServer: (config: PaidMcpServerConfig) => PaidMcpServer;
+export { type LunoraMcpServerOptions, type McpFetchHandler, type PaidMcpChargeConfig, type PaidMcpServer, type PaidMcpServerConfig, READ_ONLY_TOOL_DEFINITIONS, type RegisterPaidToolOptions, type RegisterToolOptions, type ToolDefinition, type ToolHandler, type ToolInputSchema, type ToolResult, WRITE_TOOL_DEFINITIONS, callTool, connectStdio, createLunoraMcpServer, createMcpFetchHandler, createPaidMcpServer, toolDefinitions };

package/dist/index.d.ts

@@ -1,6 +1,10 @@
-import { LunoraClient } from '@lunora/client';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { LunoraClient } from '@lunora/client';
+import { X402ChargeConfig, X402Price } from '@lunora/x402/charge';
+import { Tool } from '@modelcontextprotocol/sdk/types.js';
 interface LunoraMcpServerOptions {
+  allowWrites?: boolean;
   client?: LunoraClient;
   fetch?: typeof fetch;
   token?: string;
@@ -8,6 +12,8 @@ interface LunoraMcpServerOptions {
 }
 declare const createLunoraMcpServer: (options: LunoraMcpServerOptions) => Server;
 declare const connectStdio: (options: LunoraMcpServerOptions) => Promise<Server>;
+type McpFetchHandler = (request: Request) => Promise<Response>;
+declare const createMcpFetchHandler: (options: LunoraMcpServerOptions) => McpFetchHandler;
 interface ToolInputSchema {
   properties: Record<string, unknown>;
   required?: ReadonlyArray<string>;
@@ -25,6 +31,32 @@ interface ToolResult {
   }[];
   isError?: boolean;
 }
-declare const TOOL_DEFINITIONS: ReadonlyArray<ToolDefinition>;
-declare const callTool: (client: LunoraClient, name: string, input: Record<string, unknown>) => Promise<ToolResult>;
-export { type LunoraMcpServerOptions, TOOL_DEFINITIONS, type ToolDefinition, type ToolInputSchema, type ToolResult, callTool, connectStdio, createLunoraMcpServer };
+declare const READ_ONLY_TOOL_DEFINITIONS: ReadonlyArray<ToolDefinition>;
+declare const WRITE_TOOL_DEFINITIONS: ReadonlyArray<ToolDefinition>;
+declare const toolDefinitions: (allowWrites: boolean) => ReadonlyArray<ToolDefinition>;
+declare const callTool: (client: LunoraClient, name: string, input: Record<string, unknown>, allowWrites?: boolean) => Promise<ToolResult>;
+type ToolHandler = (arguments_: Record<string, unknown>) => Promise<ToolResult> | ToolResult;
+interface RegisterToolOptions {
+  annotations?: Tool["annotations"];
+  description: string;
+  inputSchema: ToolInputSchema;
+  name: string;
+}
+interface RegisterPaidToolOptions extends RegisterToolOptions {
+  price: X402Price;
+}
+type PaidMcpChargeConfig = Omit<X402ChargeConfig, "price">;
+interface PaidMcpServerConfig {
+  charge: PaidMcpChargeConfig;
+  serverInfo?: {
+    name: string;
+    version: string;
+  };
+}
+interface PaidMcpServer {
+  readonly fetchHandler: McpFetchHandler;
+  paidTool: (options: RegisterPaidToolOptions, handler: ToolHandler) => void;
+  tool: (options: RegisterToolOptions, handler: ToolHandler) => void;
+}
+declare const createPaidMcpServer: (config: PaidMcpServerConfig) => PaidMcpServer;
+export { type LunoraMcpServerOptions, type McpFetchHandler, type PaidMcpChargeConfig, type PaidMcpServer, type PaidMcpServerConfig, READ_ONLY_TOOL_DEFINITIONS, type RegisterPaidToolOptions, type RegisterToolOptions, type ToolDefinition, type ToolHandler, type ToolInputSchema, type ToolResult, WRITE_TOOL_DEFINITIONS, callTool, connectStdio, createLunoraMcpServer, createMcpFetchHandler, createPaidMcpServer, toolDefinitions };

package/dist/index.mjs

@@ -1,2 +1,4 @@
-export { connectStdio, createLunoraMcpServer } from './packem_shared/connectStdio-C_mvQBs2.mjs';
-export { TOOL_DEFINITIONS, callTool } from './packem_shared/TOOL_DEFINITIONS-Dpiu38ji.mjs';
+export { createMcpFetchHandler } from './packem_shared/createMcpFetchHandler-CGqlLHxj.mjs';
+export { createPaidMcpServer } from './packem_shared/createPaidMcpServer-S7RdldZo.mjs';
+export { connectStdio, createLunoraMcpServer } from './packem_shared/connectStdio-mHv2dT3u.mjs';
+export { READ_ONLY_TOOL_DEFINITIONS, WRITE_TOOL_DEFINITIONS, callTool, toolDefinitions } from './packem_shared/READ_ONLY_TOOL_DEFINITIONS-B5x61zt4.mjs';

package/dist/packem_shared/{TOOL_DEFINITIONS-Dpiu38ji.mjs → READ_ONLY_TOOL_DEFINITIONS-B5x61zt4.mjs}

@@ -1,3 +1,5 @@
+import { LunoraError } from '@lunora/errors';
+
 const RUN_INPUT_SCHEMA = {
   properties: {
     args: { description: "Arguments object passed to the function", type: "object" },
@@ -15,7 +17,7 @@ const FUNCTION_PATH_INPUT_SCHEMA = {
   required: ["functionPath"],
   type: "object"
 };
-const TOOL_DEFINITIONS = [
+const READ_ONLY_TOOL_DEFINITIONS = [
   {
     description: "List the deployment's public functions (queries, mutations, actions) with their kinds.",
     inputSchema: NO_INPUT_SCHEMA,
@@ -35,7 +37,9 @@ const TOOL_DEFINITIONS = [
     description: "Run a query and return its result. Read-only.",
     inputSchema: RUN_INPUT_SCHEMA,
     name: "lunora_run_query"
-  },
+  }
+];
+const WRITE_TOOL_DEFINITIONS = [
   {
     description: "Run a mutation and return its result. Writes data — use with care.",
     inputSchema: RUN_INPUT_SCHEMA,
@@ -47,10 +51,18 @@ const TOOL_DEFINITIONS = [
     name: "lunora_run_action"
   }
 ];
+const WRITE_TOOL_NAMES = new Set(WRITE_TOOL_DEFINITIONS.map((tool) => tool.name));
+const toolDefinitions = (allowWrites) => (
+  // Fail closed: only the boolean `true` opts in. These are exported helpers, so
+  // an env-plumbed/JS caller could pass a truthy string like `"false"`/`"0"` —
+  // the explicit `=== true` guards that despite the declared `boolean` type.
+  // eslint-disable-next-line @typescript-eslint/no-unnecessary-boolean-literal-compare -- intentional runtime guard at an exported API boundary against non-boolean callers
+  allowWrites === true ? [...READ_ONLY_TOOL_DEFINITIONS, ...WRITE_TOOL_DEFINITIONS] : READ_ONLY_TOOL_DEFINITIONS
+);
 const readFunctionPath = (input) => {
   const { functionPath } = input;
   if (typeof functionPath !== "string" || functionPath.length === 0) {
-    throw new Error('"functionPath" is required and must be a non-empty string');
+    throw new LunoraError("INTERNAL", '"functionPath" is required and must be a non-empty string');
   }
   return functionPath;
 };
@@ -69,8 +81,26 @@ const ok = (value) => {
   const text = value === void 0 ? "null" : JSON.stringify(value, void 0, 2);
   return { content: [{ text, type: "text" }] };
 };
-const callTool = async (client, name, input) => {
+const assertRunnable = async (client, functionPath, expectedKind) => {
+  const functions = await client.listFunctions();
+  const descriptor = functions.find((function_) => function_.path === functionPath);
+  if (descriptor === void 0) {
+    throw new LunoraError("NOT_FOUND", `function not found or not public: ${functionPath}`);
+  }
+  if (descriptor.kind !== expectedKind) {
+    throw new LunoraError("BAD_REQUEST", `function ${functionPath} is a ${descriptor.kind}, not a ${expectedKind}`);
+  }
+};
+const callTool = async (client, name, input, allowWrites = false) => {
   try {
+    if (allowWrites !== true && WRITE_TOOL_NAMES.has(name)) {
+      return {
+        content: [
+          { text: `tool "${name}" is disabled: this MCP server is read-only. Enable writes with the LUNORA_MCP_ALLOW_WRITES env var.`, type: "text" }
+        ],
+        isError: true
+      };
+    }
     switch (name) {
       case "lunora_get_function_schema": {
         const functionPath = readFunctionPath(input);
@@ -89,14 +119,17 @@ const callTool = async (client, name, input) => {
       }
       case "lunora_run_action": {
         const { args, functionPath, shardKey } = readRunArguments(input);
+        await assertRunnable(client, functionPath, "action");
         return ok(await client.action(reference(functionPath), args, { shardKey }));
       }
       case "lunora_run_mutation": {
         const { args, functionPath, shardKey } = readRunArguments(input);
+        await assertRunnable(client, functionPath, "mutation");
         return ok(await client.mutation(reference(functionPath), args, { shardKey }));
       }
       case "lunora_run_query": {
         const { args, functionPath, shardKey } = readRunArguments(input);
+        await assertRunnable(client, functionPath, "query");
         return ok(await client.query(reference(functionPath), args, { shardKey }));
       }
       default: {
@@ -109,4 +142,4 @@ const callTool = async (client, name, input) => {
   }
 };
 
-export { TOOL_DEFINITIONS, callTool };
+export { READ_ONLY_TOOL_DEFINITIONS, WRITE_TOOL_DEFINITIONS, callTool, toolDefinitions };

package/dist/packem_shared/{connectStdio-C_mvQBs2.mjs → connectStdio-mHv2dT3u.mjs}

@@ -2,10 +2,11 @@ import { readFileSync } from 'node:fs';
 import { dirname, join } from 'node:path';
 import { fileURLToPath } from 'node:url';
 import { LunoraClient } from '@lunora/client';
+import { LunoraError } from '@lunora/errors';
 import { Server } from '@modelcontextprotocol/sdk/server/index.js';
 import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
 import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
-import { TOOL_DEFINITIONS, callTool } from './TOOL_DEFINITIONS-Dpiu38ji.mjs';
+import { toolDefinitions, callTool } from './READ_ONLY_TOOL_DEFINITIONS-B5x61zt4.mjs';
 
 const resolveVersion = () => {
   try {
@@ -35,7 +36,7 @@ const resolveClient = (options) => {
     return options.client;
   }
   if (options.url === void 0) {
-    throw new Error("createLunoraMcpServer requires either a `client` or a `url`");
+    throw new LunoraError("INTERNAL", "createLunoraMcpServer requires either a `client` or a `url`");
   }
   const client = new LunoraClient({ fetch: options.fetch, url: options.url });
   if (options.token !== void 0) {
@@ -45,12 +46,13 @@ const resolveClient = (options) => {
 };
 const createLunoraMcpServer = (options) => {
   const client = resolveClient(options);
+  const allowWrites = options.allowWrites ?? false;
   const server = new Server(SERVER_INFO, { capabilities: { tools: {} } });
   server.setRequestHandler(ListToolsRequestSchema, () => {
-    return { tools: [...TOOL_DEFINITIONS] };
+    return { tools: [...toolDefinitions(allowWrites)] };
   });
   server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const result = await callTool(client, request.params.name, request.params.arguments ?? {});
+    const result = await callTool(client, request.params.name, request.params.arguments ?? {}, allowWrites);
     return result;
   });
   return server;

package/dist/packem_shared/createMcpFetchHandler-CGqlLHxj.mjs

@@ -0,0 +1,14 @@
+import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
+import { createLunoraMcpServer } from './connectStdio-mHv2dT3u.mjs';
+
+const serveStateless = async (server, request, options) => {
+  const transport = new WebStandardStreamableHTTPServerTransport({ enableJsonResponse: true, sessionIdGenerator: void 0 });
+  await server.connect(transport);
+  const response = await transport.handleRequest(request, options);
+  transport.close().catch(() => void 0);
+  server.close().catch(() => void 0);
+  return response;
+};
+const createMcpFetchHandler = (options) => (request) => serveStateless(createLunoraMcpServer(options), request);
+
+export { createMcpFetchHandler, serveStateless };

package/dist/packem_shared/createPaidMcpServer-S7RdldZo.mjs

@@ -0,0 +1,93 @@
+import { LunoraError } from '@lunora/errors';
+import { createChargeMiddleware } from '@lunora/x402/charge';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { ListToolsRequestSchema, CallToolRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import { serveStateless } from './createMcpFetchHandler-CGqlLHxj.mjs';
+
+const DEFAULT_SERVER_INFO = { name: "lunora-paid-mcp", version: "0.0.0" };
+const CALL_TOOL_METHOD = "tools/call";
+const callToolName = (message) => {
+  if (typeof message !== "object" || message === null) {
+    return void 0;
+  }
+  const { method, params } = message;
+  if (method !== CALL_TOOL_METHOD || typeof params !== "object" || params === null) {
+    return void 0;
+  }
+  const { name } = params;
+  return typeof name === "string" ? name : void 0;
+};
+const refuseBatch = () => Response.json({ error: "A JSON-RPC batch may not reference a paid MCP tool; send paid tools/call requests individually." }, { status: 400 });
+const createPaidMcpServer = (config) => {
+  const tools = /* @__PURE__ */ new Map();
+  const prices = /* @__PURE__ */ new Map();
+  const middlewareByTool = /* @__PURE__ */ new Map();
+  const serverInfo = config.serverInfo ?? DEFAULT_SERVER_INFO;
+  const register = (options, handler, price) => {
+    if (tools.has(options.name)) {
+      throw new LunoraError("BAD_REQUEST", `MCP tool "${options.name}" is already registered.`);
+    }
+    const definition = { description: options.description, inputSchema: options.inputSchema, name: options.name };
+    if (options.annotations !== void 0) {
+      definition.annotations = options.annotations;
+    }
+    tools.set(options.name, { definition, handler });
+    if (price !== void 0) {
+      prices.set(options.name, price);
+    }
+  };
+  const buildServer = () => {
+    const server = new Server(serverInfo, { capabilities: { tools: {} } });
+    server.setRequestHandler(ListToolsRequestSchema, () => {
+      return { tools: [...tools.values()].map((entry) => entry.definition) };
+    });
+    server.setRequestHandler(CallToolRequestSchema, async (request) => {
+      const entry = tools.get(request.params.name);
+      if (entry === void 0) {
+        return { content: [{ text: `unknown tool: ${request.params.name}`, type: "text" }], isError: true };
+      }
+      const result = await entry.handler(request.params.arguments ?? {});
+      return result;
+    });
+    return server;
+  };
+  const gateFor = (name, price) => {
+    let pending = middlewareByTool.get(name);
+    if (pending === void 0) {
+      pending = createChargeMiddleware({ ...config.charge, price }, { resource: name }).catch((error) => {
+        middlewareByTool.delete(name);
+        throw error;
+      });
+      middlewareByTool.set(name, pending);
+    }
+    return pending;
+  };
+  const fetchHandler = async (request) => {
+    let parsedBody;
+    try {
+      parsedBody = await request.clone().json();
+    } catch {
+      parsedBody = void 0;
+    }
+    const dispatch = () => serveStateless(buildServer(), request, parsedBody === void 0 ? void 0 : { parsedBody });
+    if (Array.isArray(parsedBody)) {
+      return parsedBody.some((message) => prices.has(callToolName(message) ?? "")) ? refuseBatch() : dispatch();
+    }
+    const name = callToolName(parsedBody);
+    const price = name === void 0 ? void 0 : prices.get(name);
+    if (name === void 0 || price === void 0) {
+      return dispatch();
+    }
+    const middleware = await gateFor(name, price);
+    return middleware.handle(request, dispatch);
+  };
+  const paidTool = (options, handler) => {
+    register(options, handler, options.price);
+  };
+  const tool = (options, handler) => {
+    register(options, handler);
+  };
+  return { fetchHandler, paidTool, tool };
+};
+
+export { createPaidMcpServer };

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@lunora/mcp",
-  "version": "1.0.0-alpha.2",
+  "version": "1.0.0-alpha.21",
   "description": "Model Context Protocol server exposing a Lunora deployment to AI agents",
   "keywords": [
     "ai-agents",
@@ -28,7 +28,7 @@
     "lunora-mcp": "./dist/bin.mjs"
   },
   "files": [
-    "dist",
+    "./dist",
     "__assets__",
     "README.md",
     "LICENSE.md"
@@ -49,7 +49,9 @@
     "access": "public"
   },
   "dependencies": {
-    "@lunora/client": "1.0.0-alpha.2",
+    "@lunora/client": "1.0.0-alpha.20",
+    "@lunora/errors": "1.0.0-alpha.3",
+    "@lunora/x402": "1.0.0-alpha.1",
     "@modelcontextprotocol/sdk": "^1.29.0"
   },
   "engines": {