@ty_krystal/sei-ai 0.1.8 → 0.1.13

package/dist/core/command-base/sei-command.js

@@ -0,0 +1,85 @@
+import { Command, Flags } from '@oclif/core';
+import { loadConfig } from '../config.js';
+import { DEFAULT_LOG_LEVEL } from '../constants.js';
+import { formatCliError, toErrorLogMeta } from '../errors.js';
+import { loadWorkingDirEnv } from '../env.js';
+import { createLogger } from '../logger.js';
+import { createCliSeiClient, createSeiAuthSettings } from '../sei-client.js';
+import { loadPayload } from './payload.js';
+import { printJson, writeText } from './output.js';
+export class SeiCommand extends Command {
+    static baseFlags = {
+        config: Flags.string({ description: '配置文件路径' }),
+        'base-url': Flags.string({ description: 'SEI 基础地址' }),
+        'ai-key': Flags.string({ description: 'AI 登录密钥' }),
+        account: Flags.string({ description: 'AI 登录账号' }),
+        'account-project': Flags.string({ description: 'AI 登录项目' }),
+        'account-checkcode': Flags.string({ description: 'AI 登录验证码' }),
+        token: Flags.string({ description: '固定 token' }),
+        timeout: Flags.integer({ description: '请求超时（毫秒）' }),
+    };
+    logger;
+    configData;
+    async init() {
+        await loadWorkingDirEnv();
+        this.logger = createLogger(process.env.SEI_MCP_LOG_LEVEL ?? DEFAULT_LOG_LEVEL);
+        this.configData = await loadConfig(this.argv, process.env);
+        await super.init();
+    }
+    async resolveConfig() {
+        return this.configData;
+    }
+    async createCliClient(options = {}) {
+        const config = await this.resolveConfig();
+        const settings = createSeiAuthSettings(config, {
+            baseUrl: options.baseUrl,
+            token: options.token,
+            aiKey: options.aiKey,
+            account: options.account,
+            accountProject: options.accountProject,
+            accountCheckcode: options.accountCheckcode,
+            timeoutMs: options.timeoutMs,
+        });
+        return createCliSeiClient(settings, this.logger, globalThis.fetch);
+    }
+    async loadPayload(input) {
+        return loadPayload(input);
+    }
+    printJson(value) {
+        printJson(value);
+    }
+    writeText(text) {
+        writeText(text);
+    }
+    createAuthOptions(flags) {
+        return {
+            baseUrl: stringFlag(flags, 'base-url'),
+            token: stringFlag(flags, 'token'),
+            aiKey: stringFlag(flags, 'ai-key'),
+            account: stringFlag(flags, 'account'),
+            accountProject: stringFlag(flags, 'account-project'),
+            accountCheckcode: stringFlag(flags, 'account-checkcode'),
+            timeoutMs: numberFlag(flags, 'timeout'),
+        };
+    }
+    async createClientFromFlags(flags) {
+        return this.createCliClient(this.createAuthOptions(flags));
+    }
+    async catch(error) {
+        this.logger?.error('CLI command failed', {
+            argv: this.argv,
+            error: toErrorLogMeta(error),
+        });
+        process.stderr.write(`${formatCliError(error)}\n`);
+        process.exitCode = 1;
+        return undefined;
+    }
+}
+function stringFlag(flags, name) {
+    const value = flags[name];
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function numberFlag(flags, name) {
+    const value = flags[name];
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}

package/dist/core/config.d.ts

@@ -0,0 +1,3 @@
+import type { SeiMcpConfig } from './types.js';
+export declare function loadConfig(argv?: string[], env?: NodeJS.ProcessEnv): Promise<SeiMcpConfig>;
+export declare function normalizeConfig(input?: unknown, env?: NodeJS.ProcessEnv): SeiMcpConfig;

package/dist/core/config.js

@@ -0,0 +1,80 @@
+import { readFile } from 'node:fs/promises';
+import { DEFAULT_BASE_URL } from './constants.js';
+import { SeiMcpError } from './errors.js';
+import { isObject, toTrimmedString } from './utils.js';
+export async function loadConfig(argv = process.argv.slice(2), env = process.env) {
+    const configPath = resolveArg(argv, '--config') ?? (toTrimmedString(env.SEI_AI_MCP_CONFIG) || null);
+    const fileConfig = configPath ? await readConfigFile(configPath) : {};
+    return normalizeConfig(fileConfig, env);
+}
+export function normalizeConfig(input = {}, env = process.env) {
+    const config = isObject(input) ? input : {};
+    const auth = isObject(config.auth) ? config.auth : {};
+    const tools = isObject(config.tools) ? config.tools : {};
+    const targets = isObject(config.targets) ? config.targets : {};
+    return {
+        baseUrl: normalizeBaseUrl(config.baseUrl, env.SEI_BASE_URL),
+        auth: {
+            mode: normalizeMode(auth.mode, env.SEI_AI_MCP_AUTH_MODE),
+            token: stringOrEnv(auth.token, env.SEI_TOKEN),
+            tokenEnv: stringOrEnv(auth.tokenEnv, env.SEI_TOKEN ? 'SEI_TOKEN' : 'SEI_TOKEN'),
+            aiKey: stringOrEnv(auth.aiKey, env.SEI_AI_LOGIN_KEY),
+            aiKeyEnv: stringOrEnv(auth.aiKeyEnv, env.SEI_AI_LOGIN_KEY ? 'SEI_AI_LOGIN_KEY' : 'SEI_AI_LOGIN_KEY'),
+            account: stringOrEnv(auth.account, env.SEI_AI_LOGIN_ACCOUNT) || 'admin',
+            accountEnv: stringOrEnv(auth.accountEnv, env.SEI_AI_LOGIN_ACCOUNT ? 'SEI_AI_LOGIN_ACCOUNT' : 'SEI_AI_LOGIN_ACCOUNT'),
+        },
+        tools: {
+            query: tools.query !== false,
+            save: tools.save !== false,
+            schema: tools.schema !== false,
+            querySql: tools.querySql === true,
+        },
+        targets: {
+            modules: toTargetMap(targets.modules),
+            tables: toTargetMap(targets.tables),
+            sources: toTargetMap(targets.sources),
+            views: toTargetMap(targets.views),
+        },
+    };
+}
+async function readConfigFile(path) {
+    try {
+        const text = await readFile(path, 'utf8');
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new SeiMcpError(`无法读取配置文件: ${path}`, 'INVALID_REQUEST', {
+            path,
+            cause: error instanceof Error ? error.message : String(error),
+        });
+    }
+}
+function resolveArg(argv, name) {
+    const index = argv.indexOf(name);
+    if (index === -1) {
+        return null;
+    }
+    const next = argv[index + 1];
+    return next && !next.startsWith('-') ? next : null;
+}
+function normalizeBaseUrl(configValue, envValue) {
+    const raw = stringOrEnv(configValue, envValue);
+    return raw || DEFAULT_BASE_URL;
+}
+function normalizeMode(configValue, envValue) {
+    const raw = stringOrEnv(configValue, envValue).toLowerCase();
+    return raw === 'token' ? 'token' : 'ai-login';
+}
+function stringOrEnv(value, envValue) {
+    const candidate = toTrimmedString(value);
+    if (candidate) {
+        return candidate;
+    }
+    return toTrimmedString(envValue);
+}
+function toTargetMap(value) {
+    if (!isObject(value)) {
+        return {};
+    }
+    return Object.fromEntries(Object.entries(value).filter(([, item]) => isObject(item)));
+}

package/dist/core/constants.d.ts

@@ -0,0 +1,35 @@
+export declare const PACKAGE_NAME = "sei-ai";
+export declare const BIN_NAME = "sei-ai";
+export declare const SERVER_NAME = "sei-ai-mcp-server";
+export declare const SERVER_VERSION = "0.2.0";
+export declare const DEFAULT_BASE_URL = "http://127.0.0.1:8081";
+export declare const DEFAULT_AI_KEY = "dev-ai-secret";
+export declare const DEFAULT_TIMEOUT_MS = 30000;
+export declare const DEFAULT_LOG_LEVEL = "info";
+export declare const DEFAULT_QUERY_LIMIT = 20;
+export declare const DEFAULT_QUERY_SQL_PAGE = 1;
+export declare const DEFAULT_QUERY_SQL_SIZE = 20;
+export declare const MAX_RESPONSE_TEXT = 20000;
+export declare const MAX_LOG_TEXT = 2000;
+export declare const LOGIN_PATH = "/api/sei/public/login";
+export declare const ACCOUNT_CHECK_CODE_PATH = "/api/sei/public/checkCode";
+export declare const QUERY_PATH = "/api/sei/data/public/query";
+export declare const SAVE_PATH = "/api/sei/data/public/save";
+export declare const QUERY_SQL_PATH = "/api/sei/data/querySQL";
+export declare const DDL_EXECUTE_PATH = "/api/sei/mcp/ddl/execute";
+export declare const OPENAPI_DOCS_PATH = "/v3/api-docs";
+export declare const DICT_MODULE = "sys_dic";
+export declare const DICT_DEFAULT_SYSID = "sys";
+export declare const DICT_FIELDS: readonly ["_UUID", "_PID", "_SYSID", "_TYPE", "_CTYPE", "_CODE", "_NAME", "_ENAME", "_DICT", "_SORT", "_BODY", "_MEMO"];
+export declare const BASE_SEED_DEFAULT_SYSID = "sys";
+export declare const BASE_SEED_DEFAULT_ADMIN_UID = "admin";
+export declare const BASE_SEED_DEFAULT_ADMIN_ROLE = "admin";
+export declare const BASE_SEED_DEFAULT_ADMIN_PASSWORD = "123456";
+export declare const ACCOUNT_LOGIN_DEFAULT_PROJECT = "sys";
+export declare const ACCOUNT_LOGIN_DEFAULT_CHECKCODE = "abcd";
+export declare const ACCOUNT_LOGIN_DEFAULT_TYPE = "login";
+export declare const ACCOUNT_LOGIN_DEFAULT_OS = 0;
+export declare const TOKEN_CACHE_DIR_NAME = "sei-ai";
+export declare const TOKEN_CACHE_FILE_PREFIX = "token-";
+export declare const TOKEN_CACHE_FILE_SUFFIX = ".json";
+export declare const TOKEN_CACHE_VERSION = 1;

package/dist/core/constants.js

@@ -0,0 +1,48 @@
+export const PACKAGE_NAME = 'sei-ai';
+export const BIN_NAME = 'sei-ai';
+export const SERVER_NAME = 'sei-ai-mcp-server';
+export const SERVER_VERSION = '0.2.0';
+export const DEFAULT_BASE_URL = 'http://127.0.0.1:8081';
+export const DEFAULT_AI_KEY = 'dev-ai-secret';
+export const DEFAULT_TIMEOUT_MS = 30_000;
+export const DEFAULT_LOG_LEVEL = 'info';
+export const DEFAULT_QUERY_LIMIT = 20;
+export const DEFAULT_QUERY_SQL_PAGE = 1;
+export const DEFAULT_QUERY_SQL_SIZE = 20;
+export const MAX_RESPONSE_TEXT = 20_000;
+export const MAX_LOG_TEXT = 2_000;
+export const LOGIN_PATH = '/api/sei/public/login';
+export const ACCOUNT_CHECK_CODE_PATH = '/api/sei/public/checkCode';
+export const QUERY_PATH = '/api/sei/data/public/query';
+export const SAVE_PATH = '/api/sei/data/public/save';
+export const QUERY_SQL_PATH = '/api/sei/data/querySQL';
+export const DDL_EXECUTE_PATH = '/api/sei/mcp/ddl/execute';
+export const OPENAPI_DOCS_PATH = '/v3/api-docs';
+export const DICT_MODULE = 'sys_dic';
+export const DICT_DEFAULT_SYSID = 'sys';
+export const DICT_FIELDS = [
+    '_UUID',
+    '_PID',
+    '_SYSID',
+    '_TYPE',
+    '_CTYPE',
+    '_CODE',
+    '_NAME',
+    '_ENAME',
+    '_DICT',
+    '_SORT',
+    '_BODY',
+    '_MEMO',
+];
+export const BASE_SEED_DEFAULT_SYSID = 'sys';
+export const BASE_SEED_DEFAULT_ADMIN_UID = 'admin';
+export const BASE_SEED_DEFAULT_ADMIN_ROLE = 'admin';
+export const BASE_SEED_DEFAULT_ADMIN_PASSWORD = '123456';
+export const ACCOUNT_LOGIN_DEFAULT_PROJECT = 'sys';
+export const ACCOUNT_LOGIN_DEFAULT_CHECKCODE = 'abcd';
+export const ACCOUNT_LOGIN_DEFAULT_TYPE = 'login';
+export const ACCOUNT_LOGIN_DEFAULT_OS = 0;
+export const TOKEN_CACHE_DIR_NAME = 'sei-ai';
+export const TOKEN_CACHE_FILE_PREFIX = 'token-';
+export const TOKEN_CACHE_FILE_SUFFIX = '.json';
+export const TOKEN_CACHE_VERSION = 1;

package/dist/core/env.d.ts

@@ -0,0 +1 @@
+export declare function loadWorkingDirEnv(cwd?: string, env?: NodeJS.ProcessEnv): Promise<void>;

package/dist/core/env.js

@@ -0,0 +1,55 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+const DEFAULT_ENV_FILES = ['.env.local', '.env'];
+export async function loadWorkingDirEnv(cwd = process.cwd(), env = process.env) {
+    for (const fileName of DEFAULT_ENV_FILES) {
+        await loadEnvFile(resolve(cwd, fileName), env);
+    }
+}
+async function loadEnvFile(path, env) {
+    try {
+        const text = await readFile(path, 'utf8');
+        const parsed = parseEnvText(text);
+        for (const [key, value] of Object.entries(parsed)) {
+            if (env[key] === undefined) {
+                env[key] = value;
+            }
+        }
+    }
+    catch (error) {
+        if (isMissingFile(error)) {
+            return;
+        }
+        throw error;
+    }
+}
+function isMissingFile(error) {
+    if (!error || typeof error !== 'object') {
+        return false;
+    }
+    const withCode = error;
+    return withCode.code === 'ENOENT';
+}
+function parseEnvText(text) {
+    const result = {};
+    for (const rawLine of text.split(/\r?\n/)) {
+        const line = rawLine.trim();
+        if (!line || line.startsWith('#')) {
+            continue;
+        }
+        const equalsIndex = line.indexOf('=');
+        if (equalsIndex === -1) {
+            continue;
+        }
+        const key = line.slice(0, equalsIndex).trim();
+        if (!key) {
+            continue;
+        }
+        let value = line.slice(equalsIndex + 1).trim();
+        if ((value.startsWith('"') && value.endsWith('"')) || (value.startsWith("'") && value.endsWith("'"))) {
+            value = value.slice(1, -1);
+        }
+        result[key] = value;
+    }
+    return result;
+}

package/dist/core/errors.d.ts

@@ -0,0 +1,10 @@
+import type { JsonValue } from './utils.js';
+export declare class SeiMcpError extends Error {
+    readonly code: string;
+    readonly details?: Record<string, unknown>;
+    constructor(message: string, code?: string, details?: Record<string, unknown>);
+}
+export declare function isSeiMcpError(error: unknown): error is SeiMcpError;
+export declare function normalizeErrorMessage(error: unknown): string;
+export declare function formatCliError(error: unknown): string;
+export declare function toErrorLogMeta(error: unknown): JsonValue;

package/dist/core/errors.js

@@ -0,0 +1,55 @@
+export class SeiMcpError extends Error {
+    code;
+    details;
+    constructor(message, code = 'INTERNAL_ERROR', details) {
+        super(message);
+        this.name = 'SeiMcpError';
+        this.code = code;
+        this.details = details;
+    }
+}
+export function isSeiMcpError(error) {
+    return error instanceof SeiMcpError;
+}
+export function normalizeErrorMessage(error) {
+    return error instanceof Error ? error.message : 'Unknown error';
+}
+export function formatCliError(error) {
+    if (error instanceof SeiMcpError) {
+        return `[${error.code}] ${error.message}`;
+    }
+    return `[INTERNAL_ERROR] ${normalizeErrorMessage(error)}`;
+}
+export function toErrorLogMeta(error) {
+    if (error instanceof SeiMcpError) {
+        return {
+            code: error.code,
+            message: error.message,
+            details: toJsonValue(error.details),
+        };
+    }
+    if (error instanceof Error) {
+        return {
+            message: error.message,
+            stack: error.stack ?? '',
+        };
+    }
+    return {
+        message: normalizeErrorMessage(error),
+    };
+}
+function toJsonValue(value) {
+    if (value === null) {
+        return null;
+    }
+    if (typeof value === 'string' || typeof value === 'number' || typeof value === 'boolean') {
+        return value;
+    }
+    if (Array.isArray(value)) {
+        return value.map((item) => toJsonValue(item));
+    }
+    if (value && typeof value === 'object') {
+        return Object.fromEntries(Object.entries(value).map(([key, item]) => [key, toJsonValue(item)]));
+    }
+    return String(value);
+}

package/dist/core/index.d.ts

@@ -0,0 +1,14 @@
+export * from './cli-actions.js';
+export * from './cli-helpers.js';
+export * from './config.js';
+export * from './constants.js';
+export * from './env.js';
+export * from './errors.js';
+export * from './logger.js';
+export * from './openapi.js';
+export * from './sei-client.js';
+export * from './types.js';
+export * from './utils.js';
+export * from './command-base/output.js';
+export * from './command-base/payload.js';
+export * from './command-base/sei-command.js';

package/dist/core/index.js

@@ -0,0 +1,14 @@
+export * from './cli-actions.js';
+export * from './cli-helpers.js';
+export * from './config.js';
+export * from './constants.js';
+export * from './env.js';
+export * from './errors.js';
+export * from './logger.js';
+export * from './openapi.js';
+export * from './sei-client.js';
+export * from './types.js';
+export * from './utils.js';
+export * from './command-base/output.js';
+export * from './command-base/payload.js';
+export * from './command-base/sei-command.js';

package/dist/core/logger.d.ts

@@ -0,0 +1,2 @@
+import type { Logger } from './types.js';
+export declare function createLogger(level?: string): Logger;

package/dist/core/logger.js

@@ -0,0 +1,71 @@
+import { DEFAULT_LOG_LEVEL, MAX_LOG_TEXT } from './constants.js';
+import { truncateText } from './utils.js';
+const LEVEL_PRIORITY = {
+    error: 0,
+    warn: 1,
+    info: 2,
+    debug: 3,
+};
+const SENSITIVE_KEYS = new Set([
+    'authorization',
+    'cookie',
+    'password',
+    'token',
+    'aiKey',
+    'ai_key',
+    'secret',
+    'body',
+]);
+export function createLogger(level = DEFAULT_LOG_LEVEL) {
+    const threshold = LEVEL_PRIORITY[normalizeLevel(level)] ?? LEVEL_PRIORITY.info;
+    function write(targetLevel, message, meta) {
+        if (LEVEL_PRIORITY[targetLevel] > threshold) {
+            return;
+        }
+        const entry = {
+            level: targetLevel,
+            message: truncateText(message, MAX_LOG_TEXT),
+            meta: sanitizeMeta(meta),
+            time: new Date().toISOString(),
+        };
+        process.stderr.write(`${JSON.stringify(entry)}\n`);
+    }
+    return {
+        debug(message, meta) {
+            write('debug', message, meta);
+        },
+        info(message, meta) {
+            write('info', message, meta);
+        },
+        warn(message, meta) {
+            write('warn', message, meta);
+        },
+        error(message, meta) {
+            write('error', message, meta);
+        },
+    };
+}
+function normalizeLevel(level) {
+    const normalized = level.trim().toLowerCase();
+    if (normalized === 'debug' || normalized === 'info' || normalized === 'warn' || normalized === 'error') {
+        return normalized;
+    }
+    return 'info';
+}
+function sanitizeMeta(value) {
+    if (Array.isArray(value)) {
+        return value.map((item) => sanitizeMeta(item));
+    }
+    if (!value || typeof value !== 'object') {
+        return value;
+    }
+    const result = {};
+    for (const [key, item] of Object.entries(value)) {
+        if (SENSITIVE_KEYS.has(key)) {
+            result[key] = '[REDACTED]';
+            continue;
+        }
+        result[key] = sanitizeMeta(item);
+    }
+    return result;
+}

package/dist/core/openapi.d.ts

@@ -0,0 +1,2 @@
+export declare function buildOpenApiDocSummary(openapiDoc: unknown, keyword?: string): Record<string, unknown>;
+export declare function renderOpenApiMarkdown(summary: Record<string, unknown>): string;