@ty_krystal/sei-ai 0.1.8 → 0.1.13

package/dist/core/cli-actions.d.ts

@@ -0,0 +1,94 @@
+export declare function runApiDocs(options: {
+    client: {
+        readApiDocs(): Promise<unknown>;
+    };
+    keyword?: string;
+    format?: 'json' | 'markdown';
+    outputPath?: string;
+}): Promise<void>;
+export declare function runRelogin(options: {
+    client: {
+        relogin(): Promise<string>;
+    };
+}): Promise<void>;
+export declare function runCall(options: {
+    client: {
+        call(method: string, path: string, payload?: unknown, requestOptions?: Record<string, unknown>): Promise<unknown>;
+    };
+    method: string;
+    path: string;
+    payload?: unknown;
+    allowFailure?: boolean;
+    allowEmpty?: boolean;
+    skipAuth?: boolean;
+}): Promise<void>;
+export declare function runQuery(options: {
+    client: {
+        query(payload: unknown, requestOptions?: Record<string, unknown>): Promise<unknown>;
+    };
+    payload: unknown;
+    allowFailure?: boolean;
+}): Promise<void>;
+export declare function runSave(options: {
+    client: {
+        save(payload: unknown, requestOptions?: Record<string, unknown>): Promise<unknown>;
+    };
+    payload: unknown;
+    allowFailure?: boolean;
+}): Promise<void>;
+export declare function runQuerySql(options: {
+    client: {
+        querySql(sql: string, page?: number, size?: number, requestOptions?: Record<string, unknown>): Promise<unknown>;
+    };
+    sql: string;
+    page?: number;
+    size?: number;
+    allowFailure?: boolean;
+}): Promise<void>;
+export declare function runDictList(options: {
+    client: {
+        query(payload: unknown, requestOptions?: Record<string, unknown>): Promise<unknown>;
+    };
+    typeCode?: string;
+    keyword?: string;
+    size?: number;
+    flat?: boolean;
+    allowFailure?: boolean;
+}): Promise<void>;
+export declare function runDictAddCategory(options: {
+    client: {
+        save(payload: unknown, requestOptions?: Record<string, unknown>): Promise<unknown>;
+    };
+    typeCode: string;
+    name: string;
+    rowOptions?: Record<string, unknown>;
+    allowFailure?: boolean;
+}): Promise<void>;
+export declare function runDictAddItem(options: {
+    client: {
+        save(payload: unknown, requestOptions?: Record<string, unknown>): Promise<unknown>;
+    };
+    typeCode: string;
+    code: string;
+    name: string;
+    rowOptions?: Record<string, unknown>;
+    allowFailure?: boolean;
+}): Promise<void>;
+export declare function runInitBaseData(options: {
+    client: {
+        executeDdlStatements(statements: string[], requestOptions?: Record<string, unknown>): Promise<unknown>;
+        call(method: string, path: string, payload?: unknown, requestOptions?: Record<string, unknown>): Promise<unknown>;
+    };
+    sqlFile?: string;
+    sysid?: string;
+    adminUid?: string;
+    adminName?: string;
+    adminRole?: string;
+    adminRoleName?: string;
+    adminPassword?: string;
+    resetAdminPassword?: boolean;
+    allowFailure?: boolean;
+}): Promise<void>;
+export declare function writeOutput(path: string | undefined, text: string): Promise<void>;
+export declare function resolveBaseSeedSqlPath(path: string | undefined): string;
+export declare function formatActionError(error: unknown): string;

package/dist/core/cli-actions.js

@@ -0,0 +1,155 @@
+import { readFile, writeFile } from 'node:fs/promises';
+import { resolve } from 'node:path';
+import { BASE_SEED_DEFAULT_ADMIN_ROLE, BASE_SEED_DEFAULT_ADMIN_UID } from './constants.js';
+import { formatCliError, SeiMcpError } from './errors.js';
+import { buildBaseSeedSqlVars, buildDictCategoryRow, buildDictItemRow, buildDictQueryPayload, buildDictSavePayload, buildDictTree, removeSqlCommentLines, renderBaseSeedSql, splitSqlStatements, } from './cli-helpers.js';
+import { printJson } from './command-base/output.js';
+import { buildOpenApiDocSummary, renderOpenApiMarkdown } from './openapi.js';
+export async function runApiDocs(options) {
+    const raw = await options.client.readApiDocs();
+    const summary = buildOpenApiDocSummary(raw, options.keyword);
+    const output = options.format === 'json' ? `${JSON.stringify(summary, null, 2)}\n` : renderOpenApiMarkdown(summary);
+    await writeOutput(options.outputPath, output);
+}
+export async function runRelogin(options) {
+    const token = await options.client.relogin();
+    printJson({
+        success: true,
+        code: 1,
+        message: '重新登录成功',
+        data: { token },
+    });
+}
+export async function runCall(options) {
+    const response = await options.client.call(options.method, options.path, options.payload, {
+        allowFailure: options.allowFailure,
+        allowEmpty: options.allowEmpty,
+        skipAuth: options.skipAuth,
+    });
+    printJson(response);
+}
+export async function runQuery(options) {
+    const response = await options.client.query(options.payload, {
+        allowFailure: options.allowFailure,
+    });
+    printJson(response);
+}
+export async function runSave(options) {
+    const response = await options.client.save(options.payload, {
+        allowFailure: options.allowFailure,
+    });
+    printJson(response);
+}
+export async function runQuerySql(options) {
+    const response = await options.client.querySql(options.sql, options.page, options.size, {
+        allowFailure: options.allowFailure,
+    });
+    printJson(response);
+}
+export async function runDictList(options) {
+    const payload = buildDictQueryPayload(options.typeCode, options.keyword, options.size ?? 1000);
+    const response = await options.client.query(payload, {
+        allowFailure: options.allowFailure,
+    });
+    if (!options.flat && isObject(response) && isObject(response.data) && Array.isArray(response.data.rows)) {
+        response.data.tree = buildDictTree(response.data.rows);
+    }
+    printJson(response);
+}
+export async function runDictAddCategory(options) {
+    const payload = buildDictSavePayload(buildDictCategoryRow({
+        body: stringOrUndefined(options.rowOptions?.body),
+        code: stringOrUndefined(options.rowOptions?.code),
+        ctype: stringOrUndefined(options.rowOptions?.ctype),
+        dictFlag: numberOrUndefined(options.rowOptions?.dictFlag),
+        ename: stringOrUndefined(options.rowOptions?.ename),
+        memo: stringOrUndefined(options.rowOptions?.memo),
+        name: options.name,
+        sort: numberOrUndefined(options.rowOptions?.sort),
+        sysid: stringOrUndefined(options.rowOptions?.sysid),
+        typeCode: options.typeCode,
+        uuid: stringOrUndefined(options.rowOptions?.uuid),
+    }));
+    const response = await options.client.save(payload, {
+        allowFailure: options.allowFailure,
+    });
+    printJson(response);
+}
+export async function runDictAddItem(options) {
+    const payload = buildDictSavePayload(buildDictItemRow({
+        body: stringOrUndefined(options.rowOptions?.body),
+        code: options.code,
+        ctype: stringOrUndefined(options.rowOptions?.ctype),
+        dictFlag: numberOrUndefined(options.rowOptions?.dictFlag),
+        ename: stringOrUndefined(options.rowOptions?.ename),
+        memo: stringOrUndefined(options.rowOptions?.memo),
+        name: options.name,
+        parent: stringOrUndefined(options.rowOptions?.parent),
+        sort: numberOrUndefined(options.rowOptions?.sort),
+        sysid: stringOrUndefined(options.rowOptions?.sysid),
+        typeCode: options.typeCode,
+        uuid: stringOrUndefined(options.rowOptions?.uuid),
+    }));
+    const response = await options.client.save(payload, {
+        allowFailure: options.allowFailure,
+    });
+    printJson(response);
+}
+export async function runInitBaseData(options) {
+    const sqlFile = resolveBaseSeedSqlPath(options.sqlFile);
+    const template = await readFile(sqlFile, 'utf8');
+    const sql = renderBaseSeedSql(template, buildBaseSeedSqlVars({
+        adminName: options.adminName,
+        adminPassword: options.adminPassword,
+        adminRole: options.adminRole,
+        adminRoleName: options.adminRoleName,
+        adminUid: options.adminUid,
+        resetAdminPassword: options.resetAdminPassword,
+        sysid: options.sysid,
+    }));
+    const statements = splitSqlStatements(removeSqlCommentLines(sql));
+    if (statements.length === 0) {
+        throw new SeiMcpError('初始化 SQL 文件没有可执行语句', 'INVALID_PARAMS');
+    }
+    const executed = await options.client.executeDdlStatements(statements, {
+        allowFailure: options.allowFailure,
+    });
+    await options.client.call('POST', '/api/sei/data/removeAllCache', {}, { allowFailure: false }).catch(() => undefined);
+    printJson({
+        success: true,
+        code: 1,
+        message: '基础源数据初始化完成',
+        data: {
+            executed: Array.isArray(executed) ? executed.length : 0,
+            sqlFile,
+            admin: options.adminUid ?? BASE_SEED_DEFAULT_ADMIN_UID,
+            role: options.adminRole ?? BASE_SEED_DEFAULT_ADMIN_ROLE,
+        },
+    });
+}
+export async function writeOutput(path, text) {
+    if (!path) {
+        process.stdout.write(text);
+        return;
+    }
+    await writeFile(path, text, 'utf8');
+    process.stdout.write(`已写入：${path}\n`);
+}
+export function resolveBaseSeedSqlPath(path) {
+    if (path) {
+        return resolve(path);
+    }
+    return resolve(process.cwd(), '.codex/skills/sei-ai/scripts/init-base-data.sql');
+}
+export function formatActionError(error) {
+    return formatCliError(error);
+}
+function stringOrUndefined(value) {
+    return typeof value === 'string' && value.trim() ? value.trim() : undefined;
+}
+function numberOrUndefined(value) {
+    return typeof value === 'number' && Number.isFinite(value) ? value : undefined;
+}
+function isObject(value) {
+    return Boolean(value) && typeof value === 'object' && !Array.isArray(value);
+}

package/dist/core/cli-helpers.d.ts

@@ -0,0 +1,39 @@
+export interface DictRowInput {
+    body?: string;
+    ctype?: string;
+    dictFlag?: number;
+    ename?: string;
+    memo?: string;
+    sort?: number;
+    sysid?: string;
+    uuid?: string;
+}
+export interface DictCategoryInput extends DictRowInput {
+    code?: string;
+    name: string;
+    typeCode: string;
+}
+export interface DictItemInput extends DictRowInput {
+    code: string;
+    name: string;
+    parent?: string;
+    typeCode: string;
+}
+export interface InitBaseDataInput {
+    adminName?: string;
+    adminPassword?: string;
+    adminRole?: string;
+    adminRoleName?: string;
+    adminUid?: string;
+    resetAdminPassword?: boolean;
+    sysid?: string;
+}
+export declare function buildDictQueryPayload(typeCode?: string, keyword?: string, size?: number): Record<string, unknown>;
+export declare function buildDictSavePayload(row: Record<string, unknown>): Record<string, unknown>;
+export declare function buildDictCategoryRow(input: DictCategoryInput): Record<string, unknown>;
+export declare function buildDictItemRow(input: DictItemInput): Record<string, unknown>;
+export declare function buildDictTree(rows: unknown): Array<Record<string, unknown>>;
+export declare function buildBaseSeedSqlVars(input: InitBaseDataInput): Record<string, string>;
+export declare function renderBaseSeedSql(template: string, values: Record<string, string>): string;
+export declare function removeSqlCommentLines(sql: string): string;
+export declare function splitSqlStatements(sql: string): string[];

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,40 @@
+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>;
+        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;
+    account?: string;
+    accountProject?: string;
+    accountCheckcode?: string;
+    timeoutMs?: number;
+}