@meet-im/lxcli 0.0.1

package/dist/utils/index.js

@@ -0,0 +1,133 @@
+// src/utils/index.ts
+import * as readline from 'readline';
+import JSON5 from 'json5';
+import { outputCliError } from '../core/error.js';
+import { parseLooseParams } from './loose-params.js';
+export const LIST_FORMATS = ['json', 'table'];
+const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function buildParamsParseError(params) {
+    const base = `Invalid JSON in --params: ${params}`;
+    if (process.platform !== 'win32') {
+        return new Error(base);
+    }
+    return new Error(`${base}\nHint: Windows PowerShell 5.x may strip quotes inside JSON. Try escaping inner double quotes, switching to pwsh, or using --params-file.`);
+}
+function ensureSafeParams(value) {
+    if (!value || typeof value !== 'object') {
+        return;
+    }
+    if (Array.isArray(value)) {
+        for (const item of value) {
+            ensureSafeParams(item);
+        }
+        return;
+    }
+    for (const [key, nested] of Object.entries(value)) {
+        if (DANGEROUS_KEYS.has(key)) {
+            throw new Error(`Invalid JSON in --params: dangerous key ${key}`);
+        }
+        ensureSafeParams(nested);
+    }
+}
+export function parseCliParams(params) {
+    if (!params) {
+        return {};
+    }
+    // PowerShell 可能传来的值被单引号包裹：'{task_id:123}' 或 '{"task_id":123}'
+    // 去掉外层单引号
+    if (params.startsWith("'") && params.endsWith("'")) {
+        params = params.slice(1, -1);
+    }
+    let parsed;
+    try {
+        parsed = JSON.parse(params);
+    }
+    catch {
+        try {
+            parsed = JSON5.parse(params);
+        }
+        catch {
+            try {
+                parsed = parseLooseParams(params);
+            }
+            catch {
+                throw buildParamsParseError(params);
+            }
+        }
+    }
+    ensureSafeParams(parsed);
+    if (Array.isArray(parsed)) {
+        return parsed;
+    }
+    if (parsed === null || typeof parsed !== 'object') {
+        throw new Error('--params must be a JSON object or array');
+    }
+    return parsed;
+}
+/**
+ * 合并简单参数和 --params
+ */
+export function mergeParams(options) {
+    const { params, user, _, ...flags } = options;
+    let jsonParams = {};
+    if (params && typeof params === 'string') {
+        try {
+            const parsed = parseCliParams(params);
+            if (Array.isArray(parsed)) {
+                throw new Error('--params must be a JSON object');
+            }
+            jsonParams = parsed;
+        }
+        catch (error) {
+            throw error instanceof Error ? error : new Error('Invalid JSON in --params');
+        }
+    }
+    // 过滤掉 undefined 值
+    const cleanFlags = Object.fromEntries(Object.entries(flags).filter(([, v]) => v !== undefined));
+    // --params 覆盖同名简单参数
+    return { ...cleanFlags, ...jsonParams };
+}
+/**
+ * 格式化日期
+ */
+export function formatDate(dateStr) {
+    const date = new Date(dateStr);
+    return date.toLocaleString('zh-CN', {
+        year: 'numeric',
+        month: '2-digit',
+        day: '2-digit',
+        hour: '2-digit',
+        minute: '2-digit',
+        second: '2-digit',
+    });
+}
+/**
+ * 输出 JSON 结果
+ */
+export function outputJson(data) {
+    console.log(JSON.stringify(data, null, 2));
+}
+export function parseListFormat(format) {
+    if (LIST_FORMATS.includes(format)) {
+        return format;
+    }
+    outputCliError('PARAM_INVALID', `Invalid format: ${format}. Must be one of: ${LIST_FORMATS.join(', ')}`, {
+        value: format,
+        validFormats: [...LIST_FORMATS],
+    });
+}
+/**
+ * 确认提示
+ */
+export async function confirm(message) {
+    const rl = readline.createInterface({
+        input: process.stdin,
+        output: process.stdout,
+    });
+    return new Promise((resolve) => {
+        rl.question(`${message} (y/N) `, (answer) => {
+            rl.close();
+            resolve(answer.toLowerCase() === 'y');
+        });
+    });
+}

package/dist/utils/loose-params.d.ts

@@ -0,0 +1,9 @@
+type TokenType = '{' | '}' | '[' | ']' | ':' | ',' | 'STRING' | 'BARE' | 'NUMBER' | 'BOOLEAN' | 'NULL';
+interface Token {
+    type: TokenType;
+    value: string;
+    pos: number;
+}
+export declare function tokenize(input: string): Token[];
+export declare function parseLooseParams(input: string): Record<string, unknown> | unknown[];
+export type { Token };

package/dist/utils/loose-params.js

@@ -0,0 +1,274 @@
+const DANGEROUS_KEYS = new Set(['__proto__', 'constructor', 'prototype']);
+function isWhitespace(ch) {
+    return ch === ' ' || ch === '\t' || ch === '\n' || ch === '\r';
+}
+function isStructuralChar(ch) {
+    return ch === '{' || ch === '}' || ch === '[' || ch === ']' || ch === ':' || ch === ',';
+}
+function isValueTerminator(ch) {
+    return ch === undefined || isWhitespace(ch) || ch === ',' || ch === '}' || ch === ']';
+}
+function isBareChar(ch) {
+    return !isWhitespace(ch)
+        && !isStructuralChar(ch)
+        && ch !== '"'
+        && ch !== '\'';
+}
+export function tokenize(input) {
+    const tokens = [];
+    let i = 0;
+    while (i < input.length) {
+        const ch = input[i];
+        if (isWhitespace(ch)) {
+            i += 1;
+            continue;
+        }
+        if (isStructuralChar(ch)) {
+            tokens.push({ type: ch, value: ch, pos: i });
+            i += 1;
+            continue;
+        }
+        if (ch === '"' || ch === "'") {
+            const quote = ch;
+            let j = i + 1;
+            let str = '';
+            let closed = false;
+            while (j < input.length) {
+                if (input[j] === '\\' && j + 1 < input.length) {
+                    str += input[j + 1];
+                    j += 2;
+                    continue;
+                }
+                if (input[j] === quote) {
+                    closed = true;
+                    j += 1;
+                    break;
+                }
+                str += input[j];
+                j += 1;
+            }
+            if (!closed) {
+                throw new Error(`Unterminated string at position ${i}`);
+            }
+            tokens.push({ type: 'STRING', value: str, pos: i });
+            i = j;
+            continue;
+        }
+        if ((ch === '-' && i + 1 < input.length && input[i + 1] >= '0' && input[i + 1] <= '9')
+            || (ch >= '0' && ch <= '9')) {
+            let j = i;
+            if (input[j] === '-') {
+                j += 1;
+            }
+            while (j < input.length && input[j] >= '0' && input[j] <= '9') {
+                j += 1;
+            }
+            if (input[j] === '.' && j + 1 < input.length && input[j + 1] >= '0' && input[j + 1] <= '9') {
+                j += 1;
+                while (j < input.length && input[j] >= '0' && input[j] <= '9') {
+                    j += 1;
+                }
+            }
+            if (isValueTerminator(input[j])) {
+                tokens.push({ type: 'NUMBER', value: input.slice(i, j), pos: i });
+                i = j;
+                continue;
+            }
+        }
+        if (isBareChar(ch)) {
+            let j = i;
+            while (j < input.length && isBareChar(input[j])) {
+                j += 1;
+            }
+            const value = input.slice(i, j);
+            if (value === 'true' || value === 'false') {
+                tokens.push({ type: 'BOOLEAN', value, pos: i });
+            }
+            else if (value === 'null') {
+                tokens.push({ type: 'NULL', value, pos: i });
+            }
+            else {
+                tokens.push({ type: 'BARE', value, pos: i });
+            }
+            i = j;
+            continue;
+        }
+        throw new Error(`Unexpected character '${ch}' at position ${i}`);
+    }
+    return tokens;
+}
+class ParseError extends Error {
+    pos;
+    constructor(message, pos) {
+        super(`${message} at position ${pos}`);
+        this.pos = pos;
+        this.name = 'ParseError';
+    }
+}
+class Parser {
+    tokens;
+    idx;
+    constructor(tokens, idx = 0) {
+        this.tokens = tokens;
+        this.idx = idx;
+    }
+    peek() {
+        return this.tokens[this.idx];
+    }
+    advance() {
+        const token = this.tokens[this.idx];
+        if (!token) {
+            throw new ParseError('Unexpected end of input', this.tokens.length);
+        }
+        this.idx += 1;
+        return token;
+    }
+    expect(type) {
+        const token = this.peek();
+        if (!token) {
+            throw new ParseError(`Expected ${type} but got end of input`, this.tokens.length);
+        }
+        if (token.type !== type) {
+            throw new ParseError(`Expected ${type} but got ${token.type}`, token.pos);
+        }
+        return this.advance();
+    }
+    parse() {
+        const token = this.peek();
+        if (!token) {
+            throw new ParseError('Empty input', 0);
+        }
+        const result = token.type === '{'
+            ? this.parseObject()
+            : token.type === '['
+                ? this.parseArray()
+                : (() => { throw new ParseError(`Expected '{' or '[' but got ${token.type}`, token.pos); })();
+        const extra = this.peek();
+        if (extra) {
+            throw new ParseError(`Unexpected trailing token ${extra.type}`, extra.pos);
+        }
+        return result;
+    }
+    parseValue() {
+        const token = this.peek();
+        if (!token) {
+            throw new ParseError('Expected value but got end of input', this.tokens.length);
+        }
+        switch (token.type) {
+            case '{':
+                return this.parseObject();
+            case '[':
+                return this.parseArray();
+            case 'STRING':
+                this.advance();
+                return token.value;
+            case 'NUMBER':
+                return this.parseBareLikeValue();
+            case 'BOOLEAN':
+                return this.parseBareLikeValue();
+            case 'NULL':
+                return this.parseBareLikeValue();
+            case 'BARE':
+                return this.parseBareLikeValue();
+            default:
+                throw new ParseError(`Unexpected token ${token.type}`, token.pos);
+        }
+    }
+    parseBareLikeValue() {
+        const first = this.advance();
+        const parts = [first.value];
+        while (this.peek()?.type === ':') {
+            this.advance();
+            const next = this.peek();
+            if (!next || (next.type !== 'BARE' && next.type !== 'NUMBER' && next.type !== 'BOOLEAN' && next.type !== 'NULL')) {
+                throw new ParseError(`Expected value token after ':'`, this.peek()?.pos ?? this.tokens.length);
+            }
+            parts.push(':', this.advance().value);
+        }
+        if (parts.length > 1) {
+            return parts.join('');
+        }
+        switch (first.type) {
+            case 'NUMBER':
+                return Number(first.value);
+            case 'BOOLEAN':
+                return first.value === 'true';
+            case 'NULL':
+                return null;
+            case 'BARE':
+                return first.value;
+            default:
+                throw new ParseError(`Unexpected token ${first.type}`, first.pos);
+        }
+    }
+    parseObject() {
+        this.expect('{');
+        const result = {};
+        if (this.peek()?.type === '}') {
+            this.advance();
+            return result;
+        }
+        while (true) {
+            const keyToken = this.peek();
+            if (!keyToken) {
+                throw new ParseError('Expected key but got end of input', this.tokens.length);
+            }
+            if (keyToken.type !== 'BARE' && keyToken.type !== 'STRING') {
+                throw new ParseError(`Expected key but got ${keyToken.type}`, keyToken.pos);
+            }
+            const key = this.advance().value;
+            if (DANGEROUS_KEYS.has(key)) {
+                throw new ParseError(`Disallowed key ${key}`, keyToken.pos);
+            }
+            this.expect(':');
+            result[key] = this.parseValue();
+            const sep = this.peek();
+            if (!sep) {
+                throw new ParseError(`Expected ',' or '}' but got end of input`, this.tokens.length);
+            }
+            if (sep.type === ',') {
+                this.advance();
+                continue;
+            }
+            if (sep.type === '}') {
+                this.advance();
+                return result;
+            }
+            throw new ParseError(`Expected ',' or '}' but got ${sep.type}`, sep.pos);
+        }
+    }
+    parseArray() {
+        this.expect('[');
+        const result = [];
+        if (this.peek()?.type === ']') {
+            this.advance();
+            return result;
+        }
+        while (true) {
+            result.push(this.parseValue());
+            const sep = this.peek();
+            if (!sep) {
+                throw new ParseError(`Expected ',' or ']' but got end of input`, this.tokens.length);
+            }
+            if (sep.type === ',') {
+                this.advance();
+                continue;
+            }
+            if (sep.type === ']') {
+                this.advance();
+                return result;
+            }
+            throw new ParseError(`Expected ',' or ']' but got ${sep.type}`, sep.pos);
+        }
+    }
+}
+export function parseLooseParams(input) {
+    const trimmed = input.trim();
+    if (!trimmed.startsWith('{') && !trimmed.startsWith('[')) {
+        throw new Error('Input must start with { or [');
+    }
+    const result = new Parser(tokenize(trimmed)).parse();
+    return Array.isArray(result)
+        ? result
+        : result;
+}

package/dist/utils/table.d.ts

@@ -0,0 +1,4 @@
+/**
+ * 格式化表格输出
+ */
+export declare function formatTable(rows: Record<string, unknown>[], columns: string[]): string;

package/dist/utils/table.js

@@ -0,0 +1,25 @@
+// src/utils/table.ts
+/**
+ * 格式化表格输出
+ */
+export function formatTable(rows, columns) {
+    if (rows.length === 0)
+        return '';
+    // 计算每列最大宽度（表头 + 数据）
+    const widths = {};
+    for (const col of columns) {
+        const dataWidth = Math.max(...rows.map(r => String(r[col] ?? '').length));
+        widths[col] = Math.max(col.length, dataWidth);
+    }
+    // 表头
+    const header = columns
+        .map(col => col.toUpperCase().padEnd(widths[col]))
+        .join('  ');
+    // 分隔线
+    const separator = columns.map(col => '-'.repeat(widths[col])).join('  ');
+    // 数据行
+    const body = rows
+        .map(row => columns.map(col => String(row[col] ?? '').padEnd(widths[col])).join('  '))
+        .join('\n');
+    return `${header}\n${separator}\n${body}`;
+}

package/package.json

@@ -0,0 +1,46 @@
+{
+  "name": "@meet-im/lxcli",
+  "version": "0.0.1",
+  "description": "连续科技命令行工具",
+  "type": "module",
+  "main": "dist/index.js",
+  "bin": {
+    "lxcli": "./bin/lxcli.js"
+  },
+  "scripts": {
+    "build": "tsc --build",
+    "dev": "tsc --watch",
+    "clean": "tsc --build --clean",
+    "typecheck": "tsc --noEmit",
+    "verify": "pnpm typecheck && pnpm test",
+    "prepare": "husky",
+    "test": "vitest run",
+    "test:watch": "vitest",
+    "test:coverage": "vitest run --coverage"
+  },
+  "engines": {
+    "node": ">=22.0.0"
+  },
+  "files": [
+    "dist",
+    "bin"
+  ],
+  "keywords": [
+    "cli",
+    "lxcli"
+  ],
+  "author": "",
+  "license": "ISC",
+  "packageManager": "pnpm@10.32.0",
+  "dependencies": {
+    "commander": "^14.0.3",
+    "json5": "^2.2.3",
+    "uuid": "^14.0.0"
+  },
+  "devDependencies": {
+    "@types/node": "^25.8.0",
+    "husky": "^9.1.7",
+    "typescript": "^6.0.3",
+    "vitest": "^4.1.6"
+  }
+}