@ty_krystal/sei-ai 0.1.4 → 0.1.5

package/dist/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/commands/api-docs.js

@@ -0,0 +1,23 @@
+import { Flags } from '@oclif/core';
+import { SeiCommand } from '../command-base/sei-command.js';
+import { runApiDocs } from '../cli-actions.js';
+export default class ApiDocsCommand extends SeiCommand {
+    static summary = 'Export and render OpenAPI docs';
+    static description = 'Fetches the SEI OpenAPI document and renders a markdown or JSON summary.';
+    static flags = {
+        ...SeiCommand.baseFlags,
+        keyword: Flags.string({ description: '过滤关键字' }),
+        format: Flags.string({ default: 'markdown', description: '输出格式' }),
+        output: Flags.string({ description: '输出文件路径' }),
+    };
+    async run() {
+        const { flags } = await this.parse(ApiDocsCommand);
+        const client = await this.createClientFromFlags(flags);
+        await runApiDocs({
+            client: { readApiDocs: () => client.readApiDocs() },
+            keyword: flags.keyword,
+            format: flags.format === 'json' ? 'json' : 'markdown',
+            outputPath: flags.output,
+        });
+    }
+}

package/dist/commands/call.js

@@ -0,0 +1,38 @@
+import { Args, Flags } from '@oclif/core';
+import { SeiCommand } from '../command-base/sei-command.js';
+import { runCall } from '../cli-actions.js';
+export default class CallCommand extends SeiCommand {
+    static summary = 'Call a SEI endpoint';
+    static description = 'Makes an authenticated request to a SEI endpoint.';
+    static args = {
+        method: Args.string({ required: true, description: 'HTTP method' }),
+        path: Args.string({ required: true, description: 'Request path' }),
+    };
+    static flags = {
+        ...SeiCommand.baseFlags,
+        json: Flags.string({ description: 'JSON payload' }),
+        file: Flags.string({ description: 'JSON file path' }),
+        stdin: Flags.boolean({ default: false, description: 'Read JSON payload from stdin' }),
+        'allow-failure': Flags.boolean({ default: false, description: '允许失败响应' }),
+        'allow-empty': Flags.boolean({ default: false, description: '允许空响应' }),
+        'no-token': Flags.boolean({ default: false, description: '不附带 token' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(CallCommand);
+        const client = await this.createClientFromFlags(flags);
+        const payload = await this.loadPayload({
+            jsonText: flags.json,
+            filePath: flags.file,
+            stdin: flags.stdin,
+        });
+        await runCall({
+            client: { call: (method, path, body, requestOptions) => client.call(method, path, body, requestOptions) },
+            method: args.method,
+            path: args.path,
+            payload,
+            allowFailure: flags['allow-failure'],
+            allowEmpty: flags['allow-empty'],
+            skipAuth: flags['no-token'],
+        });
+    }
+}

package/dist/commands/dict/add-category.js

@@ -0,0 +1,45 @@
+import { Args, Flags } from '@oclif/core';
+import { SeiCommand } from '../../command-base/sei-command.js';
+import { runDictAddCategory } from '../../cli-actions.js';
+export default class DictAddCategoryCommand extends SeiCommand {
+    static summary = 'Add a dictionary category';
+    static description = 'Builds and saves a SEI dictionary category row.';
+    static args = {
+        typeCode: Args.string({ required: true, description: '字典类别编码' }),
+        name: Args.string({ required: true, description: '字典名称' }),
+    };
+    static flags = {
+        ...SeiCommand.baseFlags,
+        code: Flags.string({ description: '字典代码' }),
+        ctype: Flags.string({ description: '分类类型' }),
+        'dict-flag': Flags.integer({ description: '字典标记' }),
+        ename: Flags.string({ description: '英文名' }),
+        memo: Flags.string({ description: '备注' }),
+        sort: Flags.integer({ description: '排序号' }),
+        sysid: Flags.string({ description: '系统编号' }),
+        uuid: Flags.string({ description: 'UUID' }),
+        body: Flags.string({ description: '附加内容' }),
+        'allow-failure': Flags.boolean({ default: false, description: '允许失败响应' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(DictAddCategoryCommand);
+        const client = await this.createClientFromFlags(flags);
+        await runDictAddCategory({
+            client: { save: (payload, requestOptions) => client.save(payload, requestOptions) },
+            typeCode: args.typeCode,
+            name: args.name,
+            rowOptions: {
+                body: flags.body,
+                code: flags.code,
+                ctype: flags.ctype,
+                dictFlag: flags['dict-flag'],
+                ename: flags.ename,
+                memo: flags.memo,
+                sort: flags.sort,
+                sysid: flags.sysid,
+                uuid: flags.uuid,
+            },
+            allowFailure: flags['allow-failure'],
+        });
+    }
+}

package/dist/commands/dict/add-item.js

@@ -0,0 +1,47 @@
+import { Args, Flags } from '@oclif/core';
+import { SeiCommand } from '../../command-base/sei-command.js';
+import { runDictAddItem } from '../../cli-actions.js';
+export default class DictAddItemCommand extends SeiCommand {
+    static summary = 'Add a dictionary item';
+    static description = 'Builds and saves a SEI dictionary item row.';
+    static args = {
+        typeCode: Args.string({ required: true, description: '字典类别编码' }),
+        code: Args.string({ required: true, description: '字典项编码' }),
+        name: Args.string({ required: true, description: '字典项名称' }),
+    };
+    static flags = {
+        ...SeiCommand.baseFlags,
+        parent: Flags.string({ description: '父级编号' }),
+        ctype: Flags.string({ description: '分类类型' }),
+        'dict-flag': Flags.integer({ description: '字典标记' }),
+        ename: Flags.string({ description: '英文名' }),
+        memo: Flags.string({ description: '备注' }),
+        sort: Flags.integer({ description: '排序号' }),
+        sysid: Flags.string({ description: '系统编号' }),
+        uuid: Flags.string({ description: 'UUID' }),
+        body: Flags.string({ description: '附加内容' }),
+        'allow-failure': Flags.boolean({ default: false, description: '允许失败响应' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(DictAddItemCommand);
+        const client = await this.createClientFromFlags(flags);
+        await runDictAddItem({
+            client: { save: (payload, requestOptions) => client.save(payload, requestOptions) },
+            typeCode: args.typeCode,
+            code: args.code,
+            name: args.name,
+            rowOptions: {
+                body: flags.body,
+                ctype: flags.ctype,
+                dictFlag: flags['dict-flag'],
+                ename: flags.ename,
+                memo: flags.memo,
+                parent: flags.parent,
+                sort: flags.sort,
+                sysid: flags.sysid,
+                uuid: flags.uuid,
+            },
+            allowFailure: flags['allow-failure'],
+        });
+    }
+}

package/dist/commands/dict/list.js

@@ -0,0 +1,27 @@
+import { Flags } from '@oclif/core';
+import { SeiCommand } from '../../command-base/sei-command.js';
+import { runDictList } from '../../cli-actions.js';
+export default class DictListCommand extends SeiCommand {
+    static summary = 'List dictionary entries';
+    static description = 'Queries SEI dictionary data and optionally renders the tree structure.';
+    static flags = {
+        ...SeiCommand.baseFlags,
+        type: Flags.string({ description: '字典类型' }),
+        keyword: Flags.string({ description: '过滤关键字' }),
+        size: Flags.integer({ default: 1000, description: '返回条数' }),
+        flat: Flags.boolean({ default: false, description: '只输出平铺结果' }),
+        'allow-failure': Flags.boolean({ default: false, description: '允许失败响应' }),
+    };
+    async run() {
+        const { flags } = await this.parse(DictListCommand);
+        const client = await this.createClientFromFlags(flags);
+        await runDictList({
+            client: { query: (payload, requestOptions) => client.query(payload, requestOptions) },
+            typeCode: flags.type,
+            keyword: flags.keyword,
+            size: flags.size,
+            flat: flags.flat,
+            allowFailure: flags['allow-failure'],
+        });
+    }
+}

package/dist/commands/init/base-data.js

@@ -0,0 +1,38 @@
+import { Flags } from '@oclif/core';
+import { SeiCommand } from '../../command-base/sei-command.js';
+import { runInitBaseData } from '../../cli-actions.js';
+export default class InitBaseDataCommand extends SeiCommand {
+    static summary = 'Initialize base data';
+    static description = 'Executes the base seed SQL and clears SEI caches.';
+    static flags = {
+        ...SeiCommand.baseFlags,
+        'admin-uid': Flags.string({ description: '管理员 UID' }),
+        'admin-name': Flags.string({ description: '管理员名称' }),
+        'admin-role': Flags.string({ description: '管理员角色' }),
+        'admin-role-name': Flags.string({ description: '管理员角色名称' }),
+        'admin-password': Flags.string({ description: '管理员密码' }),
+        sysid: Flags.string({ description: '系统编号' }),
+        'reset-admin-password': Flags.boolean({ default: false, description: '重置管理员密码' }),
+        'sql-file': Flags.string({ description: '初始化 SQL 文件' }),
+        'allow-failure': Flags.boolean({ default: false, description: '允许失败响应' }),
+    };
+    async run() {
+        const { flags } = await this.parse(InitBaseDataCommand);
+        const client = await this.createClientFromFlags(flags);
+        await runInitBaseData({
+            client: {
+                executeDdlStatements: (statements, requestOptions) => client.executeDdlStatements(statements, requestOptions),
+                call: (method, path, payload, requestOptions) => client.call(method, path, payload, requestOptions),
+            },
+            sqlFile: flags['sql-file'],
+            sysid: flags.sysid,
+            adminUid: flags['admin-uid'],
+            adminName: flags['admin-name'],
+            adminRole: flags['admin-role'],
+            adminRoleName: flags['admin-role-name'],
+            adminPassword: flags['admin-password'],
+            resetAdminPassword: flags['reset-admin-password'],
+            allowFailure: flags['allow-failure'],
+        });
+    }
+}

package/dist/commands/query-sql.js

@@ -0,0 +1,30 @@
+import { Args, Flags } from '@oclif/core';
+import { SeiCommand } from '../command-base/sei-command.js';
+import { runQuerySql } from '../cli-actions.js';
+import { buildQuerySqlPayload } from '../sei-client.js';
+export default class QuerySqlCommand extends SeiCommand {
+    static summary = 'Query SEI with SQL';
+    static description = 'Executes querySQL against SEI using a SQL string.';
+    static aliases = ['sql'];
+    static args = {
+        sql: Args.string({ description: 'SQL 语句', required: true }),
+    };
+    static flags = {
+        ...SeiCommand.baseFlags,
+        page: Flags.integer({ default: 1, description: '页码' }),
+        size: Flags.integer({ default: 20, description: '每页条数' }),
+        'allow-failure': Flags.boolean({ default: false, description: '允许失败响应' }),
+    };
+    async run() {
+        const { args, flags } = await this.parse(QuerySqlCommand);
+        const client = await this.createClientFromFlags(flags);
+        const payload = buildQuerySqlPayload(args.sql, flags.page, flags.size);
+        await runQuerySql({
+            client: { querySql: (sql, page, size, requestOptions) => client.querySql(sql, page, size, requestOptions) },
+            sql: payload.sql,
+            page: payload.page,
+            size: payload.size,
+            allowFailure: flags['allow-failure'],
+        });
+    }
+}

package/dist/commands/query.js

@@ -0,0 +1,28 @@
+import { Flags } from '@oclif/core';
+import { SeiCommand } from '../command-base/sei-command.js';
+import { runQuery } from '../cli-actions.js';
+export default class QueryCommand extends SeiCommand {
+    static summary = 'Query SEI data';
+    static description = 'Sends a SEI query payload.';
+    static flags = {
+        ...SeiCommand.baseFlags,
+        json: Flags.string({ description: 'JSON payload' }),
+        file: Flags.string({ description: 'JSON file path' }),
+        stdin: Flags.boolean({ default: false, description: 'Read JSON payload from stdin' }),
+        'allow-failure': Flags.boolean({ default: false, description: '允许失败响应' }),
+    };
+    async run() {
+        const { flags } = await this.parse(QueryCommand);
+        const client = await this.createClientFromFlags(flags);
+        const payload = await this.loadPayload({
+            jsonText: flags.json,
+            filePath: flags.file,
+            stdin: flags.stdin,
+        });
+        await runQuery({
+            client: { query: (input, requestOptions) => client.query(input, requestOptions) },
+            payload,
+            allowFailure: flags['allow-failure'],
+        });
+    }
+}

package/dist/commands/relogin.js

@@ -0,0 +1,16 @@
+import { SeiCommand } from '../command-base/sei-command.js';
+import { runRelogin } from '../cli-actions.js';
+export default class ReloginCommand extends SeiCommand {
+    static summary = 'Refresh the login token';
+    static description = 'Forces a fresh ai-login and prints the new token.';
+    static flags = {
+        ...SeiCommand.baseFlags,
+    };
+    async run() {
+        const { flags } = await this.parse(ReloginCommand);
+        const client = await this.createClientFromFlags(flags);
+        await runRelogin({
+            client: { relogin: () => client.relogin() },
+        });
+    }
+}

package/dist/commands/save.js

@@ -0,0 +1,28 @@
+import { Flags } from '@oclif/core';
+import { SeiCommand } from '../command-base/sei-command.js';
+import { runSave } from '../cli-actions.js';
+export default class SaveCommand extends SeiCommand {
+    static summary = 'Save SEI data';
+    static description = 'Sends a SEI save payload.';
+    static flags = {
+        ...SeiCommand.baseFlags,
+        json: Flags.string({ description: 'JSON payload' }),
+        file: Flags.string({ description: 'JSON file path' }),
+        stdin: Flags.boolean({ default: false, description: 'Read JSON payload from stdin' }),
+        'allow-failure': Flags.boolean({ default: false, description: '允许失败响应' }),
+    };
+    async run() {
+        const { flags } = await this.parse(SaveCommand);
+        const client = await this.createClientFromFlags(flags);
+        const payload = await this.loadPayload({
+            jsonText: flags.json,
+            filePath: flags.file,
+            stdin: flags.stdin,
+        });
+        await runSave({
+            client: { save: (input, requestOptions) => client.save(input, requestOptions) },
+            payload,
+            allowFailure: flags['allow-failure'],
+        });
+    }
+}

package/dist/commands/stdio.js

@@ -0,0 +1,16 @@
+import { SeiCommand } from '../command-base/sei-command.js';
+import { createMcpServer, startStdioServer } from '../server.js';
+import { createSeiClient } from '../sei-client.js';
+export default class StdioCommand extends SeiCommand {
+    static summary = 'Start MCP server over stdio';
+    static description = 'Starts the SEI MCP server using stdio transport.';
+    static flags = {
+        ...SeiCommand.baseFlags,
+    };
+    async run() {
+        const config = await this.resolveConfig();
+        const client = createSeiClient(config, this.logger);
+        const server = createMcpServer({ config, client, logger: this.logger });
+        await startStdioServer(server);
+    }
+}

package/dist/commands/streamable-http.js

@@ -0,0 +1,29 @@
+import { Flags } from '@oclif/core';
+import { SeiCommand } from '../command-base/sei-command.js';
+import { createMcpServer, startHttpServer } from '../server.js';
+import { createSeiClient } from '../sei-client.js';
+export default class StreamableHttpCommand extends SeiCommand {
+    static summary = 'Start MCP server over streamable HTTP';
+    static description = 'Starts the SEI MCP server using the streamable HTTP transport.';
+    static flags = {
+        ...SeiCommand.baseFlags,
+        host: Flags.string({ default: '127.0.0.1', description: 'HTTP bind host' }),
+        port: Flags.integer({ default: 3000, description: 'HTTP bind port' }),
+        path: Flags.string({ default: '/mcp', description: 'HTTP endpoint path' }),
+        'http-json-response': Flags.boolean({ default: false, description: 'Enable JSON response mode' }),
+    };
+    async run() {
+        const { flags } = await this.parse(StreamableHttpCommand);
+        const config = await this.resolveConfig();
+        const client = createSeiClient(config, this.logger);
+        await startHttpServer(() => createMcpServer({ config, client, logger: this.logger }), {
+            command: 'serve',
+            transport: 'streamable-http',
+            host: flags.host,
+            port: flags.port,
+            path: flags.path,
+            enableJsonResponse: flags['http-json-response'],
+            cliArgs: [],
+        }, this.logger);
+    }
+}

package/dist/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/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/env.js

@@ -0,0 +1,33 @@
+import { readFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { parseEnv } from 'node:util';
+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 = parseEnv(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';
+}