momo-ai 1.0.20 → 1.0.22

package/src/executor/executeDocs.js

@@ -0,0 +1,498 @@
+const { spawn, execSync } = require('child_process');
+const fs = require('fs');
+const fsAsync = require('fs').promises;
+const path = require('path');
+const os = require('os');
+const Ec = require('../epic');
+const { parseOptional } = require('../utils/momo-args');
+const { copyDir } = require('../utils/momo-file-utils');
+
+/**
+ * 检查 Obsidian 是否已安装
+ * @returns {Promise<boolean>}
+ */
+const _isObsidianInstalled = async () => {
+    const platform = os.platform();
+    
+    if (platform === 'darwin') {
+        // macOS: 检查 Applications 目录
+        const obsidianPath = '/Applications/Obsidian.app';
+        return fs.existsSync(obsidianPath);
+    } else if (platform === 'win32') {
+        // Windows: 检查常见安装路径或注册表
+        const localAppData = process.env.LOCALAPPDATA || '';
+        const programFiles = process.env.PROGRAMFILES || 'C:\\Program Files';
+        const possiblePaths = [
+            path.join(localAppData, 'Obsidian', 'Obsidian.exe'),
+            path.join(programFiles, 'Obsidian', 'Obsidian.exe')
+        ];
+        return possiblePaths.some(p => fs.existsSync(p));
+    } else {
+        // Linux: 检查 which obsidian 或常见路径
+        try {
+            execSync('which obsidian', { stdio: 'pipe' });
+            return true;
+        } catch {
+            // 检查 flatpak 或 snap 安装
+            const snapPath = '/snap/bin/obsidian';
+            const flatpakCheck = () => {
+                try {
+                    execSync('flatpak list | grep -i obsidian', { stdio: 'pipe' });
+                    return true;
+                } catch {
+                    return false;
+                }
+            };
+            return fs.existsSync(snapPath) || flatpakCheck();
+        }
+    }
+};
+
+/**
+ * 检查 Obsidian 是否正在运行
+ * @returns {Promise<boolean>}
+ */
+const _isObsidianRunning = async () => {
+    const platform = os.platform();
+    
+    try {
+        if (platform === 'darwin') {
+            const result = execSync('pgrep -f "Obsidian.app"', { stdio: 'pipe' });
+            return result.toString().trim().length > 0;
+        } else if (platform === 'win32') {
+            const result = execSync('tasklist /FI "IMAGENAME eq Obsidian.exe"', { stdio: 'pipe' });
+            return result.toString().includes('Obsidian.exe');
+        } else {
+            const result = execSync('pgrep -f obsidian', { stdio: 'pipe' });
+            return result.toString().trim().length > 0;
+        }
+    } catch {
+        return false;
+    }
+};
+
+/**
+ * 关闭 Obsidian 应用
+ * @returns {Promise<void>}
+ */
+const _closeObsidian = async () => {
+    const platform = os.platform();
+    
+    try {
+        if (platform === 'darwin') {
+            execSync('killall Obsidian', { stdio: 'ignore' });
+            // 等待进程完全关闭
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        } else if (platform === 'win32') {
+            execSync('taskkill /F /IM Obsidian.exe', { stdio: 'ignore' });
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        } else {
+            execSync('killall obsidian', { stdio: 'ignore' });
+            await new Promise(resolve => setTimeout(resolve, 1000));
+        }
+    } catch {
+        // 如果关闭失败也不报错
+    }
+};
+
+/**
+ * 生成 vault ID（模仿 Obsidian 的 16 位十六进制 ID）
+ * @returns {string}
+ */
+const _generateVaultId = () => {
+    const chars = '0123456789abcdef';
+    let id = '';
+    for (let i = 0; i < 16; i++) {
+        id += chars[Math.floor(Math.random() * chars.length)];
+    }
+    return id;
+};
+
+/**
+ * 注册 vault 到 Obsidian 配置
+ * @param {string} vaultPath vault 路径
+ * @returns {Promise<string|null>} 返回 vault ID，失败返回 null
+ */
+const _registerVaultToObsidian = async (vaultPath) => {
+    const platform = os.platform();
+    let configPath;
+    
+    if (platform === 'darwin') {
+        configPath = path.join(os.homedir(), 'Library/Application Support/obsidian/obsidian.json');
+    } else if (platform === 'win32') {
+        configPath = path.join(process.env.APPDATA || '', 'obsidian', 'obsidian.json');
+    } else {
+        // Linux
+        const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+        configPath = path.join(xdgConfig, 'obsidian', 'obsidian.json');
+    }
+    
+    try {
+        let config = { vaults: {}, frame: 'custom' };
+        
+        // 读取现有配置
+        if (fs.existsSync(configPath)) {
+            const content = await fsAsync.readFile(configPath, 'utf8');
+            config = JSON.parse(content);
+        }
+        
+        // 检查 vault 是否已存在
+        const existingVault = Object.entries(config.vaults || {}).find(
+            ([id, vault]) => vault.path === vaultPath
+        );
+        
+        let vaultId;
+        if (existingVault) {
+            // 已存在，更新 ts 和 open 状态
+            [vaultId] = existingVault;
+            config.vaults[vaultId].ts = Date.now();
+            config.vaults[vaultId].open = true;
+        } else {
+            // 新 vault，生成 ID 并添加
+            vaultId = _generateVaultId();
+            config.vaults[vaultId] = {
+                path: vaultPath,
+                ts: Date.now(),
+                open: true
+            };
+        }
+        
+        // 确保配置目录存在
+        const configDir = path.dirname(configPath);
+        if (!fs.existsSync(configDir)) {
+            await fsAsync.mkdir(configDir, { recursive: true });
+        }
+        
+        // 写入配置
+        await fsAsync.writeFile(configPath, JSON.stringify(config), 'utf8');
+        return vaultId;
+    } catch (error) {
+        Ec.warn(`⚠ 无法注册 vault 到配置: ${error.message}`);
+        return null;
+    }
+};
+
+/**
+ * 使用 Obsidian 打开目录
+ * 直接调用 Obsidian 可执行文件，传递目录路径作为参数
+ * @param {string} targetDir 目标目录绝对路径
+ * @param {string} vaultId vault ID，用于 URL scheme
+ * @returns {Promise<void>}
+ */
+const _openWithObsidian = async (targetDir, vaultId = null) => {
+    const platform = os.platform();
+    
+    if (platform === 'darwin') {
+        // macOS: 优先使用 vault ID 的 URL scheme，更可靠
+        if (vaultId) {
+            const obsidianUri = `obsidian://open?vault=${vaultId}`;
+            
+            return new Promise((resolve, reject) => {
+                const child = spawn('open', [obsidianUri], {
+                    stdio: 'ignore'
+                });
+                
+                child.on('error', (error) => {
+                    reject(new Error(`启动 Obsidian 失败: ${error.message}`));
+                });
+                
+                child.on('close', (code) => {
+                    if (code === 0) {
+                        // 给 Obsidian 时间加载
+                        setTimeout(() => resolve(), 1000);
+                    } else {
+                        reject(new Error(`启动 Obsidian 失败，退出码: ${code}`));
+                    }
+                });
+            });
+        } else {
+            // 回退到直接调用可执行文件
+            const obsidianBinary = '/Applications/Obsidian.app/Contents/MacOS/Obsidian';
+            
+            if (!fs.existsSync(obsidianBinary)) {
+                throw new Error('找不到 Obsidian 可执行文件');
+            }
+            
+            return new Promise((resolve, reject) => {
+                const child = spawn(obsidianBinary, [targetDir], {
+                    detached: true,
+                    stdio: 'ignore'
+                });
+                
+                child.on('error', (error) => {
+                    reject(new Error(`启动 Obsidian 失败: ${error.message}`));
+                });
+                
+                child.unref();
+                setTimeout(() => resolve(), 500);
+            });
+        }
+    } else if (platform === 'win32') {
+        // Windows: 查找 Obsidian.exe 并直接打开目录
+        const localAppData = process.env.LOCALAPPDATA || '';
+        const programFiles = process.env.PROGRAMFILES || 'C:\\Program Files';
+        const possiblePaths = [
+            path.join(localAppData, 'Obsidian', 'Obsidian.exe'),
+            path.join(programFiles, 'Obsidian', 'Obsidian.exe')
+        ];
+        
+        const obsidianExe = possiblePaths.find(p => fs.existsSync(p));
+        if (!obsidianExe) {
+            throw new Error('找不到 Obsidian 可执行文件');
+        }
+        
+        return new Promise((resolve, reject) => {
+            const child = spawn(obsidianExe, [targetDir], {
+                detached: true,
+                stdio: 'ignore'
+            });
+            
+            child.on('error', (error) => {
+                reject(new Error(`启动 Obsidian 失败: ${error.message}`));
+            });
+            
+            child.unref();
+            
+            setTimeout(() => {
+                resolve();
+            }, 500);
+        });
+    } else {
+        // Linux: 尝试直接启动 obsidian 命令
+        const snapPath = '/snap/bin/obsidian';
+        const flatpakPath = 'flatpak run md.obsidian.Obsidian';
+        let obsidianCmd = 'obsidian';
+        let args = [targetDir];
+        let useShell = false;
+        
+        // 检查 snap 安装
+        if (fs.existsSync(snapPath)) {
+            obsidianCmd = snapPath;
+        } else {
+            // 尝试 flatpak
+            try {
+                execSync('flatpak list | grep -i obsidian', { stdio: 'pipe' });
+                obsidianCmd = flatpakPath;
+                useShell = true;
+                args = [targetDir];
+            } catch {
+                // 使用默认命令
+            }
+        }
+        
+        return new Promise((resolve, reject) => {
+            const spawnOptions = {
+                detached: true,
+                stdio: 'ignore'
+            };
+            
+            if (useShell) {
+                spawnOptions.shell = true;
+            }
+            
+            const child = spawn(obsidianCmd, args, spawnOptions);
+            
+            child.on('error', (error) => {
+                reject(new Error(`启动 Obsidian 失败: ${error.message}`));
+            });
+            
+            child.unref();
+            
+            setTimeout(() => {
+                resolve();
+            }, 500);
+        });
+    }
+};
+
+/**
+ * 获取操作系统名称
+ * @returns {string}
+ */
+const _getOsName = () => {
+    const platform = os.platform();
+    switch (platform) {
+        case 'darwin': return 'macOS';
+        case 'win32': return 'Windows';
+        case 'linux': return 'Linux';
+        default: return platform;
+    }
+};
+
+/**
+ * 初始化 .obsidian 目录
+ * 从模板目录复制默认配置
+ * @param {string} targetDir 目标目录
+ * @returns {Promise<boolean>} 是否成功初始化
+ */
+const _initObsidianConfig = async (targetDir) => {
+    const obsidianSourcePath = path.resolve(__dirname, '../_template/LAIN/.obsidian');
+    const obsidianTargetPath = path.join(targetDir, '.obsidian');
+    
+    // 检查模板目录是否存在
+    if (!fs.existsSync(obsidianSourcePath)) {
+        Ec.warn(`⚠ 模板目录不存在: ${obsidianSourcePath}`);
+        return false;
+    }
+    
+    try {
+        const stat = await fsAsync.stat(obsidianSourcePath);
+        if (!stat.isDirectory()) {
+            Ec.warn(`⚠ 模板路径不是目录: ${obsidianSourcePath}`);
+            return false;
+        }
+        
+        Ec.waiting('正在初始化 .obsidian 配置...');
+        await copyDir(obsidianSourcePath, obsidianTargetPath);
+        Ec.info('✓ 已创建 .obsidian 配置目录');
+        return true;
+    } catch (error) {
+        Ec.error(`初始化 .obsidian 失败: ${error.message}`);
+        return false;
+    }
+};
+
+/**
+ * 更新目标目录的 .gitignore 文件
+ * 添加 .obsidian/workspace.json 到忽略列表
+ * @param {string} targetDir 目标目录
+ * @returns {Promise<void>}
+ */
+const _updateGitignore = async (targetDir) => {
+    const gitignorePath = path.join(targetDir, '.gitignore');
+    const ignoreEntry = '.obsidian/workspace.json';
+    
+    try {
+        let gitignoreContent = '';
+        
+        // 读取现有的 .gitignore 内容
+        if (fs.existsSync(gitignorePath)) {
+            gitignoreContent = await fsAsync.readFile(gitignorePath, 'utf8');
+        }
+        
+        // 检查是否已经包含该条目
+        if (gitignoreContent.includes(ignoreEntry)) {
+            Ec.info('✓ .gitignore 已包含 .obsidian/workspace.json');
+            return;
+        }
+        
+        // 添加条目
+        if (gitignoreContent && !gitignoreContent.endsWith('\n')) {
+            gitignoreContent += '\n';
+        }
+        
+        gitignoreContent += `${ignoreEntry}\n`;
+        
+        // 写入 .gitignore 文件
+        await fsAsync.writeFile(gitignorePath, gitignoreContent, 'utf8');
+        Ec.info('✓ 已添加 .obsidian/workspace.json 到 .gitignore');
+    } catch (error) {
+        Ec.warn(`⚠ 更新 .gitignore 失败: ${error.message}`);
+    }
+};
+
+module.exports = async (options) => {
+    try {
+        // 1. 解析 -d 参数，获取目标目录
+        const dirArg = parseOptional('dir', 'd');
+        const targetDir = dirArg.hasFlag && dirArg.value 
+            ? path.resolve(dirArg.value) 
+            : process.cwd();
+
+        Ec.info(`📁 目标目录: ${targetDir.cyan}`);
+        Ec.info(`💻 操作系统: ${_getOsName().cyan}`);
+
+        // 2. 检查目标目录是否存在
+        if (!fs.existsSync(targetDir)) {
+            Ec.error(`❌ 目录不存在: ${targetDir}`);
+            process.exit(1);
+        }
+
+        // 3. 检查目录是否是文件夹
+        const stat = fs.statSync(targetDir);
+        if (!stat.isDirectory()) {
+            Ec.error(`❌ 路径不是目录: ${targetDir}`);
+            process.exit(1);
+        }
+
+        // 4. 检查 .obsidian 配置是否存在，不存在则自动初始化
+        const obsidianConfigPath = path.join(targetDir, '.obsidian');
+        if (!fs.existsSync(obsidianConfigPath)) {
+            Ec.warn(`⚠ 目录中不存在 .obsidian 配置，正在自动初始化...`);
+            
+            const initSuccess = await _initObsidianConfig(targetDir);
+            if (!initSuccess) {
+                Ec.error('❌ 无法初始化 .obsidian 配置');
+                console.log('');
+                Ec.error('请手动使用 Obsidian 打开该目录以初始化配置');
+                console.log('  下载地址: https://obsidian.md/download'.cyan);
+                console.log('');
+                process.exit(1);
+            }
+        } else {
+            Ec.info('✓ 检测到 .obsidian 配置');
+        }
+
+        // 4.5. 更新 .gitignore，添加 .obsidian/workspace.json
+        await _updateGitignore(targetDir);
+
+        // 5. 检查 Obsidian 是否已安装
+        Ec.waiting('正在检查 Obsidian 安装状态...');
+        const obsidianInstalled = await _isObsidianInstalled();
+
+        if (!obsidianInstalled) {
+            Ec.error('❌ 未检测到 Obsidian 安装');
+            console.log('');
+            Ec.error('请先安装 Obsidian:');
+            console.log('  下载地址: https://obsidian.md/download'.cyan);
+            console.log('');
+            process.exit(1);
+        }
+
+        Ec.info('✓ Obsidian 已安装');
+
+        // 6. 检查 Obsidian 是否正在运行
+        const isRunning = await _isObsidianRunning();
+        if (isRunning) {
+            Ec.waiting('检测到 Obsidian 正在运行，正在重启以加载新 vault...');
+            await _closeObsidian();
+        }
+
+        // 7. 注册 vault 到 Obsidian 配置
+        Ec.waiting('正在注册 vault 到 Obsidian...');
+        const vaultId = await _registerVaultToObsidian(targetDir);
+        if (vaultId) {
+            Ec.info(`✓ Vault 已注册 (ID: ${vaultId.substring(0, 8)}...)`);
+        } else {
+            Ec.warn('⚠ Vault 注册失败，将尝试直接打开');
+        }
+
+        // 8. 使用 Obsidian 打开目录
+        Ec.waiting(`正在使用 Obsidian 打开: ${targetDir.cyan}...`);
+        
+        try {
+            await _openWithObsidian(targetDir, vaultId);
+            console.log('');
+            Ec.info(`✅ 已成功打开 Obsidian`);
+            if (vaultId) {
+                Ec.info(`💡 提示: 该 vault 现在会出现在 Obsidian 的本地仓库列表中`);
+            }
+            console.log('');
+        } catch (error) {
+            console.log('');
+            Ec.error(`❌ 打开失败: ${error.message}`);
+            console.log('');
+            Ec.warn('您可以手动使用 Obsidian 打开该目录');
+            console.log('');
+        }
+
+        // 短暂延迟后退出，确保进程完成
+        setTimeout(() => {
+            process.exit(0);
+        }, 1000);
+
+    } catch (error) {
+        Ec.error(`❌ 执行失败: ${error.message}`);
+        process.exit(1);
+    }
+};