@ty_krystal/sei-ai 0.1.4 → 0.1.5

package/dist/server.js

@@ -0,0 +1,237 @@
+import { randomUUID } from 'node:crypto';
+import { createServer } from 'node:http';
+import { McpServer } from '@modelcontextprotocol/sdk/server/mcp.js';
+import { StdioServerTransport } from '@modelcontextprotocol/sdk/server/stdio.js';
+import { StreamableHTTPServerTransport } from '@modelcontextprotocol/sdk/server/streamableHttp.js';
+import { JSONRPCMessageSchema, isInitializeRequest } from '@modelcontextprotocol/sdk/types.js';
+import { SERVER_NAME, SERVER_VERSION } from './constants.js';
+import { createSeiClient } from './sei-client.js';
+import { buildToolDefinitions } from './tools.js';
+import { stringifySafe } from './utils.js';
+export function createMcpServer(options) {
+    const client = options.client ?? createSeiClient(options.config, options.logger);
+    const runtime = {
+        config: options.config,
+        client,
+        logger: options.logger,
+    };
+    const server = new McpServer({
+        name: SERVER_NAME,
+        version: SERVER_VERSION,
+    });
+    for (const tool of buildToolDefinitions(options.config)) {
+        server.registerTool(tool.name, {
+            title: tool.title,
+            description: tool.description,
+            inputSchema: tool.inputSchema,
+            outputSchema: tool.outputSchema,
+            annotations: tool.annotations,
+        }, async (input) => {
+            options.logger.debug('MCP tool call', { toolName: tool.name });
+            const result = await tool.execute(input, runtime);
+            return {
+                content: [
+                    {
+                        type: 'text',
+                        text: String(result.content_text ?? stringifySafe(result)),
+                    },
+                ],
+                structuredContent: result,
+            };
+        });
+    }
+    return server;
+}
+export async function startStdioServer(server) {
+    const transport = new StdioServerTransport();
+    await server.connect(transport);
+}
+export async function startHttpServer(serverFactory, options, logger) {
+    const sessions = new Map();
+    const httpServer = createServer(async (req, res) => {
+        try {
+            if (!req.url) {
+                sendPlainText(res, 400, 'Bad Request');
+                return;
+            }
+            const requestUrl = new URL(req.url, `http://${req.headers.host ?? `${options.host}:${options.port}`}`);
+            if (normalizePath(requestUrl.pathname) !== normalizePath(options.path)) {
+                sendPlainText(res, 404, 'Not Found');
+                return;
+            }
+            if (req.method && !['GET', 'POST', 'DELETE'].includes(req.method.toUpperCase())) {
+                res.statusCode = 405;
+                res.setHeader('Allow', 'GET, POST, DELETE');
+                sendPlainText(res, 405, 'Method Not Allowed');
+                return;
+            }
+            const method = req.method?.toUpperCase();
+            const parsedBody = method === 'POST' ? await readJsonBody(req) : undefined;
+            const transport = await resolveTransport({
+                req,
+                parsedBody,
+                sessions,
+                logger,
+                enableJsonResponse: options.enableJsonResponse,
+                serverFactory,
+            });
+            if (!transport) {
+                sendJsonRpcError(res, 400, -32000, 'Bad Request: Mcp-Session-Id header is required');
+                return;
+            }
+            await transport.handleRequest(req, res, parsedBody);
+            if (method === 'POST' && isInitializePayload(parsedBody) && transport.sessionId === undefined) {
+                await transport.close();
+            }
+        }
+        catch (error) {
+            if (error instanceof SyntaxError) {
+                sendPlainText(res, 400, 'Invalid JSON body');
+                return;
+            }
+            if (error instanceof MissingSessionError) {
+                sendJsonRpcError(res, 404, -32001, error.message);
+                return;
+            }
+            logger.error('HTTP transport request failed', { error: stringifySafe(error) });
+            if (!res.headersSent) {
+                sendPlainText(res, 500, 'Internal Server Error');
+            }
+        }
+    });
+    await new Promise((resolve, reject) => {
+        httpServer.once('error', reject);
+        httpServer.listen(options.port, options.host, () => {
+            const address = httpServer.address();
+            const port = typeof address === 'object' && address ? address.port : options.port;
+            logger.info('SEI MCP HTTP server started', {
+                transport: 'streamable-http',
+                url: `http://${options.host}:${port}${options.path}`,
+            });
+            resolve();
+        });
+    });
+    let closed = false;
+    const shutdown = async () => {
+        if (closed) {
+            return;
+        }
+        closed = true;
+        await Promise.all(Array.from(sessions.values(), (transport) => transport.close()));
+        sessions.clear();
+        await closeHttpServer(httpServer);
+    };
+    process.once('SIGINT', () => {
+        void shutdown().catch((error) => logger.error('HTTP transport shutdown failed', { error: stringifySafe(error) }));
+    });
+    process.once('SIGTERM', () => {
+        void shutdown().catch((error) => logger.error('HTTP transport shutdown failed', { error: stringifySafe(error) }));
+    });
+    const address = httpServer.address();
+    const port = typeof address === 'object' && address ? address.port : options.port;
+    return {
+        url: new URL(`http://${options.host}:${port}${options.path}`),
+        close: shutdown,
+    };
+}
+async function resolveTransport(options) {
+    if (options.req.method?.toUpperCase() === 'POST' && isInitializePayload(options.parsedBody)) {
+        return createSessionTransport(options);
+    }
+    const sessionIdHeader = options.req.headers['mcp-session-id'];
+    const sessionId = typeof sessionIdHeader === 'string' ? sessionIdHeader : undefined;
+    if (options.req.method?.toUpperCase() === 'POST' && !sessionId) {
+        return createSessionTransport(options);
+    }
+    if (!sessionId) {
+        return undefined;
+    }
+    const transport = options.sessions.get(sessionId);
+    if (!transport) {
+        throw new MissingSessionError(sessionId);
+    }
+    return transport;
+}
+async function createSessionTransport(options) {
+    const transport = new StreamableHTTPServerTransport({
+        sessionIdGenerator: () => randomUUID(),
+        enableJsonResponse: options.enableJsonResponse,
+        onsessioninitialized: (sessionId) => {
+            options.sessions.set(sessionId, transport);
+        },
+        onsessionclosed: (sessionId) => {
+            if (sessionId) {
+                options.sessions.delete(sessionId);
+            }
+        },
+    });
+    transport.onerror = (error) => {
+        options.logger.error('HTTP transport request failed', { error: stringifySafe(error) });
+    };
+    transport.onclose = () => {
+        if (transport.sessionId) {
+            options.sessions.delete(transport.sessionId);
+        }
+    };
+    const server = options.serverFactory();
+    await server.connect(transport);
+    return transport;
+}
+function isInitializePayload(payload) {
+    if (payload === undefined) {
+        return false;
+    }
+    const messages = Array.isArray(payload) ? payload : [payload];
+    return messages.some((message) => {
+        const parsed = JSONRPCMessageSchema.safeParse(message);
+        return parsed.success && isInitializeRequest(parsed.data);
+    });
+}
+async function readJsonBody(req) {
+    const chunks = [];
+    for await (const chunk of req) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    if (chunks.length === 0) {
+        return undefined;
+    }
+    const text = Buffer.concat(chunks).toString('utf8').trim();
+    if (!text) {
+        return undefined;
+    }
+    return JSON.parse(text);
+}
+function sendPlainText(res, statusCode, text) {
+    res.statusCode = statusCode;
+    res.setHeader('Content-Type', 'text/plain; charset=utf-8');
+    res.end(text);
+}
+function sendJsonRpcError(res, statusCode, code, message) {
+    res.statusCode = statusCode;
+    res.setHeader('Content-Type', 'application/json');
+    res.end(JSON.stringify({
+        jsonrpc: '2.0',
+        error: { code, message },
+        id: null,
+    }));
+}
+function normalizePath(path) {
+    const raw = path.trim();
+    if (!raw) {
+        return '/mcp';
+    }
+    const normalized = raw.startsWith('/') ? raw : `/${raw}`;
+    return normalized.length > 1 ? normalized.replace(/\/+$/, '') : normalized;
+}
+async function closeHttpServer(server) {
+    await new Promise((resolve) => {
+        server.close(() => resolve());
+    });
+}
+class MissingSessionError extends Error {
+    sessionId;
+    constructor(sessionId) {
+        super('Session not found');
+        this.sessionId = sessionId;
+    }
+}

package/dist/tools.js

@@ -0,0 +1,175 @@
+import {} from 'zod';
+import { MAX_RESPONSE_TEXT } from './constants.js';
+import { SeiMcpError } from './errors.js';
+import { authorizeQuery, authorizeQuerySql, authorizeSave, resolveTarget } from './permissions.js';
+import { stringifySafe, truncateText } from './utils.js';
+import { QueryInputSchema, QueryOutputSchema, QuerySqlInputSchema, QuerySqlOutputSchema, SaveInputSchema, SaveOutputSchema, SchemaInputSchema, SchemaOutputSchema, } from './schema.js';
+export function buildToolDefinitions(config) {
+    const definitions = [];
+    if (config.tools.query) {
+        definitions.push({
+            name: 'sei_query',
+            title: 'SEI Query',
+            description: 'Run an approved SEI low-code query within the local whitelist.',
+            inputSchema: QueryInputSchema,
+            outputSchema: QueryOutputSchema,
+            annotations: toolAnnotations(true, false, true),
+            execute: async (input, runtime) => runQueryTool(input, runtime),
+        });
+    }
+    if (config.tools.save) {
+        definitions.push({
+            name: 'sei_save',
+            title: 'SEI Save',
+            description: 'Run an approved SEI low-code save action within the local whitelist.',
+            inputSchema: SaveInputSchema,
+            outputSchema: SaveOutputSchema,
+            annotations: toolAnnotations(false, true, false),
+            execute: async (input, runtime) => runSaveTool(input, runtime),
+        });
+    }
+    if (config.tools.schema) {
+        definitions.push({
+            name: 'sei_schema',
+            title: 'SEI Schema',
+            description: 'Inspect approved table or module fields without exposing the full database.',
+            inputSchema: SchemaInputSchema,
+            outputSchema: SchemaOutputSchema,
+            annotations: toolAnnotations(true, false, true),
+            execute: async (input, runtime) => runSchemaTool(input, runtime),
+        });
+    }
+    if (config.tools.querySql) {
+        definitions.push({
+            name: 'sei_query_sql',
+            title: 'SEI Query SQL',
+            description: 'Run a restricted SELECT query against approved targets only.',
+            inputSchema: QuerySqlInputSchema,
+            outputSchema: QuerySqlOutputSchema,
+            annotations: toolAnnotations(true, false, true),
+            execute: async (input, runtime) => runQuerySqlTool(input, runtime),
+        });
+    }
+    return definitions;
+}
+export function buildToolCatalog(config) {
+    return buildToolDefinitions(config).map((tool) => ({
+        name: tool.name,
+        title: tool.title,
+        description: tool.description,
+        inputSchema: tool.inputSchema,
+        outputSchema: tool.outputSchema,
+        annotations: tool.annotations,
+    }));
+}
+export async function runQueryTool(input, runtime) {
+    const parsed = QueryInputSchema.parse(input);
+    const payload = authorizeQuery(runtime.config, parsed);
+    const target = getTarget(payload);
+    const response = await runtime.client.query(payload);
+    const result = makeResultEnvelope('sei_query', parsed.option.response_format, 'Query completed.', payload, response, target);
+    return QueryOutputSchema.parse(result);
+}
+export async function runSaveTool(input, runtime) {
+    const parsed = SaveInputSchema.parse(input);
+    const payload = authorizeSave(runtime.config, parsed);
+    const target = getTarget(payload);
+    const response = await runtime.client.save(payload);
+    const result = makeResultEnvelope('sei_save', parsed.response_format, 'Save completed.', payload, response, target);
+    return SaveOutputSchema.parse(result);
+}
+export async function runSchemaTool(input, runtime) {
+    const parsed = SchemaInputSchema.parse(input);
+    const head = parsed.head;
+    const target = resolveTarget(runtime.config, head);
+    const tableName = resolvePhysicalTableName(head, target.target);
+    const response = await runtime.client.describeTable(tableName);
+    const result = makeResultEnvelope('sei_schema', parsed.response_format, 'Schema lookup completed.', {
+        head,
+        tableName,
+        target,
+    }, response, {
+        kind: target.kind,
+        name: target.name,
+    });
+    return SchemaOutputSchema.parse(result);
+}
+export async function runQuerySqlTool(input, runtime) {
+    const parsed = QuerySqlInputSchema.parse(input);
+    const payload = authorizeQuerySql(runtime.config, parsed);
+    const response = await runtime.client.querySql(payload);
+    const result = makeResultEnvelope('sei_query_sql', parsed.response_format, 'SQL query completed.', payload, response);
+    return QuerySqlOutputSchema.parse(result);
+}
+export function resolvePhysicalTableName(head, target) {
+    if (typeof head.table === 'string' && head.table.trim()) {
+        return head.table.trim();
+    }
+    if (typeof head.view === 'string' && head.view.trim()) {
+        return head.view.trim();
+    }
+    if (typeof target.mainTable === 'string' && target.mainTable.trim()) {
+        return target.mainTable.trim();
+    }
+    throw new SeiMcpError('schema 工具需要 mainTable 或显式 table/view', 'INVALID_PARAMS');
+}
+function toolAnnotations(readOnlyHint, destructiveHint, idempotentHint) {
+    return {
+        readOnlyHint,
+        destructiveHint,
+        idempotentHint,
+        openWorldHint: true,
+    };
+}
+function makeResultEnvelope(tool, responseFormat, summary, request, response, target) {
+    const payload = {
+        tool,
+        response_format: responseFormat,
+        summary,
+        request,
+        response,
+        generated_at: new Date().toISOString(),
+        ...(target ? { target } : {}),
+    };
+    return {
+        ...payload,
+        content_text: responseFormat === 'json' ? stringifySafe(payload) : formatMarkdownPayload(payload),
+    };
+}
+function getTarget(payload) {
+    if (!payload || typeof payload !== 'object' || Array.isArray(payload)) {
+        throw new SeiMcpError('目标信息缺失', 'INVALID_PARAMS');
+    }
+    const target = payload._target;
+    if (!target || typeof target !== 'object' || Array.isArray(target)) {
+        throw new SeiMcpError('目标信息缺失', 'INVALID_PARAMS');
+    }
+    const kind = target.kind;
+    const name = target.name;
+    if ((kind === 'module' || kind === 'source' || kind === 'table' || kind === 'view') &&
+        typeof name === 'string' &&
+        name.trim()) {
+        return { kind, name: name.trim() };
+    }
+    throw new SeiMcpError('目标信息缺失', 'INVALID_PARAMS');
+}
+function formatMarkdownPayload(payload) {
+    const lines = [
+        `# ${String(payload.tool).toUpperCase()}`,
+        '',
+        `- Summary: ${String(payload.summary)}`,
+        `- Format: ${String(payload.response_format)}`,
+        `- Generated: ${String(payload.generated_at)}`,
+        '',
+        '## Request',
+        '```json',
+        truncateText(stringifySafe(payload.request), MAX_RESPONSE_TEXT),
+        '```',
+        '',
+        '## Response',
+        '```json',
+        truncateText(stringifySafe(payload.response), MAX_RESPONSE_TEXT),
+        '```',
+    ];
+    return lines.join('\n');
+}

package/dist/types.js

@@ -0,0 +1 @@
+export {};

package/dist/utils.js

@@ -0,0 +1,53 @@
+export function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}
+export function toTrimmedString(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+export function stringifySafe(value) {
+    try {
+        return JSON.stringify(value, null, 2);
+    }
+    catch {
+        return String(value);
+    }
+}
+export function truncateText(value, limit) {
+    const text = String(value ?? '');
+    return text.length > limit ? `${text.slice(0, limit)}...` : text;
+}
+export function uniqueStrings(values) {
+    return [...new Set([...values].map((value) => value.trim()).filter(Boolean))];
+}
+export function normalizeBaseUrl(value) {
+    const text = toTrimmedString(value);
+    if (!text) {
+        throw new Error('base URL 不能为空');
+    }
+    return text.replace(/\/+$/, '');
+}
+export function normalizePath(value) {
+    const text = toTrimmedString(value);
+    if (!text) {
+        return '/';
+    }
+    if (text.startsWith('http://') || text.startsWith('https://')) {
+        try {
+            return new URL(text).pathname || '/';
+        }
+        catch {
+            return '/';
+        }
+    }
+    return text.startsWith('/') ? text : `/${text}`;
+}
+export function makeUrl(baseUrl, path) {
+    if (path.startsWith('http://') || path.startsWith('https://')) {
+        return path;
+    }
+    return `${normalizeBaseUrl(baseUrl)}${normalizePath(path)}`;
+}
+export function toPositiveInteger(value, fallback) {
+    const parsed = Number(value);
+    return Number.isInteger(parsed) && parsed > 0 ? parsed : fallback;
+}

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "@ty_krystal/sei-ai",
-  "version": "0.1.4",
+  "version": "0.1.5",
   "description": "SEI MCP server and developer CLI for query, save, query-sql, and api-docs workflows",
   "keywords": [
     "sei",
@@ -26,6 +26,17 @@
   "bin": {
     "sei-ai": "dist/index.js"
   },
+  "oclif": {
+    "bin": "sei-ai",
+    "dirname": "sei-ai",
+    "commands": {
+      "strategy": "pattern",
+      "target": "./dist/commands",
+      "globPatterns": [
+        "**/*.js"
+      ]
+    }
+  },
   "main": "./dist/index.js",
   "exports": {
     ".": {
@@ -37,7 +48,7 @@
     "start": "node dist/index.js",
     "start:stdio": "node dist/index.js stdio --config ./config.example.json",
     "start:http": "node dist/index.js streamable-http --host 0.0.0.0 --port 3000 --path /mcp --config ./config.example.json",
-    "build": "pnpm vite build",
+    "build": "tsc -p tsconfig.build.json && node ./scripts/copy-build-assets.mjs",
     "test": "node --import tsx --test test/**/*.test.ts",
     "check": "pnpm run typecheck && pnpm run test",
     "typecheck": "tsc -p tsconfig.json --noEmit",
@@ -51,6 +62,7 @@
   },
   "dependencies": {
     "@modelcontextprotocol/sdk": "^1.29.0",
+    "@oclif/core": "^4.11.10",
     "tsx": "^4.22.4",
     "zod": "^3.25.76"
   }