@meet-im/lxcli 0.0.1

package/dist/core/http.js

@@ -0,0 +1,140 @@
+// src/core/http.ts
+import { logger } from './logger.js';
+import { outputApiError } from './error.js';
+import pkg from '../../package.json' with { type: 'json' };
+// ─── 重试配置 ───────────────────────────────────────
+const MAX_RETRIES = 3;
+const BASE_DELAY_MS = 1000;
+const MAX_DELAY_MS = 10000;
+function parseRetryAfterDelay(retryAfterHeader) {
+    if (!retryAfterHeader) {
+        return null;
+    }
+    const retryAfterSeconds = Number(retryAfterHeader);
+    if (!Number.isNaN(retryAfterSeconds) && retryAfterSeconds >= 0) {
+        return retryAfterSeconds * 1000;
+    }
+    const retryAt = Date.parse(retryAfterHeader);
+    if (Number.isNaN(retryAt)) {
+        return null;
+    }
+    return Math.max(0, retryAt - Date.now());
+}
+function computeRetryDelay(attempt, retryAfterHeader) {
+    const retryAfterDelay = parseRetryAfterDelay(retryAfterHeader);
+    if (retryAfterDelay !== null) {
+        return Math.min(retryAfterDelay, MAX_DELAY_MS);
+    }
+    // 指数退避: 1s, 2s, 4s
+    const delay = BASE_DELAY_MS * Math.pow(2, attempt);
+    return Math.min(delay, MAX_DELAY_MS);
+}
+function sleep(ms) {
+    return new Promise(resolve => setTimeout(resolve, ms));
+}
+function parseJsonResponse(responseText) {
+    return JSON.parse(responseText);
+}
+function joinUrl(gateway, path) {
+    const normalizedGateway = gateway.endsWith('/') ? gateway.slice(0, -1) : gateway;
+    const normalizedPath = path.startsWith('/') ? path : `/${path}`;
+    return `${normalizedGateway}${normalizedPath}`;
+}
+/**
+ * 通用请求函数
+ *
+ * 支持灵活传递 gateway、路径、方法、参数、UA 等。
+ *
+ * 支持自动重试：
+ * - 429 (rate limit) 响应时重试，尊重 Retry-After header
+ * - 网络错误时重试，使用指数退避
+ */
+export async function request(options) {
+    const { gateway, path, method = 'GET', query, body, headers = {}, userAgent = `lxcli/${pkg.version}`, maxRetries = MAX_RETRIES, } = options;
+    // 构建 URL（gateway + path + query）
+    let url = joinUrl(gateway, path);
+    if (query && Object.keys(query).length > 0) {
+        const searchParams = new URLSearchParams(Object.fromEntries(Object.entries(query).map(([k, v]) => [k, String(v)])));
+        url += `?${searchParams.toString()}`;
+    }
+    // 构建 headers
+    const allHeaders = {
+        'Content-Type': 'application/json',
+        'User-Agent': userAgent,
+        ...headers,
+    };
+    const requestBody = body ? JSON.stringify(body) : undefined;
+    let lastError = null;
+    // 发送请求（带重试）
+    for (let attempt = 0; attempt < maxRetries; attempt++) {
+        try {
+            logger.debug('Request', { method, url, headers: allHeaders, body, attempt });
+            const response = await fetch(url, {
+                method,
+                headers: allHeaders,
+                body: requestBody,
+            });
+            const responseText = await response.text();
+            // 429 rate limit - 重试
+            if (response.status === 429) {
+                let errorResponse;
+                if (responseText) {
+                    try {
+                        errorResponse = parseJsonResponse(responseText);
+                    }
+                    catch {
+                        errorResponse = undefined;
+                    }
+                }
+                logger.debug('Response', { status: response.status, data: errorResponse ?? responseText, attempt });
+                if (attempt < maxRetries - 1) {
+                    const retryAfter = response.headers.get('Retry-After');
+                    const delay = computeRetryDelay(attempt, retryAfter ?? undefined);
+                    logger.info(`Rate limited (429), retrying after ${delay}ms (attempt ${attempt + 1}/${maxRetries})`);
+                    await sleep(delay);
+                    continue;
+                }
+                outputApiError(errorResponse?.error?.code || response.status, errorResponse?.error?.message || 'Request failed', errorResponse?.error?.details, response.status);
+            }
+            let responseData;
+            try {
+                responseData = parseJsonResponse(responseText);
+            }
+            catch {
+                outputApiError(response.status, `Invalid JSON response: ${responseText}`, undefined, response.status);
+            }
+            logger.debug('Response', { status: response.status, data: responseData, attempt });
+            if (!response.ok) {
+                const errorResponse = responseData;
+                outputApiError(errorResponse.error?.code || response.status, errorResponse.error?.message || 'Request failed', errorResponse.error?.details, response.status);
+            }
+            return responseData;
+        }
+        catch (error) {
+            // 网络错误 - 重试
+            const isNetworkError = error instanceof TypeError && (error.message.includes('fetch') ||
+                error.message.includes('network') ||
+                error.message.includes('ECONNREFUSED') ||
+                error.message.includes('ETIMEDOUT'));
+            if (isNetworkError && attempt < maxRetries - 1) {
+                const delay = computeRetryDelay(attempt);
+                logger.info(`Network error, retrying after ${delay}ms (attempt ${attempt + 1}/${maxRetries})`);
+                lastError = error;
+                await sleep(delay);
+                continue;
+            }
+            if (isNetworkError) {
+                logger.error('Request failed', error);
+                outputApiError(500, error.message, undefined, 500);
+            }
+            throw error;
+        }
+    }
+    // 所有重试都失败了
+    if (lastError) {
+        logger.error('All retries failed', lastError);
+        outputApiError(500, lastError.message, undefined, 500);
+    }
+    // 不应该到达这里，但 TypeScript 需要返回值
+    throw new Error('Request failed after all retries');
+}

package/dist/core/logger.d.ts

@@ -0,0 +1,24 @@
+import type { LogLevel } from '../types/index.js';
+/**
+ * 日志管理器
+ */
+export declare class Logger {
+    private static instance;
+    level: LogLevel;
+    private constructor();
+    static getInstance(): Logger;
+    setLevel(level: LogLevel): void;
+    /**
+     * 输出调试信息到 stderr
+     */
+    debug(message: string, data?: Record<string, unknown>): void;
+    /**
+     * 输出信息到 stderr
+     */
+    info(message: string): void;
+    /**
+     * 输出错误信息到 stderr
+     */
+    error(message: string, err?: Error): void;
+}
+export declare const logger: Logger;

package/dist/core/logger.js

@@ -0,0 +1,53 @@
+// src/core/logger.ts
+/**
+ * 日志管理器
+ */
+export class Logger {
+    static instance;
+    level = 'silent';
+    constructor() { }
+    static getInstance() {
+        if (!Logger.instance) {
+            Logger.instance = new Logger();
+        }
+        return Logger.instance;
+    }
+    setLevel(level) {
+        this.level = level;
+    }
+    /**
+     * 输出调试信息到 stderr
+     */
+    debug(message, data) {
+        if (this.level !== 'debug')
+            return;
+        const prefix = '[DEBUG]';
+        if (data) {
+            console.error(`${prefix} ${message}`, JSON.stringify(data, null, 2));
+        }
+        else {
+            console.error(`${prefix} ${message}`);
+        }
+    }
+    /**
+     * 输出信息到 stderr
+     */
+    info(message) {
+        if (this.level === 'silent')
+            return;
+        console.error(`[INFO] ${message}`);
+    }
+    /**
+     * 输出错误信息到 stderr
+     */
+    error(message, err) {
+        const prefix = '[ERROR]';
+        if (err) {
+            console.error(`${prefix} ${message}`, err.message);
+        }
+        else {
+            console.error(`${prefix} ${message}`);
+        }
+    }
+}
+export const logger = Logger.getInstance();

package/dist/core/reserved.d.ts

@@ -0,0 +1,13 @@
+/**
+ * 保留命令名（不可用于外部服务名）
+ */
+export declare const RESERVED_NAMES: readonly ["upgrade", "version", "help", "auth", "users", "tenants", "services", "config"];
+export type ReservedName = typeof RESERVED_NAMES[number];
+/**
+ * 验证服务名是否为保留名
+ */
+export declare function isReservedName(name: string): boolean;
+/**
+ * 验证服务名
+ */
+export declare function validateServiceName(name: string): void;

package/dist/core/reserved.js

@@ -0,0 +1,28 @@
+// src/core/reserved.ts
+/**
+ * 保留命令名（不可用于外部服务名）
+ */
+export const RESERVED_NAMES = [
+    'upgrade',
+    'version',
+    'help',
+    'auth',
+    'users',
+    'tenants',
+    'services',
+    'config',
+];
+/**
+ * 验证服务名是否为保留名
+ */
+export function isReservedName(name) {
+    return RESERVED_NAMES.includes(name);
+}
+/**
+ * 验证服务名
+ */
+export function validateServiceName(name) {
+    if (isReservedName(name)) {
+        throw new Error(`"${name}" is a reserved command name. Choose a different service name.`);
+    }
+}

package/dist/core/tenants.d.ts

@@ -0,0 +1,36 @@
+import type { TenantConfig, Env } from '../types/index.js';
+/**
+ * 服务配置类型
+ * 按企业、按环境配置 gateway
+ */
+export interface ServiceGatewayConfig {
+    name: string;
+    gateways: Record<string, Record<Env, string>>;
+}
+/**
+ * 注册服务配置到主体
+ */
+export declare function registerService(serviceConfig: ServiceGatewayConfig): void;
+/**
+ * 获取主体配置
+ */
+export declare function getTenant(name: string): TenantConfig | undefined;
+/**
+ * 获取所有主体名称
+ */
+export declare function getTenantNames(): string[];
+/**
+ * 列出所有主体
+ */
+export declare function listTenants(): TenantConfig[];
+/**
+ * 获取网关地址
+ * @param tenant 主体（企业）名称
+ * @param env 环境
+ * @param service 服务名称
+ */
+export declare function getGateway(tenant: string, env: Env, service: string): string | undefined;
+/**
+ * 检查主体是否存在
+ */
+export declare function tenantExists(name: string): boolean;

package/dist/core/tenants.js

@@ -0,0 +1,50 @@
+// src/core/tenants.ts
+/** 服务注册表：serviceName -> tenant -> env -> gateway */
+const SERVICE_REGISTRY = {};
+/**
+ * 内置主体配置
+ */
+const TENANTS = {
+    meet: { name: 'meet' },
+    co: { name: 'co' },
+    sky: { name: 'sky' },
+};
+/**
+ * 注册服务配置到主体
+ */
+export function registerService(serviceConfig) {
+    SERVICE_REGISTRY[serviceConfig.name] = serviceConfig.gateways;
+}
+/**
+ * 获取主体配置
+ */
+export function getTenant(name) {
+    return TENANTS[name];
+}
+/**
+ * 获取所有主体名称
+ */
+export function getTenantNames() {
+    return Object.keys(TENANTS);
+}
+/**
+ * 列出所有主体
+ */
+export function listTenants() {
+    return Object.values(TENANTS);
+}
+/**
+ * 获取网关地址
+ * @param tenant 主体（企业）名称
+ * @param env 环境
+ * @param service 服务名称
+ */
+export function getGateway(tenant, env, service) {
+    return SERVICE_REGISTRY[service]?.[tenant]?.[env];
+}
+/**
+ * 检查主体是否存在
+ */
+export function tenantExists(name) {
+    return name in TENANTS;
+}

package/dist/index.d.ts

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+export declare function normalizeCliArgv(argv: string[]): string[];

package/dist/index.js

@@ -0,0 +1,152 @@
+#!/usr/bin/env node
+// src/index.ts
+import { Command, CommanderError } from 'commander';
+import { outputCliError } from './core/error.js';
+import { logger } from './core/logger.js';
+import { registerAllCommands } from './commands/index.js';
+import pkg from '../package.json' with { type: 'json' };
+const program = new Command();
+export function normalizeCliArgv(argv) {
+    const normalized = [];
+    for (let i = 0; i < argv.length; i += 1) {
+        const arg = argv[i];
+        if (arg !== '--params') {
+            normalized.push(arg);
+            continue;
+        }
+        normalized.push(arg);
+        const value = argv[i + 1];
+        if (!value) {
+            continue;
+        }
+        if (!value.startsWith("'") || value.endsWith("'")) {
+            normalized.push(value);
+            i += 1;
+            continue;
+        }
+        const chunks = [value];
+        let endIndex = i + 1;
+        for (let j = i + 2; j < argv.length; j += 1) {
+            const chunk = argv[j];
+            if (chunk.startsWith('-') && !chunk.endsWith("'")) {
+                break;
+            }
+            chunks.push(chunk);
+            endIndex = j;
+            if (chunk.endsWith("'")) {
+                break;
+            }
+        }
+        normalized.push(chunks.join(' '));
+        i = endIndex;
+    }
+    return normalized;
+}
+// 设置基本信息
+program
+    .name('lxcli')
+    .description('连续科技命令行工具')
+    .version(pkg.version);
+// 无子命令时显示帮助
+program.action(() => {
+    program.outputHelp();
+    process.exitCode = 0;
+});
+// 全局选项
+program
+    .option('--debug', 'Enable debug mode')
+    .option('--verbose', 'Enable verbose output')
+    .hook('preAction', (thisCommand) => {
+    const options = thisCommand.opts();
+    if (options.debug) {
+        logger.setLevel('debug');
+    }
+    else if (options.verbose) {
+        logger.setLevel('info');
+    }
+});
+// 注册所有命令
+registerAllCommands(program);
+function getAuthInvocationState() {
+    const args = process.argv.slice(2);
+    const authIndex = args.indexOf('auth');
+    const authArgs = authIndex >= 0 ? args.slice(authIndex + 1) : [];
+    const positionals = [];
+    let hasTenant = false;
+    for (let i = 0; i < authArgs.length; i += 1) {
+        const arg = authArgs[i];
+        if (arg === '--tenant') {
+            hasTenant = true;
+            i += 1;
+            continue;
+        }
+        if (arg.startsWith('--tenant=')) {
+            hasTenant = true;
+            continue;
+        }
+        if (arg === '--gateway' || arg === '--env' || arg === '-e') {
+            i += 1;
+            continue;
+        }
+        if (!arg.startsWith('-')) {
+            positionals.push(arg);
+        }
+    }
+    return {
+        authArgs,
+        positionals,
+        hasTenant,
+    };
+}
+// 捕获 Commander 错误
+const setupErrorHandling = (cmd) => {
+    cmd.exitOverride((err) => {
+        // help 和 version 正常输出后退出
+        if (err.code === 'commander.help' || err.code === 'commander.version' || err.code === 'commander.helpDisplayed') {
+            process.exitCode = 0;
+            return;
+        }
+        if (cmd.name() === 'auth') {
+            const { authArgs, positionals, hasTenant } = getAuthInvocationState();
+            if (authArgs.length === 0) {
+                cmd.help({ error: false });
+            }
+            if (positionals.length === 0) {
+                outputCliError('PARAM_INVALID', `Missing required argument: name. Use 'lxcli auth --help' for usage.`);
+            }
+            if (positionals.length === 1) {
+                outputCliError('PARAM_INVALID', `Missing required argument: token. Use 'lxcli auth --help' for usage.`);
+            }
+            if (!hasTenant) {
+                outputCliError('PARAM_INVALID', `Missing required option: --tenant. Use 'lxcli auth --help' for usage.`);
+            }
+        }
+        const message = err.message.replace(/^error:\s*/i, '').trim();
+        outputCliError('PARAM_INVALID', message, {
+            source: 'commander',
+            commanderCode: err.code,
+        });
+    });
+    cmd.configureOutput({
+        writeErr: () => { },
+        // writeOut 保留默认，让 help 正常显示
+    });
+    cmd.commands.forEach((sub) => setupErrorHandling(sub));
+};
+setupErrorHandling(program);
+// 解析命令行参数
+program.parseAsync(normalizeCliArgv(process.argv)).catch((error) => {
+    if (error instanceof Error && error.message === 'Invalid JSON in --params') {
+        outputCliError('PARAM_INVALID', error.message);
+    }
+    else if (error instanceof CommanderError) {
+        const message = error.message.replace(/^error:\s*/i, '').trim();
+        outputCliError('PARAM_INVALID', message, {
+            source: 'commander',
+            commanderCode: error.code,
+        });
+    }
+    else {
+        outputCliError('UNKNOWN', error instanceof Error ? error.message : 'Unknown error');
+    }
+});

package/dist/types/index.d.ts

@@ -0,0 +1,59 @@
+import type { Command } from 'commander';
+/**
+ * 环境类型
+ */
+export declare const ENVIRONMENTS: readonly ["test", "pre", "staging", "beta", "prod"];
+export type Env = typeof ENVIRONMENTS[number];
+/**
+ * 主体配置（内置）
+ */
+export interface TenantConfig {
+    name: string;
+}
+/**
+ * 用户配置
+ */
+export interface UserConfig {
+    id: string;
+    name: string;
+    token: string;
+    tenant: string;
+    env: Env;
+    companyID?: number;
+    isDefault?: boolean;
+    disabled?: boolean;
+    createdAt: string;
+}
+/**
+ * 应用配置
+ */
+export interface AppConfig {
+    version: string;
+    users: UserConfig[];
+    currentUser?: string;
+}
+/**
+ * 服务命令接口
+ */
+export interface ServiceCommand {
+    name: string;
+    description: string;
+    /** 是否启用，默认 true。设为 false 时服务不注册到 CLI */
+    enabled?: boolean;
+    register(program: Command): void;
+}
+/**
+ * 错误响应格式
+ */
+export interface ErrorResponse {
+    error: {
+        code: number;
+        reason?: string;
+        message: string;
+        details?: Record<string, unknown>;
+    };
+}
+/**
+ * 日志级别
+ */
+export type LogLevel = 'silent' | 'info' | 'debug';

package/dist/types/index.js

@@ -0,0 +1,5 @@
+// src/types/index.ts
+/**
+ * 环境类型
+ */
+export const ENVIRONMENTS = ['test', 'pre', 'staging', 'beta', 'prod'];

package/dist/utils/index.d.ts

@@ -0,0 +1,20 @@
+export declare const LIST_FORMATS: readonly ["json", "table"];
+export type ListFormat = (typeof LIST_FORMATS)[number];
+export declare function parseCliParams(params?: string): Record<string, unknown> | unknown[];
+/**
+ * 合并简单参数和 --params
+ */
+export declare function mergeParams(options: Record<string, unknown>): Record<string, unknown>;
+/**
+ * 格式化日期
+ */
+export declare function formatDate(dateStr: string): string;
+/**
+ * 输出 JSON 结果
+ */
+export declare function outputJson(data: unknown): void;
+export declare function parseListFormat(format: string): ListFormat;
+/**
+ * 确认提示
+ */
+export declare function confirm(message: string): Promise<boolean>;