@lunora/mcp 1.0.0-alpha.25 → 1.0.0-alpha.250

package/dist/packem_shared/READ_ONLY_TOOL_DEFINITIONS-CWb_wFd5.mjs

@@ -1,204 +0,0 @@
-import { LunoraError } from '@lunora/errors';
-
-const RUN_INPUT_SCHEMA = {
-  properties: {
-    args: { description: "Arguments object passed to the function", type: "object" },
-    functionPath: { description: 'Function reference, e.g. "messages:send"', type: "string" },
-    shardKey: { description: "Optional shard key when the function is .shardBy()-partitioned", type: "string" }
-  },
-  required: ["functionPath"],
-  type: "object"
-};
-const NO_INPUT_SCHEMA = { properties: {}, type: "object" };
-const FUNCTION_PATH_INPUT_SCHEMA = {
-  properties: {
-    functionPath: { description: 'Function reference, e.g. "messages:send"', type: "string" }
-  },
-  required: ["functionPath"],
-  type: "object"
-};
-const READ_ONLY_TOOL_DEFINITIONS = [
-  {
-    description: "List the deployment's public functions (queries, mutations, actions) with their kinds.",
-    inputSchema: NO_INPUT_SCHEMA,
-    name: "lunora_list_functions"
-  },
-  {
-    description: "List the deployment's .global() tables and their column shapes.",
-    inputSchema: NO_INPUT_SCHEMA,
-    name: "lunora_list_tables"
-  },
-  {
-    description: "Return a function's argument JSON Schema and kind, so a caller can construct a valid arguments object. Call lunora_list_functions first to discover available function paths.",
-    inputSchema: FUNCTION_PATH_INPUT_SCHEMA,
-    name: "lunora_get_function_schema"
-  },
-  {
-    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,
-    name: "lunora_run_mutation"
-  },
-  {
-    description: "Run an action and return its result. May call external services.",
-    inputSchema: RUN_INPUT_SCHEMA,
-    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 LunoraError("INTERNAL", '"functionPath" is required and must be a non-empty string');
-  }
-  return functionPath;
-};
-const isPlainObject = (value) => typeof value === "object" && value !== null && !Array.isArray(value);
-const describeArgs = (value) => Array.isArray(value) ? "an array" : `a ${typeof value}`;
-const readArgumentsBag = (raw) => {
-  if (raw === void 0 || raw === null) {
-    return {};
-  }
-  if (typeof raw === "string") {
-    let parsed;
-    try {
-      parsed = JSON.parse(raw);
-    } catch {
-      throw new LunoraError("BAD_REQUEST", `"args" must be a JSON object; received a string that is not valid JSON`);
-    }
-    if (!isPlainObject(parsed)) {
-      throw new LunoraError("BAD_REQUEST", `"args" must be a JSON object; the provided string decoded to ${describeArgs(parsed)}`);
-    }
-    return parsed;
-  }
-  if (!isPlainObject(raw)) {
-    throw new LunoraError("BAD_REQUEST", `"args" must be a JSON object, got ${describeArgs(raw)}`);
-  }
-  return raw;
-};
-const readRunArguments = (input) => {
-  const functionPath = readFunctionPath(input);
-  const args = readArgumentsBag(input.args);
-  const shardKey = typeof input.shardKey === "string" && input.shardKey.length > 0 ? input.shardKey : void 0;
-  return { args, functionPath, shardKey };
-};
-const reference = (functionPath) => {
-  return { __lunoraRef: functionPath };
-};
-const bytesToBase64 = (bytes) => {
-  let binary = "";
-  const chunk = 32768;
-  for (let index = 0; index < bytes.length; index += chunk) {
-    binary += String.fromCharCode(...bytes.subarray(index, index + chunk));
-  }
-  return btoa(binary);
-};
-const jsonResultReplacer = (_key, value) => {
-  if (typeof value === "bigint") {
-    return value.toString();
-  }
-  if (value instanceof ArrayBuffer) {
-    return bytesToBase64(new Uint8Array(value));
-  }
-  if (ArrayBuffer.isView(value)) {
-    const view = value;
-    return bytesToBase64(new Uint8Array(view.buffer, view.byteOffset, view.byteLength));
-  }
-  return value;
-};
-const ok = (value) => {
-  const text = value === void 0 ? "null" : JSON.stringify(value, jsonResultReplacer, 2);
-  return { content: [{ text, type: "text" }] };
-};
-const FUNCTIONS_CACHE_TTL_MS = 3e4;
-const functionsCache = /* @__PURE__ */ new WeakMap();
-const listFunctionsCached = (client) => {
-  const now = Date.now();
-  const cached = functionsCache.get(client);
-  if (cached !== void 0 && cached.expiresAt > now) {
-    return cached.promise;
-  }
-  const promise = client.listFunctions().catch((error) => {
-    if (functionsCache.get(client)?.promise === promise) {
-      functionsCache.delete(client);
-    }
-    throw error;
-  });
-  functionsCache.set(client, { expiresAt: now + FUNCTIONS_CACHE_TTL_MS, promise });
-  return promise;
-};
-const assertRunnable = async (client, functionPath, expectedKind) => {
-  const functions = await listFunctionsCached(client);
-  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);
-        const functions = await listFunctionsCached(client);
-        const descriptor = functions.find((function_) => function_.path === functionPath);
-        if (descriptor === void 0) {
-          return { content: [{ text: `function not found: ${functionPath}`, type: "text" }], isError: true };
-        }
-        return ok({ args: descriptor.args ?? [], kind: descriptor.kind, path: descriptor.path });
-      }
-      case "lunora_list_functions": {
-        return ok(await listFunctionsCached(client));
-      }
-      case "lunora_list_tables": {
-        return ok(await client.listGlobalTables());
-      }
-      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: {
-        return { content: [{ text: `unknown tool: ${name}`, type: "text" }], isError: true };
-      }
-    }
-  } catch (error) {
-    const message = error instanceof Error ? error.message : String(error);
-    return { content: [{ text: message, type: "text" }], isError: true };
-  }
-};
-
-export { READ_ONLY_TOOL_DEFINITIONS, WRITE_TOOL_DEFINITIONS, callTool, toolDefinitions };

package/dist/packem_shared/connectStdio-bkJcaXYE.mjs

@@ -1,76 +0,0 @@
-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 { agentToolDefinitions, isAgentToolName, callAgentTool } from './AGENT_RUN_INPUT_SCHEMA-DWobae3P.mjs';
-import { toolDefinitions, callTool } from './READ_ONLY_TOOL_DEFINITIONS-CWb_wFd5.mjs';
-
-const resolveVersion = () => {
-  try {
-    let directory = dirname(fileURLToPath(import.meta.url));
-    for (let depth = 0; depth < 8; depth += 1) {
-      try {
-        const raw = readFileSync(join(directory, "package.json"), "utf8");
-        const pkg = JSON.parse(raw);
-        if (pkg.name === "@lunora/mcp" && typeof pkg.version === "string" && pkg.version.length > 0) {
-          return pkg.version;
-        }
-      } catch {
-      }
-      const parent = dirname(directory);
-      if (parent === directory) {
-        break;
-      }
-      directory = parent;
-    }
-  } catch {
-  }
-  return "0.0.0";
-};
-const SERVER_INFO = { name: "lunora", version: resolveVersion() };
-const resolveClient = (options) => {
-  if (options.client !== void 0) {
-    return options.client;
-  }
-  if (options.url === void 0) {
-    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) {
-    client.setAuthToken(options.token);
-  }
-  return client;
-};
-const createLunoraMcpServer = (options) => {
-  const client = resolveClient(options);
-  const allowWrites = options.allowWrites ?? false;
-  const allowAgents = options.allowAgents ?? false;
-  const agents = options.agents ?? [];
-  const server = new Server(SERVER_INFO, { capabilities: { tools: {} } });
-  server.setRequestHandler(ListToolsRequestSchema, () => {
-    return { tools: [...toolDefinitions(allowWrites), ...agentToolDefinitions(agents, allowAgents)] };
-  });
-  server.setRequestHandler(CallToolRequestSchema, async (request) => {
-    const { arguments: rawArguments, name } = request.params;
-    const input = rawArguments ?? {};
-    const result = isAgentToolName(name, agents) ? await callAgentTool(client, name, input, {
-      allowAgents,
-      exposures: agents,
-      ...options.agentMaxWaitMs === void 0 ? {} : { maxWaitMs: options.agentMaxWaitMs },
-      ...options.agentPollIntervalMs === void 0 ? {} : { pollIntervalMs: options.agentPollIntervalMs }
-    }) : await callTool(client, name, input, allowWrites);
-    return result;
-  });
-  return server;
-};
-const connectStdio = async (options) => {
-  const server = createLunoraMcpServer(options);
-  await server.connect(new StdioServerTransport());
-  return server;
-};
-
-export { connectStdio, createLunoraMcpServer };

package/dist/packem_shared/createMcpFetchHandler-DfzBSLrm.mjs

@@ -1,14 +0,0 @@
-import { WebStandardStreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/webStandardStreamableHttp.js';
-import { createLunoraMcpServer } from './connectStdio-bkJcaXYE.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-b-qp_aEF.mjs

@@ -1,93 +0,0 @@
-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-DfzBSLrm.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 };