@lifesi/genesis-mcp 0.0.0-stage → 0.1.1

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/hives-node-transport.d.ts

@@ -0,0 +1,6 @@
+import { type GenesisOptions } from '@lifesi/genesis';
+export declare function closeHivesNodeTransport(): Promise<void>;
+export declare function hivesOperationBudget(id: string): number;
+/** Hives leaf transport. Caller fetch overrides stay authoritative; only native
+ * global fetch gets our Agent. Every operation retains an overall body deadline. */
+export declare function createHivesNodeTransport(opts: GenesisOptions, callerSignal?: AbortSignal): typeof fetch;

package/dist/hives-node-transport.js

@@ -0,0 +1,145 @@
+import { Agent } from 'undici';
+import { Genesis, operationTable } from '@lifesi/genesis';
+// Node's native fetch accepts a compatible per-request dispatcher. Never change
+// the global dispatcher or the portable SDK: other products retain their transport.
+const agentOptions = { headersTimeout: 340_000, bodyTimeout: 340_000, connect: { timeout: 5_000 }, connections: 4, pipelining: 1 };
+let agent;
+const nativeAgent = () => agent ??= new Agent(agentOptions);
+export async function closeHivesNodeTransport() {
+    const current = agent;
+    agent = undefined;
+    await current?.destroy();
+}
+export function hivesOperationBudget(id) {
+    if (id === 'hives_cancel_deployment' || id === 'hives_delete_deployment')
+        return 330_000;
+    if (['hives_create_deployment', 'hives_upload_deployment', 'hives_invoke_deployment', 'hives_invoke_function', 'hives_invoke_function_async'].includes(id))
+        return 40_000;
+    if (['hives_create_function', 'hives_update_function', 'hives_delete_function'].includes(id))
+        return 100_000;
+    return 20_000;
+}
+const escape = (value) => value.replace(/[.*+?^${}()|[\]\\]/g, '\\$&');
+const templatePattern = (value) => new RegExp('^' + value.split(/(\{[^}]+\})/).map((part) => part.startsWith('{') ? '[^/]+' : escape(part)).join('') + '$');
+/** Hives leaf transport. Caller fetch overrides stay authoritative; only native
+ * global fetch gets our Agent. Every operation retains an overall body deadline. */
+export function createHivesNodeTransport(opts, callerSignal) {
+    const supplied = opts.fetch ?? globalThis.fetch;
+    const underlying = supplied.bind(globalThis);
+    const useNative = supplied === globalThis.fetch;
+    const resolver = new Genesis(opts);
+    const routes = Object.entries(operationTable)
+        .filter(([, op]) => op.service === 'hives' && !op.internal)
+        .flatMap(([id, op]) => {
+        const direct = resolver.routing === 'direct';
+        let base;
+        try {
+            base = new URL(direct ? (opts.upstreams?.hives ?? op.upstream.base) : resolver.baseUrl);
+        }
+        catch {
+            throw new Error('Invalid Hives service address.');
+        }
+        const path = direct ? op.upstream.path : op.path;
+        const prefix = base.pathname.replace(/\/+$/, '');
+        const paths = [path];
+        if (!direct && path.startsWith('/v1/hives/'))
+            paths.push(path.replace('/v1/hives/', '/hives/v1/'));
+        return paths.map((p) => ({ id, origin: base.origin, method: direct ? op.upstream.method : op.method, pattern: templatePattern(prefix + p) }));
+    });
+    return (async (input, init = {}) => {
+        let url;
+        try {
+            url = new URL(input instanceof Request ? input.url : String(input));
+        }
+        catch {
+            throw new Error('Invalid Hives request address.');
+        }
+        const method = (init.method ?? (input instanceof Request ? input.method : 'GET')).toUpperCase();
+        const route = routes.find((entry) => entry.origin === url.origin && entry.method === method && entry.pattern.test(url.pathname));
+        if (!route)
+            return underlying(input, init);
+        const controller = new AbortController();
+        let message = 'Hives transport failed. Refresh the resource and retry.';
+        const safeError = () => new Error(message);
+        const signals = [...new Set([callerSignal, init.signal, input instanceof Request ? input.signal : undefined].filter((signal) => !!signal))];
+        const canceled = () => {
+            message = 'Hives request canceled before completion. Refresh the resource before retrying.';
+            controller.abort();
+        };
+        for (const signal of signals)
+            signal.addEventListener('abort', canceled, { once: true });
+        const timer = setTimeout(() => {
+            message = 'Hives request deadline exceeded. Refresh the resource before retrying.';
+            controller.abort();
+        }, hivesOperationBudget(route.id));
+        timer.unref();
+        let abortReject = () => { };
+        let reader;
+        let bodyController;
+        const aborted = () => {
+            abortReject(safeError());
+            bodyController?.error(safeError());
+            void reader?.cancel().catch(() => { });
+            cleanup();
+        };
+        controller.signal.addEventListener('abort', aborted, { once: true });
+        const abortPromise = new Promise((_, reject) => { abortReject = reject; });
+        void abortPromise.catch(() => { });
+        const cleanup = () => {
+            clearTimeout(timer);
+            for (const signal of signals)
+                signal.removeEventListener('abort', canceled);
+            controller.signal.removeEventListener('abort', aborted);
+        };
+        if (signals.some((signal) => signal.aborted))
+            canceled();
+        try {
+            if (controller.signal.aborted)
+                throw safeError();
+            const requestInit = {
+                ...init, signal: controller.signal, cache: 'no-store',
+                redirect: init.redirect === 'manual' ? 'manual' : 'error',
+                ...(useNative ? { dispatcher: nativeAgent() } : {}),
+            };
+            const pending = underlying(input, requestInit);
+            // A caller transport may ignore AbortSignal. Reject on our budget anyway,
+            // and discard any late response rather than presenting an acknowledgement.
+            void pending.then((response) => { if (controller.signal.aborted)
+                void response.body?.cancel().catch(() => { }); }, () => { });
+            const response = await Promise.race([pending, abortPromise]);
+            if (controller.signal.aborted)
+                throw safeError();
+            if (!response.body) {
+                cleanup();
+                return response;
+            }
+            reader = response.body.getReader();
+            const body = new ReadableStream({
+                start(value) { bodyController = value; },
+                async pull(value) {
+                    try {
+                        const next = await reader.read();
+                        if (controller.signal.aborted)
+                            return;
+                        if (next.done) {
+                            cleanup();
+                            value.close();
+                        }
+                        else
+                            value.enqueue(next.value);
+                    }
+                    catch {
+                        cleanup();
+                        value.error(safeError());
+                    }
+                },
+                async cancel() { cleanup(); await reader.cancel().catch(() => { }); },
+            });
+            return new Response(body, { status: response.status, statusText: response.statusText, headers: response.headers });
+        }
+        catch {
+            cleanup();
+            throw safeError();
+        }
+    });
+}

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.1' }, {
+        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, extra) => callTool(opts, req.params.name, (req.params.arguments ?? {}), extra.signal));
+    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,70 @@
+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: string;
+        properties: {
+            project_id: {
+                type: string;
+                description: string;
+            };
+            wasm_base64: {
+                type: string;
+                maxLength: number;
+                description: string;
+            };
+            filename: {
+                type: string;
+                maxLength: number;
+            };
+            git_sha: {
+                type: string;
+                minLength: number;
+                maxLength: number;
+            };
+            git_branch: {
+                type: string;
+                maxLength: number;
+            };
+            git_message: {
+                type: string;
+                maxLength: number;
+            };
+        };
+        required: string[];
+        additionalProperties: boolean;
+    };
+}[];
+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>, signal?: AbortSignal): Promise<Result>;
+export {};

package/dist/tools.js

@@ -0,0 +1,117 @@
+import { createHivesNodeTransport } from './hives-node-transport.js';
+import { Genesis, GenesisError, MAX_WASM_BYTES, hivesResponseBytes, operationTable } from '@lifesi/genesis';
+const uploadSchema = { type: 'object', properties: {
+        project_id: { type: 'string', description: 'Project owned by the caller’s verified org' },
+        wasm_base64: { type: 'string', maxLength: Math.ceil(MAX_WASM_BYTES / 3) * 4, description: 'Explicit standard-base64 content of a real WASM binary (decoded maximum 10 MiB)' },
+        filename: { type: 'string', maxLength: 255 },
+        git_sha: { type: 'string', minLength: 7, maxLength: 40 }, git_branch: { type: 'string', maxLength: 255 }, git_message: { type: 'string', maxLength: 1000 },
+    }, required: ['project_id', 'wasm_base64'], additionalProperties: false };
+const inputSchema = (id, op) => id === 'hives_upload_deployment' ? uploadSchema : op.inputSchema;
+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: inputSchema(id, op), 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: inputSchema(id, op) }));
+}
+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, signal) {
+    const op = operationTable[id];
+    if (!op || op.internal)
+        return text(`Unknown operation "${id}". Use genesis_search_tools to find one.`, true);
+    try {
+        let r;
+        if (op.service === 'hives' && op.rawResponse) {
+            const response = await genesis.raw(id, args, { signal });
+            const bytes = await hivesResponseBytes(response);
+            const payload = { status: response.status, headers: Object.fromEntries(response.headers), body_base64: Buffer.from(bytes).toString('base64') };
+            return { ...text(payload), structuredContent: payload };
+        }
+        else if (id === 'hives_upload_deployment') {
+            const encoded = args.wasm_base64;
+            if (typeof args.project_id !== 'string' || !args.project_id || typeof encoded !== 'string'
+                || encoded.length > Math.ceil(MAX_WASM_BYTES / 3) * 4 || encoded.length % 4 !== 0 || !/^[A-Za-z0-9+/]*={0,2}$/.test(encoded)) {
+                return text({ error: { type: 'invalid_request', message: 'Provide a project ID and standard base64 of a real WASM file, up to 10 MiB decoded.' } }, true);
+            }
+            const bytes = Buffer.from(encoded, 'base64');
+            if (bytes.toString('base64') !== encoded || bytes.length > MAX_WASM_BYTES)
+                return text({ error: { type: 'invalid_request', message: 'WASM base64 is invalid or exceeds 10 MiB.' } }, true);
+            const optional = (key) => {
+                if (args[key] !== undefined && typeof args[key] !== 'string')
+                    throw new Error('WASM upload metadata must contain strings.');
+                return args[key];
+            };
+            r = await genesis.hives.deployments.upload(args.project_id, new Blob([Uint8Array.from(bytes)], { type: 'application/wasm' }), {
+                filename: optional('filename'), git_sha: optional('git_sha'), git_branch: optional('git_branch'), git_message: optional('git_message'),
+            });
+        }
+        else
+            r = op.service === 'hives'
+                ? await genesis.request(id, args, { signal })
+                : 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 = {}, signal) {
+    if (name === 'genesis_search_tools')
+        return text(searchTools(String(args.query ?? ''), args.service, Number(args.limit ?? 10)));
+    if (name !== 'genesis_call' && !specTools.some((t) => t.name === name))
+        return text(`Unknown tool "${name}".`, true);
+    const id = name === 'genesis_call' ? String(args.operation ?? '') : name;
+    const input = name === 'genesis_call' ? args.arguments ?? {} : args;
+    const op = operationTable[id];
+    if (!op || op.internal)
+        return text(`Unknown operation "${id}". Use genesis_search_tools to find one.`, true);
+    const hives = op.service === 'hives';
+    const genesis = new Genesis(hives ? { ...opts, fetch: createHivesNodeTransport(opts, signal) } : opts);
+    return invoke(genesis, id, input, hives ? signal : undefined);
+}

package/package.json

@@ -1,6 +1,21 @@
 {
   "name": "@lifesi/genesis-mcp",
-  "version": "0.0.0-stage",
-  "stub": true,
-  "description": "Temporary package placeholder for staged publishing"
+  "version": "0.1.1",
+  "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",
+    "undici": "6.29.0",
+    "@lifesi/genesis": "0.1.1"
+  },
+  "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.