mulby-cli 1.1.5

package/dist/commands/dev.js

@@ -0,0 +1,141 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.dev = dev;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const esbuild = __importStar(require("esbuild"));
+const chalk_1 = __importDefault(require("chalk"));
+const child_process_1 = require("child_process");
+let viteProcess = null;
+async function dev() {
+    const cwd = process.cwd();
+    const manifestPath = path.join(cwd, 'manifest.json');
+    if (!fs.existsSync(manifestPath)) {
+        console.log(chalk_1.default.red('错误: 未找到 manifest.json'));
+        process.exit(1);
+    }
+    const manifest = fs.readJsonSync(manifestPath);
+    const hasUI = !!manifest.ui;
+    const entryPoint = path.join(cwd, 'src/main.ts');
+    console.log(chalk_1.default.blue('启动开发模式...'));
+    console.log();
+    // 确保 dist 目录存在
+    fs.ensureDirSync(path.join(cwd, 'dist'));
+    // 1. 启动后端监听
+    if (fs.existsSync(entryPoint)) {
+        await startBackendWatch(cwd, entryPoint);
+    }
+    // 2. 启动 UI 开发服务器（如果有）
+    if (hasUI) {
+        await startViteDevServer(cwd);
+    }
+    console.log();
+    console.log(chalk_1.default.gray('按 Ctrl+C 退出'));
+    // 处理退出
+    process.on('SIGINT', cleanup);
+    process.on('SIGTERM', cleanup);
+}
+async function startBackendWatch(cwd, entryPoint) {
+    const ctx = await esbuild.context({
+        entryPoints: [entryPoint],
+        bundle: true,
+        platform: 'node',
+        outfile: path.join(cwd, 'dist/main.js'),
+        sourcemap: true
+    });
+    await ctx.watch();
+    console.log(chalk_1.default.green('✓ 后端监听已启动'));
+    // 监听文件变化并输出日志
+    const chokidar = await Promise.resolve().then(() => __importStar(require('chokidar')));
+    const watcher = chokidar.watch(['src/main.ts', 'src/**/*.ts'], {
+        cwd,
+        ignoreInitial: true,
+        ignored: ['src/ui/**']
+    });
+    watcher.on('change', (file) => {
+        console.log(chalk_1.default.yellow(`[后端] 文件变化: ${file}`));
+    });
+}
+async function startViteDevServer(cwd) {
+    const viteConfig = path.join(cwd, 'vite.config.ts');
+    if (!fs.existsSync(viteConfig)) {
+        console.log(chalk_1.default.yellow('跳过 UI 开发服务器: 未找到 vite.config.ts'));
+        return;
+    }
+    // 每次启动开发模式都构建 UI
+    // 这样应用可以加载最新的插件 UI
+    console.log(chalk_1.default.blue('构建 UI...'));
+    await new Promise((resolve, reject) => {
+        const viteBuild = (0, child_process_1.spawn)('npx', ['vite', 'build'], {
+            cwd,
+            stdio: 'inherit',
+            shell: true
+        });
+        viteBuild.on('close', (code) => {
+            if (code === 0) {
+                console.log(chalk_1.default.green('✓ UI 构建完成: ui/'));
+                resolve();
+            }
+            else {
+                reject(new Error(`Vite 构建失败，退出码: ${code}`));
+            }
+        });
+        viteBuild.on('error', reject);
+    });
+    console.log();
+    console.log(chalk_1.default.blue('启动 Vite 开发服务器...'));
+    console.log(chalk_1.default.gray('  💡 提示: Vite 开发服务器提供 UI 预览，修改 UI 代码后'));
+    console.log(chalk_1.default.gray('           在 Mulby 中点击「刷新插件」或执行 npm run build 更新'));
+    console.log();
+    viteProcess = (0, child_process_1.spawn)('npx', ['vite', '--host'], {
+        cwd,
+        stdio: 'inherit',
+        shell: true
+    });
+    viteProcess.on('error', (err) => {
+        console.log(chalk_1.default.red('Vite 启动失败:'), err);
+    });
+}
+function cleanup() {
+    console.log(chalk_1.default.blue('\n停止开发模式...'));
+    if (viteProcess) {
+        viteProcess.kill();
+    }
+    process.exit(0);
+}

package/dist/commands/pack.js

@@ -0,0 +1,160 @@
+"use strict";
+var __createBinding = (this && this.__createBinding) || (Object.create ? (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    var desc = Object.getOwnPropertyDescriptor(m, k);
+    if (!desc || ("get" in desc ? !m.__esModule : desc.writable || desc.configurable)) {
+      desc = { enumerable: true, get: function() { return m[k]; } };
+    }
+    Object.defineProperty(o, k2, desc);
+}) : (function(o, m, k, k2) {
+    if (k2 === undefined) k2 = k;
+    o[k2] = m[k];
+}));
+var __setModuleDefault = (this && this.__setModuleDefault) || (Object.create ? (function(o, v) {
+    Object.defineProperty(o, "default", { enumerable: true, value: v });
+}) : function(o, v) {
+    o["default"] = v;
+});
+var __importStar = (this && this.__importStar) || (function () {
+    var ownKeys = function(o) {
+        ownKeys = Object.getOwnPropertyNames || function (o) {
+            var ar = [];
+            for (var k in o) if (Object.prototype.hasOwnProperty.call(o, k)) ar[ar.length] = k;
+            return ar;
+        };
+        return ownKeys(o);
+    };
+    return function (mod) {
+        if (mod && mod.__esModule) return mod;
+        var result = {};
+        if (mod != null) for (var k = ownKeys(mod), i = 0; i < k.length; i++) if (k[i] !== "default") __createBinding(result, mod, k[i]);
+        __setModuleDefault(result, mod);
+        return result;
+    };
+})();
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.pack = pack;
+const fs = __importStar(require("fs-extra"));
+const path = __importStar(require("path"));
+const archiver_1 = __importDefault(require("archiver"));
+const chalk_1 = __importDefault(require("chalk"));
+async function pack() {
+    const cwd = process.cwd();
+    const manifestPath = path.join(cwd, 'manifest.json');
+    if (!fs.existsSync(manifestPath)) {
+        console.log(chalk_1.default.red('错误: 未找到 manifest.json'));
+        process.exit(1);
+    }
+    const manifest = fs.readJsonSync(manifestPath);
+    const distMain = path.join(cwd, 'dist/main.js');
+    if (!fs.existsSync(distMain)) {
+        console.log(chalk_1.default.red('错误: 未找到 dist/main.js，请先运行 build'));
+        process.exit(1);
+    }
+    const outputName = `${manifest.name}-${manifest.version}.inplugin`;
+    const outputPath = path.join(cwd, outputName);
+    console.log(chalk_1.default.blue(`打包插件: ${outputName}`));
+    await createArchive(cwd, outputPath, manifest);
+    console.log(chalk_1.default.green(`✓ 打包成功: ${outputName}`));
+}
+async function createArchive(cwd, outputPath, manifest) {
+    return new Promise((resolve, reject) => {
+        const output = fs.createWriteStream(outputPath);
+        const archive = (0, archiver_1.default)('zip', { zlib: { level: 9 } });
+        output.on('close', () => resolve());
+        archive.on('error', (err) => reject(err));
+        archive.pipe(output);
+        // 添加 manifest.json
+        archive.file(path.join(cwd, 'manifest.json'), { name: 'manifest.json' });
+        // 添加打包后的 main.js
+        archive.file(path.join(cwd, 'dist/main.js'), { name: 'main.js' });
+        // 添加图标（如果存在）
+        const iconPath = path.join(cwd, 'icon.png');
+        if (fs.existsSync(iconPath)) {
+            archive.file(iconPath, { name: 'icon.png' });
+        }
+        // 添加 UI 目录（如果存在）
+        const uiDir = path.join(cwd, 'ui');
+        if (fs.existsSync(uiDir)) {
+            archive.directory(uiDir, 'ui');
+        }
+        // 添加 preload 脚本（如果在 manifest 中配置了）
+        if (manifest.preload) {
+            const preloadPath = path.join(cwd, manifest.preload);
+            if (fs.existsSync(preloadPath)) {
+                archive.file(preloadPath, { name: manifest.preload });
+                console.log(chalk_1.default.gray(`  + ${manifest.preload}`));
+                // 当有 preload 时，打包 node_modules 中的生产依赖
+                const nodeModulesDir = path.join(cwd, 'node_modules');
+                const pkgJsonPath = path.join(cwd, 'package.json');
+                if (fs.existsSync(nodeModulesDir) && fs.existsSync(pkgJsonPath)) {
+                    const pkgJson = fs.readJsonSync(pkgJsonPath);
+                    const dependencies = Object.keys(pkgJson.dependencies || {});
+                    if (dependencies.length > 0) {
+                        console.log(chalk_1.default.gray('  + node_modules/ (生产依赖)'));
+                        // 打包每个生产依赖及其子依赖
+                        for (const dep of dependencies) {
+                            const depPath = path.join(nodeModulesDir, dep);
+                            if (fs.existsSync(depPath)) {
+                                archive.directory(depPath, `node_modules/${dep}`);
+                            }
+                        }
+                        // 递归收集所有需要的依赖（包括依赖的依赖）
+                        const allDeps = collectAllDependencies(cwd, dependencies);
+                        for (const dep of allDeps) {
+                            if (!dependencies.includes(dep)) {
+                                const depPath = path.join(nodeModulesDir, dep);
+                                if (fs.existsSync(depPath)) {
+                                    archive.directory(depPath, `node_modules/${dep}`);
+                                }
+                            }
+                        }
+                    }
+                }
+            }
+            else {
+                console.log(chalk_1.default.yellow(`警告: preload 文件不存在: ${manifest.preload}`));
+            }
+        }
+        // 添加 README.md（如果存在）
+        const readmePath = path.join(cwd, 'README.md');
+        if (fs.existsSync(readmePath)) {
+            archive.file(readmePath, { name: 'README.md' });
+        }
+        archive.finalize();
+    });
+}
+/**
+ * 递归收集所有依赖（包括依赖的依赖）
+ */
+function collectAllDependencies(cwd, dependencies) {
+    const nodeModulesDir = path.join(cwd, 'node_modules');
+    const collected = new Set();
+    const queue = [...dependencies];
+    while (queue.length > 0) {
+        const dep = queue.shift();
+        if (collected.has(dep))
+            continue;
+        collected.add(dep);
+        // 读取该依赖的 package.json 获取其依赖
+        const depPkgPath = path.join(nodeModulesDir, dep, 'package.json');
+        if (fs.existsSync(depPkgPath)) {
+            try {
+                const depPkg = fs.readJsonSync(depPkgPath);
+                const subDeps = Object.keys(depPkg.dependencies || {});
+                for (const subDep of subDeps) {
+                    if (!collected.has(subDep)) {
+                        queue.push(subDep);
+                    }
+                }
+            }
+            catch {
+                // 忽略读取错误
+            }
+        }
+    }
+    return Array.from(collected);
+}

package/dist/commands/resume.js

@@ -0,0 +1,97 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+exports.resume = resume;
+const chalk_1 = __importDefault(require("chalk"));
+const inquirer_1 = __importDefault(require("inquirer"));
+const session_manager_1 = require("../services/session-manager");
+const ai_generator_1 = require("../services/ai-generator");
+async function resume(options) {
+    const sessionManager = session_manager_1.SessionManager.getInstance();
+    const cwd = process.cwd();
+    console.log(chalk_1.default.gray(`Checking for sessions in ${cwd}...`));
+    const session = sessionManager.getLatestSessionForDir(cwd);
+    if (!session) {
+        console.log(chalk_1.default.yellow('No active AI session found for this directory.'));
+        console.log('You can start a new one with: mulby create <name> --ai');
+        return;
+    }
+    console.log(chalk_1.default.green(`Found session: ${session.id}`));
+    console.log(chalk_1.default.blue(`Description: ${session.description}`));
+    console.log(chalk_1.default.gray(`Status: ${session.status}`));
+    // Check for interrupted tool execution (dangling tool calls)
+    // Check for interrupted tool execution (dangling tool calls)
+    // Find the last assistant message
+    let lastAssistantIdx = -1;
+    for (let i = session.conversationHistory.length - 1; i >= 0; i--) {
+        if (session.conversationHistory[i].role === 'assistant') {
+            lastAssistantIdx = i;
+            break;
+        }
+    }
+    if (lastAssistantIdx !== -1) {
+        const lastAsstMsg = session.conversationHistory[lastAssistantIdx];
+        if (lastAsstMsg.tool_calls && lastAsstMsg.tool_calls.length > 0) {
+            console.log(chalk_1.default.cyan(`Debug: Checking tool chain integrity for Assistant Msg #${lastAssistantIdx}...`));
+            // 1. Identify valid tool responses that exist *anywhere* after the assistant
+            // logic: we want to keep valid tool responses but remove 'user' junk in between
+            const subsequentMessages = session.conversationHistory.slice(lastAssistantIdx + 1);
+            const validToolResponses = subsequentMessages.filter(m => m.role === 'tool' &&
+                lastAsstMsg.tool_calls.some(c => c.id === m.tool_call_id));
+            // 2. Check if we need to repair (if there are intervening junk OR missing calls)
+            // If subsequentMessages has more items than validToolResponses, there is junk.
+            // If validToolResponses.length < tool_calls.length, there are missing calls.
+            const hasJunk = subsequentMessages.length > validToolResponses.length;
+            const hasMissingKeys = validToolResponses.length < lastAsstMsg.tool_calls.length;
+            if (hasJunk || hasMissingKeys) {
+                console.log(chalk_1.default.yellow(`⚠️ Detected broken tool chain (Junk: ${hasJunk}, Missing: ${hasMissingKeys}). Repairing...`));
+                // 3. Rebuild history
+                // Keep everything up to Assistant
+                const newHistory = session.conversationHistory.slice(0, lastAssistantIdx + 1);
+                // Add valid existing responses
+                // We map tool_calls to preserve order or just push what we found?
+                // OpenAI prefers order matching tool_calls usually, but ID matching is key.
+                // Let's iterate tool_calls and find response or create fake.
+                for (const call of lastAsstMsg.tool_calls) {
+                    const existing = validToolResponses.find(m => m.tool_call_id === call.id);
+                    if (existing) {
+                        newHistory.push(existing);
+                    }
+                    else {
+                        newHistory.push({
+                            role: 'tool',
+                            tool_call_id: call.id,
+                            name: call.function.name,
+                            content: 'Session resumed. Tool execution interrupted or failed to save.'
+                        });
+                    }
+                }
+                // Update session
+                session.conversationHistory = newHistory;
+                sessionManager.saveSession(session);
+                console.log(chalk_1.default.green('✓ History repaired. Removed intervening user messages and filled missing tool outputs.'));
+            }
+        }
+    }
+    // If session is completed or failed, we might want to check if user wants to continue
+    if (session.status === 'completed' || session.status === 'failed') {
+        const { confirm } = await inquirer_1.default.prompt([{
+                type: 'confirm',
+                name: 'confirm',
+                message: `Session is marked as ${session.status}. Do you want to continue working on it?`,
+                default: true
+            }]);
+        if (!confirm) {
+            return;
+        }
+        session.status = 'generating';
+        sessionManager.saveSession(session);
+    }
+    // Start UI
+    // Note: AIAgent will look for system prompt in history or default.
+    // Since we are resuming, we assume the agent can handle context.
+    const agent = new ai_generator_1.AIAgent(session);
+    await agent.start({ waitForInput: true });
+}

package/dist/commands/test-ui.js

@@ -0,0 +1,50 @@
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const chalk_1 = __importDefault(require("chalk"));
+const tui_1 = require("../services/tui");
+async function main() {
+    console.log('Starting UI Test...');
+    tui_1.tui.start();
+    tui_1.tui.log('Welcome to Mulby CLI UI Test');
+    tui_1.tui.log('This line should appear in the scrollable log area.');
+    let counter = 0;
+    const interval = setInterval(() => {
+        counter++;
+        tui_1.tui.log(`Auto log message #${counter} - ${new Date().toLocaleTimeString()}`);
+        tui_1.tui.setStatus(`Processing... (${counter}/10)`);
+        if (counter >= 10) {
+            clearInterval(interval);
+            tui_1.tui.log(chalk_1.default.green('Auto logging finished.'));
+            tui_1.tui.setStatus('Ready');
+        }
+    }, 1000);
+    try {
+        const name = await tui_1.tui.prompt('What is your name?');
+        tui_1.tui.log(chalk_1.default.cyan(`Hello, ${name}!`));
+        const cmd = await tui_1.tui.prompt('Type a command like /help:');
+        tui_1.tui.log(`You typed: ${cmd}`);
+        if (cmd.startsWith('/')) {
+            tui_1.tui.log(chalk_1.default.yellow('Command detected!'));
+        }
+        const confirm = await tui_1.tui.prompt('Do you want to exit? (y/n)');
+        if (confirm === 'y') {
+            tui_1.tui.log('Exiting...');
+        }
+        else {
+            tui_1.tui.log('Staying alive for 2 more seconds...');
+            await new Promise(r => setTimeout(r, 2000));
+        }
+    }
+    catch (e) {
+        tui_1.tui.log(chalk_1.default.red('Error during prompt: ' + e));
+    }
+    finally {
+        tui_1.tui.stop();
+        console.log('UI Test Finished.');
+        process.exit(0);
+    }
+}
+main().catch(console.error);

package/dist/index.js

@@ -0,0 +1,71 @@
+#!/usr/bin/env node
+"use strict";
+var __importDefault = (this && this.__importDefault) || function (mod) {
+    return (mod && mod.__esModule) ? mod : { "default": mod };
+};
+Object.defineProperty(exports, "__esModule", { value: true });
+const commander_1 = require("commander");
+const create_1 = require("./commands/create");
+const build_1 = require("./commands/build");
+const pack_1 = require("./commands/pack");
+const dev_1 = require("./commands/dev");
+const config_1 = require("./commands/config");
+const config_ai_1 = require("./commands/config-ai");
+const ai_session_1 = require("./commands/ai-session");
+const fs_1 = require("fs");
+const path_1 = require("path");
+const resume_1 = require("./commands/resume");
+const chalk_1 = __importDefault(require("chalk"));
+// 全局错误处理 - 防止进程意外退出
+process.on('uncaughtException', (err) => {
+    console.error(chalk_1.default.red('\n❌ Uncaught Exception:'));
+    console.error(chalk_1.default.red(err.stack || err.message));
+    process.exit(1);
+});
+process.on('unhandledRejection', (reason, promise) => {
+    console.error(chalk_1.default.red('\n❌ Unhandled Promise Rejection:'));
+    console.error(chalk_1.default.red(reason instanceof Error ? reason.stack || reason.message : String(reason)));
+    // 不立即退出，让程序有机会处理
+});
+// 读取 package.json 获取版本号
+const pkg = JSON.parse((0, fs_1.readFileSync)((0, path_1.join)(__dirname, '..', 'package.json'), 'utf-8'));
+const program = new commander_1.Command();
+program
+    .name('mulby')
+    .description('Mulby 插件开发 CLI 工具')
+    .version(pkg.version);
+program
+    .command('create <name>')
+    .description('创建新插件项目')
+    .option('-t, --template <template>', '模板类型: react (默认) | basic', 'react')
+    .option('--ai', '使用 AI 辅助生成插件')
+    .option('--desc <description>', '此插件的简单功能描述')
+    .option('--resume [sessionId]', '恢复 AI 生成会话')
+    .action(create_1.create);
+program
+    .command('build')
+    .description('构建插件')
+    .action(build_1.build);
+program
+    .command('pack')
+    .description('打包成 .inplugin 文件')
+    .action(pack_1.pack);
+program
+    .command('dev')
+    .description('开发模式（热重载）')
+    .action(dev_1.dev);
+program
+    .command('config <action> [key] [value]')
+    .description('管理配置 (get, set, delete, list)')
+    .action(config_1.configCommand);
+// 添加 AI 配置命令（独立的顶级命令）
+program.addCommand((0, config_ai_1.createAIConfigCommand)());
+program
+    .command('ai-session <action> [sessionId]')
+    .description('管理 AI 会话 (list, resume)')
+    .action(ai_session_1.sessionCommand);
+program
+    .command('resume')
+    .description('恢复当前目录的 AI 会话')
+    .action(resume_1.resume);
+program.parse();