@lifesi/genesis-mcp 0.0.0-stage → 0.1.0

package/bin/genesis-mcp.js

@@ -0,0 +1,3 @@
+#!/usr/bin/env node
+import { cli } from '../dist/index.js';
+cli(process.argv.slice(2)).catch((e) => { console.error(e?.message ?? e); process.exit(1); });

package/dist/index.d.ts

@@ -0,0 +1,3 @@
+export { createServer, createHttpServer, serveStdio } from './server.js';
+export { tools, specTools, metaTools, searchTools, callTool } from './tools.js';
+export declare function cli(args: string[]): Promise<void>;

package/dist/index.js

@@ -0,0 +1,11 @@
+export { createServer, createHttpServer, serveStdio } from './server.js';
+export { tools, specTools, metaTools, searchTools, callTool } from './tools.js';
+export async function cli(args) {
+    const { serveStdio, createHttpServer } = await import('./server.js');
+    if (args[0] === 'http') {
+        const port = Number(process.env.PORT ?? args[1] ?? 8787);
+        createHttpServer().listen(port, () => console.error(`genesis-mcp listening on http://0.0.0.0:${port}/mcp`));
+        return;
+    }
+    await serveStdio();
+}

package/dist/server.d.ts

@@ -0,0 +1,45 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import http from 'node:http';
+import type { GenesisOptions } from '@lifesi/genesis';
+export declare function createServer(opts?: GenesisOptions): Server<{
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    method: string;
+    params?: {
+        [x: string]: unknown;
+        _meta?: {
+            [x: string]: unknown;
+            progressToken?: string | number | undefined;
+            "io.modelcontextprotocol/related-task"?: {
+                taskId: string;
+            } | undefined;
+        } | undefined;
+    } | undefined;
+}, {
+    [x: string]: unknown;
+    _meta?: {
+        [x: string]: unknown;
+        progressToken?: string | number | undefined;
+        "io.modelcontextprotocol/related-task"?: {
+            taskId: string;
+        } | undefined;
+    } | undefined;
+}>;
+/** stdio: credential from GENESIS_API_KEY / GENESIS_TOKEN (or `credentials` provider). */
+export declare function serveStdio(opts?: GenesisOptions): Promise<void>;
+/**
+ * Streamable HTTP (stateless) at POST /mcp, for mcp.life.one.
+ * Each request's `Authorization: Bearer <LifeID key | M2M token>` is forwarded as that caller's credential;
+ * the server never holds a credential of its own. Requests without one get 401 + WWW-Authenticate.
+ */
+export declare function createHttpServer(opts?: Omit<GenesisOptions, 'apiKey' | 'token' | 'credentials'>): http.Server<typeof http.IncomingMessage, typeof http.ServerResponse>;

package/dist/server.js

@@ -0,0 +1,63 @@
+import { Server } from '@modelcontextprotocol/sdk/server/index.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { CallToolRequestSchema, ListToolsRequestSchema } from '@modelcontextprotocol/sdk/types.js';
+import http from 'node:http';
+import { callTool, tools } from './tools.js';
+export function createServer(opts = {}) {
+    const server = new Server({ name: 'genesis', version: '0.1.0' }, {
+        capabilities: { tools: {} },
+        instructions: 'Genesis: one API for Foundry (inference), Hives (compute), Relays (DNS) and LifeID keys. Use the named tools for common tasks; use genesis_search_tools + genesis_call for anything else.',
+    });
+    server.setRequestHandler(ListToolsRequestSchema, async () => ({ tools: tools() }));
+    server.setRequestHandler(CallToolRequestSchema, async (req) => callTool(opts, req.params.name, (req.params.arguments ?? {})));
+    return server;
+}
+/** stdio: credential from GENESIS_API_KEY / GENESIS_TOKEN (or `credentials` provider). */
+export async function serveStdio(opts = {}) {
+    await createServer(opts).connect(new StdioServerTransport());
+}
+/**
+ * Streamable HTTP (stateless) at POST /mcp, for mcp.life.one.
+ * Each request's `Authorization: Bearer <LifeID key | M2M token>` is forwarded as that caller's credential;
+ * the server never holds a credential of its own. Requests without one get 401 + WWW-Authenticate.
+ */
+export function createHttpServer(opts = {}) {
+    return http.createServer(async (req, res) => {
+        const url = new URL(req.url ?? '/', 'http://x');
+        if (url.pathname === '/healthz') {
+            res.writeHead(200, { 'content-type': 'application/json' }).end('{"ok":true}');
+            return;
+        }
+        if (url.pathname !== '/mcp') {
+            res.writeHead(404).end();
+            return;
+        }
+        if (req.method !== 'POST') {
+            res.writeHead(405, { allow: 'POST' }).end();
+            return;
+        }
+        const m = /^Bearer\s+(.+)$/i.exec(req.headers.authorization ?? '');
+        if (!m) {
+            res.writeHead(401, { 'content-type': 'application/json', 'www-authenticate': 'Bearer realm="genesis", error="invalid_token"' })
+                .end(JSON.stringify({ jsonrpc: '2.0', error: { code: -32001, message: 'Send Authorization: Bearer <LifeID API key or M2M token>' }, id: null }));
+            return;
+        }
+        let body = '';
+        for await (const chunk of req)
+            body += chunk;
+        let parsed;
+        try {
+            parsed = JSON.parse(body);
+        }
+        catch {
+            res.writeHead(400).end('invalid JSON');
+            return;
+        }
+        const server = createServer({ ...opts, token: m[1] });
+        const transport = new StreamableHTTPServerTransport({ sessionIdGenerator: undefined, enableJsonResponse: true });
+        res.on('close', () => { transport.close(); server.close(); });
+        await server.connect(transport);
+        await transport.handleRequest(req, res, parsed);
+    });
+}

package/dist/tools.d.ts

@@ -0,0 +1,38 @@
+import { type GenesisOptions, type OperationMeta } from '@lifesi/genesis';
+export interface ToolDef {
+    name: string;
+    title?: string;
+    description: string;
+    inputSchema: Record<string, unknown>;
+    annotations?: {
+        readOnlyHint?: boolean;
+        destructiveHint?: boolean;
+        idempotentHint?: boolean;
+        openWorldHint?: boolean;
+    };
+}
+/** Operations callable by agents (everything except gateway-internal ones like credential verify). */
+export declare const callable: [string, OperationMeta][];
+/** Curated tools: one per operation tagged x-mcp in the merged spec. */
+export declare const specTools: ToolDef[];
+export declare const metaTools: ToolDef[];
+export declare const tools: () => ToolDef[];
+export declare function searchTools(query: string, service?: string, limit?: number): {
+    operation: string;
+    service: string;
+    method: string;
+    path: string;
+    summary: string;
+    status: string;
+    inputSchema: Record<string, unknown>;
+}[];
+type Result = {
+    content: {
+        type: 'text';
+        text: string;
+    }[];
+    isError?: boolean;
+    structuredContent?: Record<string, unknown>;
+};
+export declare function callTool(opts: GenesisOptions, name: string, args?: Record<string, unknown>): Promise<Result>;
+export {};

package/dist/tools.js

@@ -0,0 +1,77 @@
+import { Genesis, GenesisError, operationTable } from '@lifesi/genesis';
+const all = Object.entries(operationTable);
+/** Operations callable by agents (everything except gateway-internal ones like credential verify). */
+export const callable = all.filter(([, op]) => !op.internal);
+function describe(id, op) {
+    const status = op.upstream.status === 'live' ? '' : ` [service status: ${op.upstream.status}]`;
+    return `${op.summary} (${op.method} ${op.path})${status}`;
+}
+const annotate = (op) => ({
+    readOnlyHint: op.method === 'GET', destructiveHint: op.method === 'DELETE',
+    idempotentHint: ['GET', 'PUT', 'DELETE'].includes(op.method), openWorldHint: true,
+});
+/** Curated tools: one per operation tagged x-mcp in the merged spec. */
+export const specTools = callable.filter(([, op]) => op.mcp).map(([id, op]) => ({
+    name: id, title: op.summary, description: describe(id, op), inputSchema: op.inputSchema, annotations: annotate(op),
+}));
+export const metaTools = [
+    {
+        name: 'genesis_search_tools',
+        description: `Search all ${callable.length} Genesis API operations (Foundry, Hives, Relays, IAM...) by keyword. Returns operation ids and input schemas to use with genesis_call.`,
+        inputSchema: { type: 'object', properties: {
+                query: { type: 'string', description: 'keywords, e.g. "dns record" or "deploy"' },
+                service: { type: 'string', description: 'optional service filter: foundry | hives | relays | iam' },
+                limit: { type: 'integer', minimum: 1, maximum: 50, default: 10 },
+            }, required: ['query'], additionalProperties: false },
+        annotations: { readOnlyHint: true, openWorldHint: false },
+    },
+    {
+        name: 'genesis_call',
+        description: 'Call any Genesis API operation by id (find ids with genesis_search_tools). arguments = path params + query params + body.',
+        inputSchema: { type: 'object', properties: {
+                operation: { type: 'string', description: 'operation id, e.g. hives_list_secrets' },
+                arguments: { type: 'object', additionalProperties: true, default: {} },
+            }, required: ['operation'], additionalProperties: false },
+        annotations: { openWorldHint: true },
+    },
+];
+export const tools = () => [...metaTools, ...specTools];
+export function searchTools(query, service, limit = 10) {
+    const terms = query.toLowerCase().split(/\W+/).filter(Boolean);
+    return callable
+        .filter(([, op]) => !service || op.service === service)
+        .map(([id, op]) => {
+        const hay = `${id} ${op.summary} ${op.path}`.toLowerCase();
+        const score = terms.reduce((s, t) => s + (hay.includes(t) ? (id.toLowerCase().includes(t) ? 2 : 1) : 0), 0);
+        return { id, op, score };
+    })
+        .filter((x) => x.score > 0)
+        .sort((a, b) => b.score - a.score || a.id.localeCompare(b.id))
+        .slice(0, limit)
+        .map(({ id, op }) => ({ operation: id, service: op.service, method: op.method, path: op.path, summary: op.summary, status: op.upstream.status, inputSchema: op.inputSchema }));
+}
+const text = (v, isError = false) => ({ content: [{ type: 'text', text: typeof v === 'string' ? v : JSON.stringify(v, null, 2) }], ...(isError ? { isError } : {}) });
+async function invoke(genesis, id, args) {
+    const op = operationTable[id];
+    if (!op || op.internal)
+        return text(`Unknown operation "${id}". Use genesis_search_tools to find one.`, true);
+    try {
+        const r = await genesis.request(id, args);
+        return text(r === undefined ? { ok: true } : r);
+    }
+    catch (e) {
+        if (e instanceof GenesisError)
+            return text({ error: { type: e.type, status: e.status, message: e.message, request_id: e.requestId } }, true);
+        return text({ error: { type: 'network', message: e.message, hint: `The ${op.service} service may be unreachable (status: ${op.upstream.status}).` } }, true);
+    }
+}
+export async function callTool(opts, name, args = {}) {
+    if (name === 'genesis_search_tools')
+        return text(searchTools(String(args.query ?? ''), args.service, Number(args.limit ?? 10)));
+    const genesis = new Genesis(opts);
+    if (name === 'genesis_call')
+        return invoke(genesis, String(args.operation ?? ''), args.arguments ?? {});
+    if (!specTools.some((t) => t.name === name))
+        return text(`Unknown tool "${name}".`, true);
+    return invoke(genesis, name, args);
+}

package/package.json

@@ -1,6 +1,20 @@
 {
   "name": "@lifesi/genesis-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.0",
+  "description": "Genesis MCP server (stdio + streamable HTTP): tools generated from the Genesis OpenAPI",
+  "type": "module",
+  "bin": {
+    "genesis-mcp": "bin/genesis-mcp.js"
+  },
+  "files": [
+    "bin",
+    "dist"
+  ],
+  "dependencies": {
+    "@modelcontextprotocol/sdk": "^1.32.1",
+    "@lifesi/genesis": "0.1.0"
+  },
+  "scripts": {
+    "build": "tsc -p tsconfig.json"
+  }
 }

package/README.md

@@ -1,3 +0,0 @@
-# Temporary Holding Version
-
-This version is a temporary placeholder for this package. An operational version to replace this has been submitted for review and is awaiting a staged release.