@lunora/mcp 0.0.0 → 1.0.0-alpha.2

package/dist/bin.mjs

@@ -0,0 +1,36 @@
+#!/usr/bin/env node
+import { connectStdio } from './packem_shared/connectStdio-C_mvQBs2.mjs';
+
+class BinError extends Error {
+  code;
+  constructor(message, code) {
+    super(message);
+    this.name = "BinError";
+    this.code = code;
+  }
+}
+const runBin = async (environment, dependencies = {}) => {
+  const connect = dependencies.connect ?? connectStdio;
+  const writeError = dependencies.writeError ?? ((message) => {
+    process.stderr.write(message);
+  });
+  const url = environment.LUNORA_URL;
+  if (url === void 0 || url.length === 0) {
+    writeError("lunora-mcp: LUNORA_URL environment variable is required\n");
+    throw new BinError("LUNORA_URL environment variable is required", 1);
+  }
+  try {
+    await connect({ token: environment.LUNORA_ADMIN_TOKEN, url });
+  } catch (error) {
+    const message = error instanceof Error ? error.message : String(error);
+    writeError(`lunora-mcp: failed to start — ${message}
+`);
+    throw new BinError(`failed to start — ${message}`, 1);
+  }
+};
+
+try {
+  await runBin(process.env);
+} catch (error) {
+  process.exit(error instanceof BinError ? error.code : 1);
+}

package/dist/index.d.mts

@@ -0,0 +1,30 @@
+import { LunoraClient } from '@lunora/client';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+interface LunoraMcpServerOptions {
+  client?: LunoraClient;
+  fetch?: typeof fetch;
+  token?: string;
+  url?: string;
+}
+declare const createLunoraMcpServer: (options: LunoraMcpServerOptions) => Server;
+declare const connectStdio: (options: LunoraMcpServerOptions) => Promise<Server>;
+interface ToolInputSchema {
+  properties: Record<string, unknown>;
+  required?: ReadonlyArray<string>;
+  type: "object";
+}
+interface ToolDefinition {
+  description: string;
+  inputSchema: ToolInputSchema;
+  name: string;
+}
+interface ToolResult {
+  content: {
+    text: string;
+    type: "text";
+  }[];
+  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 };

package/dist/index.d.ts

@@ -0,0 +1,30 @@
+import { LunoraClient } from '@lunora/client';
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+interface LunoraMcpServerOptions {
+  client?: LunoraClient;
+  fetch?: typeof fetch;
+  token?: string;
+  url?: string;
+}
+declare const createLunoraMcpServer: (options: LunoraMcpServerOptions) => Server;
+declare const connectStdio: (options: LunoraMcpServerOptions) => Promise<Server>;
+interface ToolInputSchema {
+  properties: Record<string, unknown>;
+  required?: ReadonlyArray<string>;
+  type: "object";
+}
+interface ToolDefinition {
+  description: string;
+  inputSchema: ToolInputSchema;
+  name: string;
+}
+interface ToolResult {
+  content: {
+    text: string;
+    type: "text";
+  }[];
+  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 };

package/dist/index.mjs

@@ -0,0 +1,2 @@
+export { connectStdio, createLunoraMcpServer } from './packem_shared/connectStdio-C_mvQBs2.mjs';
+export { TOOL_DEFINITIONS, callTool } from './packem_shared/TOOL_DEFINITIONS-Dpiu38ji.mjs';

package/dist/packem_shared/TOOL_DEFINITIONS-Dpiu38ji.mjs

@@ -0,0 +1,112 @@
+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 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"
+  },
+  {
+    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 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');
+  }
+  return functionPath;
+};
+const readRunArguments = (input) => {
+  const functionPath = readFunctionPath(input);
+  const rawArguments = input.args;
+  const isPlainObject = typeof rawArguments === "object" && rawArguments !== null && !Array.isArray(rawArguments);
+  const args = isPlainObject ? rawArguments : {};
+  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 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) => {
+  try {
+    switch (name) {
+      case "lunora_get_function_schema": {
+        const functionPath = readFunctionPath(input);
+        const functions = await client.listFunctions();
+        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 client.listFunctions());
+      }
+      case "lunora_list_tables": {
+        return ok(await client.listGlobalTables());
+      }
+      case "lunora_run_action": {
+        const { args, functionPath, shardKey } = readRunArguments(input);
+        return ok(await client.action(reference(functionPath), args, { shardKey }));
+      }
+      case "lunora_run_mutation": {
+        const { args, functionPath, shardKey } = readRunArguments(input);
+        return ok(await client.mutation(reference(functionPath), args, { shardKey }));
+      }
+      case "lunora_run_query": {
+        const { args, functionPath, shardKey } = readRunArguments(input);
+        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 { TOOL_DEFINITIONS, callTool };

package/dist/packem_shared/connectStdio-C_mvQBs2.mjs

@@ -0,0 +1,64 @@
+import { readFileSync } from 'node:fs';
+import { dirname, join } from 'node:path';
+import { fileURLToPath } from 'node:url';
+import { LunoraClient } from '@lunora/client';
+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';
+
+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 Error("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 server = new Server(SERVER_INFO, { capabilities: { tools: {} } });
+  server.setRequestHandler(ListToolsRequestSchema, () => {
+    return { tools: [...TOOL_DEFINITIONS] };
+  });
+  server.setRequestHandler(CallToolRequestSchema, async (request) => {
+    const result = await callTool(client, request.params.name, request.params.arguments ?? {});
+    return result;
+  });
+  return server;
+};
+const connectStdio = async (options) => {
+  const server = createLunoraMcpServer(options);
+  await server.connect(new StdioServerTransport());
+  return server;
+};
+
+export { connectStdio, createLunoraMcpServer };

package/package.json

@@ -1,31 +1,58 @@
 {
   "name": "@lunora/mcp",
-  "version": "0.0.0",
+  "version": "1.0.0-alpha.2",
   "description": "Model Context Protocol server exposing a Lunora deployment to AI agents",
-  "license": "FSL-1.1-Apache-2.0",
+  "keywords": [
+    "ai-agents",
+    "cloudflare",
+    "durable-objects",
+    "llm",
+    "lunora",
+    "mcp",
+    "model-context-protocol",
+    "workers"
+  ],
   "homepage": "https://lunora.sh",
+  "bugs": "https://github.com/anolilab/lunora/issues",
+  "license": "FSL-1.1-Apache-2.0",
+  "author": {
+    "name": "Daniel Bannert",
+    "email": "d.bannert@anolilab.de"
+  },
   "repository": {
     "type": "git",
     "url": "git+https://github.com/anolilab/lunora.git",
     "directory": "packages/mcp"
   },
-  "bugs": {
-    "url": "https://github.com/anolilab/lunora/issues"
+  "bin": {
+    "lunora-mcp": "./dist/bin.mjs"
   },
-  "keywords": [
-    "lunora",
-    "cloudflare",
-    "workers",
-    "durable-objects",
-    "mcp",
-    "model-context-protocol",
-    "ai-agents",
-    "llm"
+  "files": [
+    "dist",
+    "__assets__",
+    "README.md",
+    "LICENSE.md"
   ],
+  "type": "module",
+  "sideEffects": false,
+  "main": "./dist/index.mjs",
+  "module": "./dist/index.mjs",
+  "types": "./dist/index.d.ts",
+  "exports": {
+    ".": {
+      "types": "./dist/index.d.ts",
+      "import": "./dist/index.mjs"
+    },
+    "./package.json": "./package.json"
+  },
   "publishConfig": {
     "access": "public"
   },
-  "files": [
-    "README.md"
-  ]
+  "dependencies": {
+    "@lunora/client": "1.0.0-alpha.2",
+    "@modelcontextprotocol/sdk": "^1.29.0"
+  },
+  "engines": {
+    "node": "^22.15.0 || >=24.11.0"
+  }
 }