@ty_krystal/sei-ai 0.1.8 → 0.1.12

package/dist/core/cli-helpers.js

@@ -0,0 +1,246 @@
+import { createHash } from 'node:crypto';
+import { BASE_SEED_DEFAULT_ADMIN_PASSWORD, BASE_SEED_DEFAULT_ADMIN_ROLE, BASE_SEED_DEFAULT_ADMIN_UID, BASE_SEED_DEFAULT_SYSID, DICT_DEFAULT_SYSID, DICT_FIELDS, DICT_MODULE, } from './constants.js';
+import { SeiMcpError } from './errors.js';
+export function buildDictQueryPayload(typeCode, keyword, size = 1000) {
+    return {
+        head: {
+            module: DICT_MODULE,
+        },
+        option: {
+            keyField: true,
+            privilege: true,
+            fields: DICT_FIELDS.join(','),
+            filter: buildDictQueryFilter(typeCode, keyword),
+            order: '_SORT ASC,_CODE ASC',
+            page: 1,
+            size,
+        },
+    };
+}
+export function buildDictSavePayload(row) {
+    return {
+        head: {
+            module: DICT_MODULE,
+        },
+        data: [
+            {
+                action: 'add',
+                option: {
+                    keyVal: true,
+                },
+                rows: [
+                    {
+                        row,
+                    },
+                ],
+            },
+        ],
+    };
+}
+export function buildDictCategoryRow(input) {
+    const typeCode = requiredText(input.typeCode, '字典类别');
+    const name = requiredText(input.name, '字典名称');
+    const uuid = requiredText(input.uuid || typeCode, '字典编号');
+    const code = requiredText(input.code || typeCode, '字典代码');
+    return {
+        _UUID: uuid,
+        _PID: '',
+        _SYSID: requiredText(input.sysid || DICT_DEFAULT_SYSID, '所属系统'),
+        _TYPE: typeCode,
+        _CTYPE: normalizeText(input.ctype),
+        _CODE: code,
+        _NAME: name,
+        _ENAME: normalizeText(input.ename),
+        _DICT: normalizeDictFlag(input.dictFlag),
+        _SORT: normalizeSort(input.sort),
+        _BODY: normalizeText(input.body),
+        _MEMO: normalizeText(input.memo),
+    };
+}
+export function buildDictItemRow(input) {
+    const typeCode = requiredText(input.typeCode, '字典类别');
+    const code = requiredText(input.code, '字典代码');
+    const name = requiredText(input.name, '字典名称');
+    const parent = requiredText(input.parent || typeCode, '父级编号');
+    const uuid = requiredText(input.uuid || `${parent}_${code}`, '字典编号');
+    return {
+        _UUID: uuid,
+        _PID: parent,
+        _SYSID: requiredText(input.sysid || DICT_DEFAULT_SYSID, '所属系统'),
+        _TYPE: typeCode,
+        _CTYPE: normalizeText(input.ctype),
+        _CODE: code,
+        _NAME: name,
+        _ENAME: normalizeText(input.ename),
+        _DICT: normalizeDictFlag(input.dictFlag),
+        _SORT: normalizeSort(input.sort),
+        _BODY: normalizeText(input.body),
+        _MEMO: normalizeText(input.memo),
+    };
+}
+export function buildDictTree(rows) {
+    if (!Array.isArray(rows)) {
+        return [];
+    }
+    const recordMap = new Map();
+    const childrenMap = new Map();
+    const roots = [];
+    for (const row of rows) {
+        if (!isObject(row)) {
+            continue;
+        }
+        const key = normalizeText(row._UUID);
+        if (!key) {
+            continue;
+        }
+        recordMap.set(key, { ...row });
+    }
+    for (const record of recordMap.values()) {
+        const parentId = normalizeText(record._PID);
+        if (!parentId || !recordMap.has(parentId)) {
+            roots.push(record);
+            continue;
+        }
+        const children = childrenMap.get(parentId) ?? [];
+        children.push(record);
+        childrenMap.set(parentId, children);
+    }
+    for (const [key, record] of recordMap.entries()) {
+        const children = childrenMap.get(key);
+        if (children && children.length > 0) {
+            record.children = children.sort(dictSortKey);
+        }
+    }
+    return roots.sort(dictSortKey);
+}
+export function buildBaseSeedSqlVars(input) {
+    const adminPassword = input.adminPassword || BASE_SEED_DEFAULT_ADMIN_PASSWORD;
+    const passwordHash = createHash('md5').update(adminPassword, 'utf8').digest('hex');
+    const adminUid = input.adminUid || BASE_SEED_DEFAULT_ADMIN_UID;
+    const adminRole = input.adminRole || BASE_SEED_DEFAULT_ADMIN_ROLE;
+    const resetSql = input.resetAdminPassword === true
+        ? `UPDATE _SYS_USER\nSET _PWD = ${sqlLiteral(passwordHash)}\nWHERE _UID = ${sqlLiteral(adminUid)};`
+        : '';
+    return {
+        SYSID: sqlLiteral(input.sysid || BASE_SEED_DEFAULT_SYSID),
+        ADMIN_UID: sqlLiteral(adminUid),
+        ADMIN_NAME: sqlLiteral(input.adminName || '管理员'),
+        ADMIN_ROLE: sqlLiteral(adminRole),
+        ADMIN_ROLE_NAME: sqlLiteral(input.adminRoleName || '管理员'),
+        ADMIN_PASSWORD_MD5: sqlLiteral(passwordHash),
+        RESET_ADMIN_PASSWORD_SQL: resetSql,
+    };
+}
+export function renderBaseSeedSql(template, values) {
+    let rendered = template;
+    for (const [key, value] of Object.entries(values)) {
+        rendered = rendered.replaceAll(`{{${key}}}`, value);
+    }
+    const missing = [...rendered.matchAll(/\{\{[A-Z0-9_]+\}\}/g)].map((item) => item[0]);
+    if (missing.length > 0) {
+        throw new SeiMcpError(`初始化 SQL 存在未替换变量：${[...new Set(missing)].join(', ')}`, 'INVALID_PARAMS');
+    }
+    return rendered;
+}
+export function removeSqlCommentLines(sql) {
+    return sql
+        .split('\n')
+        .filter((line) => !line.trimStart().startsWith('--'))
+        .join('\n');
+}
+export function splitSqlStatements(sql) {
+    const statements = [];
+    let current = '';
+    let quote = null;
+    let escaped = false;
+    for (const char of sql) {
+        if (escaped) {
+            current += char;
+            escaped = false;
+            continue;
+        }
+        if (char === '\\' && quote !== null) {
+            current += char;
+            escaped = true;
+            continue;
+        }
+        if (quote !== null) {
+            current += char;
+            if (char === quote) {
+                quote = null;
+            }
+            continue;
+        }
+        if (char === '\'' || char === '"' || char === '`') {
+            current += char;
+            quote = char;
+            continue;
+        }
+        if (char === ';') {
+            const statement = current.trim();
+            if (statement) {
+                statements.push(statement);
+            }
+            current = '';
+            continue;
+        }
+        current += char;
+    }
+    const finalStatement = current.trim();
+    if (finalStatement) {
+        statements.push(finalStatement);
+    }
+    return statements;
+}
+function buildDictQueryFilter(typeCode, keyword) {
+    const filters = [];
+    const normalizedType = normalizeText(typeCode);
+    const normalizedKeyword = normalizeText(keyword);
+    if (normalizedType) {
+        filters.push({ _TYPE: { '=': normalizedType } });
+    }
+    if (normalizedKeyword) {
+        filters.push({
+            OR: [
+                { _UUID: { '*LIKE*': normalizedKeyword } },
+                { _TYPE: { '*LIKE*': normalizedKeyword } },
+                { _CODE: { '*LIKE*': normalizedKeyword } },
+                { _NAME: { '*LIKE*': normalizedKeyword } },
+            ],
+        });
+    }
+    return filters;
+}
+function dictSortKey(a, b) {
+    const sortA = normalizeSort(typeof a._SORT === 'number' ? a._SORT : Number(a._SORT ?? 0));
+    const sortB = normalizeSort(typeof b._SORT === 'number' ? b._SORT : Number(b._SORT ?? 0));
+    if (sortA !== sortB) {
+        return sortA - sortB;
+    }
+    return normalizeText(a._CODE).localeCompare(normalizeText(b._CODE), 'zh-CN');
+}
+function normalizeDictFlag(value) {
+    return value === 1 ? 1 : 0;
+}
+function normalizeSort(value) {
+    return Number.isInteger(value) && Number(value) >= 0 ? Number(value) : 100;
+}
+function requiredText(value, label) {
+    const normalized = normalizeText(value);
+    if (!normalized) {
+        throw new SeiMcpError(`${label} 不能为空`, 'INVALID_PARAMS');
+    }
+    return normalized;
+}
+function normalizeText(value) {
+    return typeof value === 'string' ? value.trim() : '';
+}
+function sqlLiteral(value) {
+    if (value === null || value === undefined) {
+        return 'NULL';
+    }
+    return `'${String(value).replace(/'/g, "''")}'`;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/core/command-base/context.d.ts

@@ -0,0 +1,6 @@
+import type { Logger, SeiMcpConfig } from '../types.js';
+export interface CliContext {
+    config: SeiMcpConfig;
+    logger: Logger;
+}
+export declare function loadCliContext(argv?: string[], env?: NodeJS.ProcessEnv): Promise<CliContext>;

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

@@ -0,0 +1,10 @@
+import { loadConfig } from '../config.js';
+import { DEFAULT_LOG_LEVEL } from '../constants.js';
+import { loadWorkingDirEnv } from '../env.js';
+import { createLogger } from '../logger.js';
+export async function loadCliContext(argv = process.argv.slice(2), env = process.env) {
+    await loadWorkingDirEnv();
+    const logger = createLogger(env.SEI_MCP_LOG_LEVEL ?? DEFAULT_LOG_LEVEL);
+    const config = await loadConfig(argv, env);
+    return { config, logger };
+}

package/dist/core/command-base/output.d.ts

@@ -0,0 +1,2 @@
+export declare function printJson(value: unknown): void;
+export declare function writeText(text: string): void;

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

@@ -0,0 +1,6 @@
+export function printJson(value) {
+    process.stdout.write(`${JSON.stringify(value, null, 2)}\n`);
+}
+export function writeText(text) {
+    process.stdout.write(text);
+}

package/dist/core/command-base/payload.d.ts

@@ -0,0 +1,7 @@
+export declare function loadPayload(options: {
+    fallback?: unknown;
+    filePath?: string;
+    jsonText?: string;
+    stdin?: boolean;
+}): Promise<unknown>;
+export declare function parseJson(text: string): unknown;

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

@@ -0,0 +1,33 @@
+import { readFile } from 'node:fs/promises';
+import { SeiMcpError } from '../errors.js';
+export async function loadPayload(options) {
+    const sources = [options.stdin, options.jsonText !== undefined, options.filePath !== undefined].filter(Boolean).length;
+    if (sources > 1) {
+        throw new SeiMcpError('只能选择一种载荷来源：--json、--file 或 --stdin', 'INVALID_PARAMS');
+    }
+    if (options.jsonText !== undefined) {
+        return parseJson(options.jsonText);
+    }
+    if (options.filePath !== undefined) {
+        return parseJson(await readFile(options.filePath, 'utf8'));
+    }
+    if (options.stdin) {
+        return parseJson(await readStdin());
+    }
+    return options.fallback;
+}
+export function parseJson(text) {
+    try {
+        return JSON.parse(text);
+    }
+    catch (error) {
+        throw new SeiMcpError(`载荷不是合法 JSON：${error instanceof Error ? error.message : String(error)}`, 'INVALID_PARAMS');
+    }
+}
+async function readStdin() {
+    const chunks = [];
+    for await (const chunk of process.stdin) {
+        chunks.push(Buffer.isBuffer(chunk) ? chunk : Buffer.from(chunk));
+    }
+    return Buffer.concat(chunks).toString('utf8');
+}

package/dist/core/command-base/sei-command.d.ts

@@ -0,0 +1,42 @@
+import { Command } from '@oclif/core';
+import type { CliSeiClient } from '../sei-client.js';
+import type { Logger, SeiMcpConfig } from '../types.js';
+export declare abstract class SeiCommand extends Command {
+    static baseFlags: {
+        config: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'base-url': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'ai-key': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        role: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        account: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'account-project': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        'account-checkcode': import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        token: import("@oclif/core/interfaces").OptionFlag<string | undefined, import("@oclif/core/interfaces").CustomOptions>;
+        timeout: import("@oclif/core/interfaces").OptionFlag<number | undefined, import("@oclif/core/interfaces").CustomOptions>;
+    };
+    protected logger: Logger;
+    protected configData: SeiMcpConfig;
+    protected init(): Promise<void>;
+    protected resolveConfig(): Promise<SeiMcpConfig>;
+    protected createCliClient(options?: Partial<SeiAuthSettingsOptions>): Promise<CliSeiClient>;
+    protected loadPayload(input: {
+        fallback?: unknown;
+        filePath?: string;
+        jsonText?: string;
+        stdin?: boolean;
+    }): Promise<unknown>;
+    protected printJson(value: unknown): void;
+    protected writeText(text: string): void;
+    protected createAuthOptions(flags: Record<string, unknown>): SeiAuthSettingsOptions;
+    protected createClientFromFlags(flags: Record<string, unknown>): Promise<CliSeiClient>;
+    protected catch(error: unknown): Promise<unknown>;
+}
+export interface SeiAuthSettingsOptions {
+    baseUrl?: string;
+    token?: string;
+    aiKey?: string;
+    role?: string;
+    account?: string;
+    accountProject?: string;
+    accountCheckcode?: string;
+    timeoutMs?: number;
+}

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

@@ -0,0 +1,88 @@
+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 登录密钥' }),
+        role: Flags.string({ aliases: ['profile'], 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,
+            role: options.role,
+            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'),
+            role: stringFlag(flags, 'role') ?? stringFlag(flags, 'profile'),
+            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,82 @@
+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),
+            accountEnv: stringOrEnv(auth.accountEnv, env.SEI_AI_LOGIN_ACCOUNT ? 'SEI_AI_LOGIN_ACCOUNT' : 'SEI_AI_LOGIN_ACCOUNT'),
+            role: stringOrEnv(auth.role, env.SEI_AI_LOGIN_ROLE),
+            roleEnv: stringOrEnv(auth.roleEnv, env.SEI_AI_LOGIN_ROLE ? 'SEI_AI_LOGIN_ROLE' : 'SEI_AI_LOGIN_ROLE'),
+        },
+        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>;