@meet-im/lxcli 0.0.1

package/LICENSE

@@ -0,0 +1,15 @@
+ISC License
+
+Copyright (c) 2025
+
+Permission to use, copy, modify, and/or distribute this software for any
+purpose with or without fee is hereby granted, provided that the above
+copyright notice and this permission notice appear in all copies.
+
+THE SOFTWARE IS PROVIDED "AS IS" AND THE AUTHOR DISCLAIMS ALL WARRANTIES WITH
+REGARD TO THIS SOFTWARE INCLUDING ALL IMPLIED WARRANTIES OF MERCHANTABILITY
+AND FITNESS. IN NO EVENT SHALL THE AUTHOR BE LIABLE FOR ANY SPECIAL, DIRECT,
+INDIRECT, OR CONSEQUENTIAL DAMAGES OR ANY DAMAGES WHATSOEVER RESULTING FROM
+LOSS OF USE, DATA OR PROFITS, WHETHER IN AN ACTION OF CONTRACT, NEGLIGENCE OR
+OTHER TORTIOUS ACTION, ARISING OUT OF OR IN CONNECTION WITH THE USE OR
+PERFORMANCE OF THIS SOFTWARE.

package/README.md

@@ -0,0 +1,3 @@
+# lxcli
+
+连续科技命令行工具。

package/bin/lxcli.js

@@ -0,0 +1,2 @@
+#!/usr/bin/env node
+import '../dist/index.js';

package/dist/commands/auth.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerAuthCommand(program: Command): void;

package/dist/commands/auth.js

@@ -0,0 +1,45 @@
+// src/commands/auth.ts
+import { addUser, getUserId } from '../core/config.js';
+import { tenantExists, listTenants, getTenantNames } from '../core/tenants.js';
+import { outputCliError } from '../core/error.js';
+import { outputJson } from '../utils/index.js';
+import { ENVIRONMENTS } from '../types/index.js';
+function parseEnv(value) {
+    if (!ENVIRONMENTS.includes(value)) {
+        outputCliError('PARAM_INVALID', `Invalid env: ${value}. Must be one of: ${ENVIRONMENTS.join(', ')}`, {
+            value,
+            validEnvs: [...ENVIRONMENTS],
+        });
+    }
+    return value;
+}
+export function registerAuthCommand(program) {
+    program
+        .command('auth <name> <token>')
+        .description('Add user authentication')
+        .requiredOption('--tenant <tenant>', `Tenant name (${getTenantNames().join(', ')})`)
+        .option('-e, --env <env>', `Environment (${ENVIRONMENTS.join(', ')})`, parseEnv, 'prod')
+        .option('--company <id>', 'Company ID (default: 1)', Number, 1)
+        .action((name, token, options) => {
+        const { tenant, env, company } = options;
+        if (!tenantExists(tenant)) {
+            outputCliError('PARAM_INVALID', `Unknown tenant: ${tenant}`, {
+                availableTenants: listTenants().map(t => t.name),
+            });
+        }
+        addUser({
+            id: '',
+            name,
+            token,
+            tenant,
+            env,
+            companyID: company,
+            createdAt: new Date().toISOString(),
+        });
+        const id = getUserId(name, tenant);
+        outputJson({
+            success: true,
+            message: `User "${id}" added successfully (${env})`,
+        });
+    });
+}

package/dist/commands/config.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerConfigCommand(program: Command): void;

package/dist/commands/config.js

@@ -0,0 +1,28 @@
+// src/commands/config.ts
+import { getConfigPath, loadConfig } from '../core/config.js';
+import { outputJson } from '../utils/index.js';
+export function registerConfigCommand(program) {
+    const configCmd = program
+        .command('config')
+        .description('Manage configuration')
+        .addHelpCommand()
+        .action(() => {
+        // 默认执行 path 子命令
+        outputJson({ path: getConfigPath() });
+    });
+    // 配置路径
+    configCmd
+        .command('path')
+        .description('Show config file path')
+        .action(() => {
+        outputJson({ path: getConfigPath() });
+    });
+    // 显示配置
+    configCmd
+        .command('show')
+        .description('Show current configuration')
+        .action(() => {
+        const config = loadConfig();
+        outputJson(config);
+    });
+}

package/dist/commands/generate-skills.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerGenerateSkillsCommand(program: Command): void;

package/dist/commands/generate-skills.js

@@ -0,0 +1,283 @@
+// src/commands/generate-skills.ts
+import { promises as fs } from 'fs';
+import * as path from 'path';
+import { outputCliError } from '../core/error.js';
+import { logger } from '../core/logger.js';
+import { PARAM_DEFS, METHOD_DESCRIPTIONS } from './services/kb/descriptions.js';
+const API_ROOT = path.resolve('api');
+const DEFAULT_SKILLS_DIR = path.resolve('api/skills');
+const DEFAULT_OUTPUT = 'api/docs/skills.md';
+// 分类配置：前缀 -> 分类名/描述
+const CATEGORY_CONFIG = {
+    'lxcli-builtin': { title: 'Builtin', description: 'lxcli 内置命令。' },
+    'kb-': { title: 'Kb', description: 'Kanboard 服务命令。' },
+    'meet-': { title: 'Meet', description: 'Meet 服务命令。' },
+    'meetbot-': { title: 'Meetbot', description: 'MeetBot 服务命令。' },
+};
+function getCategory(skillName) {
+    // 精确匹配 lxcli-builtin
+    if (skillName === 'lxcli-builtin') {
+        return 'builtin';
+    }
+    // 前缀匹配
+    for (const [prefix, _] of Object.entries(CATEGORY_CONFIG)) {
+        if (skillName.startsWith(prefix)) {
+            return CATEGORY_CONFIG[prefix].title.toLowerCase();
+        }
+    }
+    return 'other';
+}
+function parseFrontmatter(content) {
+    const fmMatch = content.match(/^---\n([\s\S]*?)\n---/);
+    if (!fmMatch) {
+        return null;
+    }
+    const fm = fmMatch[1];
+    const nameMatch = fm.match(/^name:\s*["']?([^"'\n]+)["']?/m);
+    const descMatch = fm.match(/^description:\s*["'](.+)["']/m);
+    if (!nameMatch || !descMatch) {
+        return null;
+    }
+    return {
+        name: nameMatch[1].trim(),
+        description: descMatch[1].trim(),
+    };
+}
+async function scanSkills(skillsDir) {
+    const entries = [];
+    try {
+        const dirs = await fs.readdir(skillsDir, { withFileTypes: true });
+        for (const dir of dirs) {
+            if (!dir.isDirectory())
+                continue;
+            const skillPath = path.join(skillsDir, dir.name, 'SKILL.md');
+            try {
+                const content = await fs.readFile(skillPath, 'utf-8');
+                const meta = parseFrontmatter(content);
+                if (meta) {
+                    entries.push({
+                        name: meta.name,
+                        description: meta.description,
+                        category: getCategory(meta.name),
+                    });
+                }
+                else {
+                    logger.info(`Failed to parse frontmatter: ${skillPath}`);
+                }
+            }
+            catch {
+                // SKILL.md not found, skip
+            }
+        }
+    }
+    catch (err) {
+        throw new Error(`Failed to read skills directory: ${skillsDir}`);
+    }
+    // 按分类排序，同类按名称排序
+    const categoryOrder = ['builtin', 'kb', 'meet', 'meetbot', 'other'];
+    entries.sort((a, b) => {
+        const catA = categoryOrder.indexOf(a.category);
+        const catB = categoryOrder.indexOf(b.category);
+        if (catA !== catB)
+            return catA - catB;
+        return a.name.localeCompare(b.name);
+    });
+    return entries;
+}
+function renderIndex(entries) {
+    const lines = [
+        '# Skills Index',
+        '',
+        '> Auto-generated by `lxcli generate-skills`. Do not edit manually.',
+        '',
+    ];
+    // 按分类分组
+    const grouped = {};
+    for (const entry of entries) {
+        if (!grouped[entry.category]) {
+            grouped[entry.category] = [];
+        }
+        grouped[entry.category].push(entry);
+    }
+    // 渲染各分类
+    const categoryMeta = {
+        builtin: CATEGORY_CONFIG['lxcli-builtin'],
+        kb: CATEGORY_CONFIG['kb-'],
+        meet: CATEGORY_CONFIG['meet-'],
+        meetbot: CATEGORY_CONFIG['meetbot-'],
+        other: { title: 'Other', description: '其他命令。' },
+    };
+    for (const [cat, items] of Object.entries(grouped)) {
+        const meta = categoryMeta[cat] || { title: cat, description: '' };
+        lines.push(`## ${meta.title}`, '', meta.description, '');
+        lines.push('| Skill | Description |');
+        lines.push('|-------|-------------|');
+        for (const item of items) {
+            lines.push(`| [${item.name}](../skills/${item.name}/SKILL.md) | ${item.description} |`);
+        }
+        lines.push('');
+    }
+    return lines.join('\n');
+}
+// ---------------------------------------------------------------------------
+// SKILL.md 生成
+// ---------------------------------------------------------------------------
+function renderParamType(type) {
+    const typeMap = {
+        'integer': 'integer',
+        'string': 'string',
+        'array<integer>': 'integer[]',
+        'array<string>': 'string[]',
+        'object': 'object',
+        'file': 'string (base64)',
+    };
+    return typeMap[type] || type;
+}
+function renderParamsTable(params) {
+    if (params.length === 0)
+        return '';
+    const lines = [
+        '## Parameters',
+        '',
+        '| 参数 | 类型 | 必填 | 说明 |',
+        '|------|------|------|------|',
+    ];
+    for (const p of params) {
+        const required = p.required ? '✓' : '';
+        lines.push(`| ${p.name} | ${renderParamType(p.type)} | ${required} | ${p.description} |`);
+    }
+    lines.push('');
+    return lines.join('\n');
+}
+function renderSkillMd(method) {
+    const description = METHOD_DESCRIPTIONS[method];
+    const params = PARAM_DEFS[method] || [];
+    const skillName = `kb-${method}`;
+    const hasParams = params.length > 0;
+    // 快捷参数列表
+    const shortcuts = params.filter(p => p.required).map(p => `--${p.name} <${p.type === 'integer' ? 'ID' : 'VALUE'}>`);
+    const shortcutUsage = shortcuts.length > 0 ? `lxcli kb ${method} ${shortcuts.join(' ')}` : '';
+    // Usage 部分
+    const usageLines = ['## Usage', '', '```bash'];
+    if (hasParams) {
+        if (shortcutUsage) {
+            usageLines.push(shortcutUsage);
+        }
+        // 生成 --params 示例
+        const paramsExample = {};
+        for (const p of params) {
+            if (p.type === 'array<integer>') {
+                paramsExample[p.name] = [1, 2];
+            }
+            else if (p.type === 'array<string>') {
+                paramsExample[p.name] = ['id1', 'id2'];
+            }
+            else if (p.type === 'integer') {
+                paramsExample[p.name] = 123;
+            }
+            else if (p.type === 'object') {
+                paramsExample[p.name] = {};
+            }
+            else {
+                paramsExample[p.name] = 'value';
+            }
+        }
+        usageLines.push(`lxcli kb ${method} --params '${JSON.stringify(paramsExample)}'`);
+    }
+    else {
+        usageLines.push(`lxcli kb ${method}`);
+    }
+    usageLines.push('```', '');
+    // 快捷参数说明
+    if (hasParams && shortcutUsage) {
+        usageLines.push(`快捷参数使用见上方；\`--params\` 用于完整参数场景。若同时传入，CLI 优先使用 \`--params\`。`, '');
+    }
+    // 组装 SKILL.md
+    const frontmatter = `---
+name: ${skillName}
+description: "Kanboard: ${description}"
+metadata:
+  version: 1.0.0
+  openclaw:
+    category: "productivity"
+    requires:
+      bins:
+        - lxcli
+    cliHelp: "lxcli kb ${method} --help"
+---`;
+    const lines = [
+        frontmatter,
+        '',
+        `# kb ${method}`,
+        '',
+        description + '。',
+        '',
+        ...usageLines,
+    ];
+    if (hasParams) {
+        lines.push(renderParamsTable(params));
+    }
+    lines.push('## Examples', '', '```bash', shortcutUsage || `lxcli kb ${method}`, '```', '');
+    return lines.join('\n');
+}
+async function generateServiceSkills(skillsDir, serviceName) {
+    // 目前只支持 kb 服务
+    if (serviceName !== 'kb') {
+        logger.info(`Service "${serviceName}" is not supported. Supported services: kb`);
+        return;
+    }
+    const methods = Object.keys(PARAM_DEFS);
+    for (const method of methods) {
+        const skillName = `${serviceName}-${method}`;
+        const skillDir = path.join(skillsDir, skillName);
+        const skillPath = path.join(skillDir, 'SKILL.md');
+        // 检查是否已有手写的 SKILL.md
+        try {
+            await fs.access(skillPath);
+            logger.info(`Skipped ${skillName}: SKILL.md already exists`);
+            continue;
+        }
+        catch {
+            // 不存在，生成新的
+        }
+        await fs.mkdir(skillDir, { recursive: true });
+        const content = renderSkillMd(method);
+        await fs.writeFile(skillPath, content, 'utf-8');
+        logger.info(`Generated ${skillName}/SKILL.md`);
+    }
+}
+export function registerGenerateSkillsCommand(program) {
+    program
+        .command('generate-skills')
+        .description('生成 skills 索引文件')
+        .option('-o, --output <path>', '输出文件路径', DEFAULT_OUTPUT)
+        .option('-s, --service <name>', '为指定服务生成缺失的 SKILL.md 文件（如 kb, meet）')
+        .action(async (options) => {
+        try {
+            const stat = await fs.stat(API_ROOT);
+            if (!stat.isDirectory()) {
+                outputCliError('PARAM_INVALID', 'api submodule is not initialized. Run git submodule update --init --recursive first.');
+            }
+        }
+        catch {
+            outputCliError('PARAM_INVALID', 'api submodule is not initialized. Run git submodule update --init --recursive first.');
+        }
+        const skillsDir = DEFAULT_SKILLS_DIR;
+        const outputPath = path.resolve(options.output);
+        await fs.mkdir(skillsDir, { recursive: true });
+        logger.info(`Scanning skills from ${skillsDir}`);
+        // 如果指定了 --service，先生成缺失的 SKILL.md
+        if (options.service) {
+            logger.info(`Generating missing ${options.service} SKILL.md files...`);
+            await generateServiceSkills(skillsDir, options.service);
+        }
+        const entries = await scanSkills(skillsDir);
+        logger.info(`Found ${entries.length} skills`);
+        const content = renderIndex(entries);
+        // 确保输出目录存在
+        const outputDir = path.dirname(outputPath);
+        await fs.mkdir(outputDir, { recursive: true });
+        await fs.writeFile(outputPath, content, 'utf-8');
+        console.log(JSON.stringify({ generated: outputPath, count: entries.length }, null, 2));
+    });
+}

package/dist/commands/index.d.ts

@@ -0,0 +1,9 @@
+import type { Command } from 'commander';
+import type { ServiceCommand } from '../types/index.js';
+export interface BuiltInCommand {
+    name: string;
+    register(program: Command): void;
+}
+export declare const builtInCommands: BuiltInCommand[];
+export declare const externalServices: ServiceCommand[];
+export declare function registerAllCommands(program: Command): void;

package/dist/commands/index.js

@@ -0,0 +1,43 @@
+// src/commands/index.ts
+import { configureHelp } from '../core/help.js';
+import { registerAuthCommand } from './auth.js';
+import { registerUsersCommand } from './users.js';
+import { registerTenantsCommand } from './tenants.js';
+import { registerServicesCommand } from './services.js';
+import { registerConfigCommand } from './config.js';
+import { registerUpgradeCommand } from './upgrade.js';
+import { registerGenerateSkillsCommand } from './generate-skills.js';
+import { registerSchemaCommand } from './schema.js';
+import kbService from './services/kb/index.js';
+import meetbotService from './services/meetbot/index.js';
+import meetService from './services/meet/index.js';
+export const builtInCommands = [
+    { name: 'auth', register: registerAuthCommand },
+    { name: 'users', register: registerUsersCommand },
+    { name: 'tenants', register: registerTenantsCommand },
+    { name: 'services', register: registerServicesCommand },
+    { name: 'config', register: registerConfigCommand },
+    { name: 'upgrade', register: registerUpgradeCommand },
+    { name: 'generate-skills', register: registerGenerateSkillsCommand },
+    { name: 'schema', register: registerSchemaCommand },
+];
+export const externalServices = [
+    kbService,
+    meetbotService,
+    meetService,
+];
+export function registerAllCommands(program) {
+    // 注册内置命令
+    builtInCommands.forEach(({ register }) => {
+        register(program);
+    });
+    // 过滤启用的服务
+    const enabledServices = externalServices.filter(service => service.enabled !== false);
+    // 注册服务命令（hidden: 不在默认 Commands 列表中显示，但仍可使用）
+    enabledServices.forEach((service) => {
+        const cmd = program.command(service.name, { hidden: true });
+        service.register(cmd);
+    });
+    // 配置自定义帮助：在 Commands 后追加 Services 分组
+    configureHelp(program, enabledServices);
+}

package/dist/commands/schema.d.ts

@@ -0,0 +1,2 @@
+import { Command } from 'commander';
+export declare function registerSchemaCommand(program: Command): void;

package/dist/commands/schema.js

@@ -0,0 +1,37 @@
+import { outputCliError } from '../core/error.js';
+import { METHOD_DESCRIPTIONS, METHODS, PARAM_DEFS } from './services/kb/descriptions.js';
+const SORTED_METHODS = [...METHODS].sort();
+export function registerSchemaCommand(program) {
+    program
+        .command('schema')
+        .description('查看服务方法参数 schema')
+        .argument('<service>', 'Service name')
+        .argument('[method]', 'Method name')
+        .action((service, method) => {
+        if (service !== 'kb') {
+            outputCliError('SERVICE_NOT_FOUND', `Schema for service "${service}" is not supported`, { service });
+        }
+        if (!method) {
+            const methods = SORTED_METHODS.map((name) => ({
+                name,
+                description: METHOD_DESCRIPTIONS[name],
+                paramsCount: PARAM_DEFS[name]?.length ?? 0,
+            }));
+            console.log(JSON.stringify({ service: 'kb', methods }, null, 2));
+            return;
+        }
+        if (!METHODS.includes(method)) {
+            outputCliError('PARAM_INVALID', `Method "${method}" not found for service "kb"`, {
+                service: 'kb',
+                method,
+                availableMethods: SORTED_METHODS,
+            });
+        }
+        console.log(JSON.stringify({
+            service: 'kb',
+            method,
+            description: METHOD_DESCRIPTIONS[method],
+            params: PARAM_DEFS[method] ?? [],
+        }, null, 2));
+    });
+}

package/dist/commands/services/kb/config.d.ts

@@ -0,0 +1,2 @@
+import type { ServiceGatewayConfig } from '../../../core/tenants.js';
+export declare const kbConfig: ServiceGatewayConfig;

package/dist/commands/services/kb/config.js

@@ -0,0 +1,32 @@
+// src/commands/services/kb/config.ts
+// kanboard gateway 配置（按企业、按环境）
+// 实际地址需要根据部署环境配置
+const meetGateways = {
+    test: 'https://kanboard-test.miyachat.com',
+    pre: 'https://kanboard-pre.miyachat.com',
+    staging: 'https://kanboard-staging.miyachat.com',
+    beta: 'https://kanboard-beta.miyachat.com',
+    prod: 'https://kanboard.miyachat.com',
+};
+const coGateways = {
+    test: 'https://kanboard-test.co.example.com',
+    pre: 'https://kanboard-pre.co.example.com',
+    staging: 'https://kanboard-staging.co.example.com',
+    beta: 'https://kanboard-beta.co.example.com',
+    prod: 'https://kanboard.co.example.com',
+};
+const skyGateways = {
+    test: 'https://kanboard-test.sky.example.com',
+    pre: 'https://kanboard-pre.sky.example.com',
+    staging: 'https://kanboard-staging.sky.example.com',
+    beta: 'https://kanboard-beta.sky.example.com',
+    prod: 'https://kanboard.sky.example.com',
+};
+export const kbConfig = {
+    name: 'kb',
+    gateways: {
+        meet: meetGateways,
+        co: coGateways,
+        sky: skyGateways,
+    },
+};

package/dist/commands/services/kb/descriptions.d.ts

@@ -0,0 +1,4 @@
+export declare const METHODS: readonly string[];
+export type Method = typeof METHODS[number];
+export declare const METHOD_DESCRIPTIONS: Record<Method, string>;
+export { PARAM_DEFS, type ParamDef, type ParamType } from './params.js';

package/dist/commands/services/kb/descriptions.js

@@ -0,0 +1,24 @@
+// src/commands/services/kb/descriptions.ts
+//
+// 方法列表和描述，参数定义见 params.ts
+import { PARAM_DEFS } from './params.js';
+// 方法列表（从 PARAM_DEFS 自动推导）
+export const METHODS = Object.keys(PARAM_DEFS);
+// 方法描述
+export const METHOD_DESCRIPTIONS = {
+    getMe: '获取当前用户信息',
+    getMyProjects: '获取我的项目列表',
+    getTask: '获取需求/bug 明细',
+    queryUsers: '获取用户信息',
+    searchTasks: '搜索需求/bug 列表',
+    getAllActiveIterations: '获取启用迭代列表',
+    createTask: '创建需求/bug',
+    createSubtask: '创建子任务',
+    updateTask: '修改需求',
+    getAllComments: '获取评论列表',
+    createComment: '对需求增加评论',
+    createProjectFile: '上传附件到项目',
+    createTaskFile: '上传附件到需求',
+};
+// 重新导出 params.ts 的类型和定义，方便其他模块使用
+export { PARAM_DEFS } from './params.js';

package/dist/commands/services/kb/handler.d.ts

@@ -0,0 +1,12 @@
+import type { Method } from './descriptions.js';
+export interface KbCommandOptions {
+    params?: string;
+    task_id?: string;
+    title?: string;
+    project_id?: string;
+    query?: string;
+    user?: string;
+    gateway?: string;
+    file?: string;
+}
+export declare function createKbAction(method: Method): (options: KbCommandOptions) => Promise<void>;