@ty_krystal/sei-ai 0.1.5 → 0.1.6

package/dist/cli-helpers.js

@@ -1,246 +0,0 @@
-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/command-base/context.js

@@ -1,10 +0,0 @@
-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/command-base/output.js

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

package/dist/command-base/payload.js

@@ -1,33 +0,0 @@
-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/command-base/sei-command.js

@@ -1,88 +0,0 @@
-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/stdio.js

@@ -1,16 +0,0 @@
-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

@@ -1,29 +0,0 @@
-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.example.json

@@ -1,33 +0,0 @@
-{
-  "baseUrl": "http://127.0.0.1:8081",
-  "auth": {
-    "mode": "ai-login",
-    "aiKeyEnv": "SEI_AI_LOGIN_KEY",
-    "roleEnv": "SEI_AI_LOGIN_ROLE"
-  },
-  "tools": {
-    "query": true,
-    "save": true,
-    "schema": true,
-    "querySql": false
-  },
-  "targets": {
-    "modules": {
-      "demo_order": {
-        "mainTable": "demo_order",
-        "query": {
-          "fields": ["_ID", "ORDER_NO", "STATUS", "AMOUNT"],
-          "defaultFields": ["_ID", "ORDER_NO", "STATUS"],
-          "allowAllFields": false
-        },
-        "save": {
-          "actions": ["add", "edit"],
-          "fields": ["STATUS", "MEMO"]
-        }
-      }
-    },
-    "tables": {},
-    "sources": {},
-    "views": {}
-  }
-}

package/dist/config.js

@@ -1,82 +0,0 @@
-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

@@ -1,48 +0,0 @@
-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

@@ -1,33 +0,0 @@
-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';
-}