momo-ai 1.0.75 → 1.0.77

package/package.json

@@ -1,6 +1,6 @@
 {
     "name": "momo-ai",
-    "version": "1.0.75",
+    "version": "1.0.77",
     "description": "Rachel Momo ( OpenSpec )",
     "main": "src/momo.js",
     "bin": {

package/src/_skill/repositories.json

@@ -47,6 +47,12 @@
             "description": "社区精选技能集合",
             "url": "https://github.com/abubakarsiddik31/claude-skills-collection.git",
             "skillsPath": "skills"
+        },
+        {
+            "name": "mxt",
+            "description": "MXT实战技能库",
+            "url": "https://gitee.com/silentbalanceyh/r2mo-ai.git",
+            "skillsPath": "skills"
         }
     ]
 }

package/src/executor/executeDocs.js

@@ -1,5 +1,4 @@
-const { execSync } = require('child_process');
-const crypto = require('crypto');
+const { spawn, execSync } = require('child_process');
 const fs = require('fs');
 const fsAsync = require('fs').promises;
 const path = require('path');
@@ -8,94 +7,123 @@ const Ec = require('../epic');
 const { parseOptional } = require('../utils/momo-args');
 const { copyDir } = require('../utils/momo-file-utils');
 
-const _getObsidianConfigPath = () => {
-    const platform = os.platform();
-
-    if (platform === 'darwin') {
-        return path.join(os.homedir(), 'Library/Application Support/obsidian/obsidian.json');
-    }
-    if (platform === 'win32') {
-        return path.join(process.env.APPDATA || '', 'obsidian', 'obsidian.json');
-    }
-
-    const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
-    return path.join(xdgConfig, 'obsidian', 'obsidian.json');
-};
-
-/**
- * 根据绝对路径生成确定性 vault ID（sha256 前 16 位 hex）
- * 同一路径永远得到相同 ID，避免随机 ID 导致 Vault Not Found
- * @param {string} absPath vault 绝对路径
- * @returns {string}
- */
-const _deriveVaultId = (absPath) => {
-    return crypto.createHash('sha256').update(absPath).digest('hex').slice(0, 16);
-};
-
 /**
  * 检查 Obsidian 是否已安装
- * @returns {boolean}
+ * @returns {Promise<boolean>}
  */
-const _isObsidianInstalled = () => {
+const _isObsidianInstalled = async () => {
     const platform = os.platform();
-
+    
     if (platform === 'darwin') {
-        return fs.existsSync('/Applications/Obsidian.app');
-    }
-    if (platform === 'win32') {
+        // 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';
-        return [
+        const possiblePaths = [
             path.join(localAppData, 'Obsidian', 'Obsidian.exe'),
-            path.join(programFiles, 'Obsidian', 'Obsidian.exe'),
-        ].some(p => fs.existsSync(p));
-    }
-
-    // Linux
-    try {
-        execSync('which obsidian', { stdio: 'pipe' });
-        return true;
-    } catch {
-        if (fs.existsSync('/snap/bin/obsidian')) return true;
+            path.join(programFiles, 'Obsidian', 'Obsidian.exe')
+        ];
+        return possiblePaths.some(p => fs.existsSync(p));
+    } else {
+        // Linux: 检查 which obsidian 或常见路径
         try {
-            execSync('flatpak list | grep -i obsidian', { stdio: 'pipe' });
+            execSync('which obsidian', { stdio: 'pipe' });
             return true;
         } catch {
-            return false;
+            // 检查 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();
         }
     }
 };
 
 /**
- * 检查指定 vault 是否正在运行（open: true）
- * @param {string} vaultId 确定性 vault ID
+ * 检查指定 vault 是否正在运行
+ * @param {string} vaultPath vault 路径
  * @returns {Promise<boolean>}
  */
-const _isVaultRunning = async (vaultId) => {
-    const configPath = _getObsidianConfigPath();
+const _isVaultRunning = 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 {
+        const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+        configPath = path.join(xdgConfig, 'obsidian', 'obsidian.json');
+    }
+
     try {
-        if (!fs.existsSync(configPath)) return false;
-        const config = JSON.parse(await fsAsync.readFile(configPath, 'utf8'));
-        const vault = (config.vaults || {})[vaultId];
-        return vault ? vault.open === true : false;
+        if (!fs.existsSync(configPath)) {
+            return false;
+        }
+
+        const content = await fsAsync.readFile(configPath, 'utf8');
+        const config = JSON.parse(content);
+
+        // 检查是否有 vault 的 open 状态为 true 且路径匹配
+        const openVault = Object.values(config.vaults || {}).find(
+            vault => vault.path === vaultPath && vault.open === true
+        );
+
+        return !!openVault;
     } catch {
         return false;
     }
 };
 
 /**
- * 关闭指定 vault（将 open 设为 false）
- * @param {string} vaultId 确定性 vault ID
+ * 关闭指定 vault 的 Obsidian 窗口
+ * 通过更新配置文件将 vault 的 open 状态设为 false
+ * @param {string} vaultPath vault 路径
  * @returns {Promise<void>}
  */
-const _closeVault = async (vaultId) => {
-    const configPath = _getObsidianConfigPath();
+const _closeVault = 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 {
+        const xdgConfig = process.env.XDG_CONFIG_HOME || path.join(os.homedir(), '.config');
+        configPath = path.join(xdgConfig, 'obsidian', 'obsidian.json');
+    }
+
     try {
-        if (!fs.existsSync(configPath)) return;
-        const config = JSON.parse(await fsAsync.readFile(configPath, 'utf8'));
-        if (config.vaults && config.vaults[vaultId] && config.vaults[vaultId].open) {
-            const updatedVaults = { ...config.vaults, [vaultId]: { ...config.vaults[vaultId], open: false } };
-            await fsAsync.writeFile(configPath, JSON.stringify({ ...config, vaults: updatedVaults }), 'utf8');
+        if (!fs.existsSync(configPath)) {
+            return;
+        }
+
+        const content = await fsAsync.readFile(configPath, 'utf8');
+        const config = JSON.parse(content);
+
+        // 找到对应的 vault 并设置 open 为 false
+        let updated = false;
+        for (const [id, vault] of Object.entries(config.vaults || {})) {
+            if (vault.path === vaultPath && vault.open === true) {
+                config.vaults[id].open = false;
+                updated = true;
+            }
+        }
+
+        if (updated) {
+            await fsAsync.writeFile(configPath, JSON.stringify(config), 'utf8');
+            // 等待配置生效
             await new Promise(resolve => setTimeout(resolve, 500));
         }
     } catch (error) {
@@ -104,43 +132,75 @@ const _closeVault = async (vaultId) => {
 };
 
 /**
- * 注册 vault 到 obsidian.json，使用确定性 ID。
- * 若已存在同路径的旧随机 ID 记录，先删除旧记录再以确定性 ID 写入。
- * @param {string} vaultPath vault 绝对路径
- * @returns {Promise<string|null>} 确定性 vault ID，失败返回 null
+ * 生成 vault ID（模仿 Obsidian 的 16 位十六进制 ID）
+ * @returns {string}
  */
-const _registerVaultToObsidian = async (vaultPath) => {
-    const configPath = _getObsidianConfigPath();
-    const vaultId = _deriveVaultId(vaultPath);
+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)) {
-            config = JSON.parse(await fsAsync.readFile(configPath, 'utf8'));
+            const content = await fsAsync.readFile(configPath, 'utf8');
+            config = JSON.parse(content);
         }
-        if (!config.vaults) config.vaults = {};
-
-        // 删除所有同路径的旧记录（key 可能是随机 ID）
-        const updatedVaults = {};
-        for (const [id, vault] of Object.entries(config.vaults)) {
-            if (vault.path !== vaultPath) {
-                updatedVaults[id] = vault;
-            }
+        
+        // 检查 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
+            };
         }
-
-        // 写入确定性 ID 记录
-        updatedVaults[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, vaults: updatedVaults }), 'utf8');
+        
+        // 写入配置
+        await fsAsync.writeFile(configPath, JSON.stringify(config), 'utf8');
         return vaultId;
     } catch (error) {
         Ec.warn(`⚠ 无法注册 vault 到配置: ${error.message}`);
@@ -148,72 +208,147 @@ const _registerVaultToObsidian = async (vaultPath) => {
     }
 };
 
-const _removeVaultRegistration = async (vaultPath) => {
-    const configPath = _getObsidianConfigPath();
-    try {
-        if (!fs.existsSync(configPath)) return false;
-        const config = JSON.parse(await fsAsync.readFile(configPath, 'utf8'));
-        let updated = false;
-        const updatedVaults = {};
-        for (const [id, vault] of Object.entries(config.vaults || {})) {
-            if (vault.path === vaultPath) {
-                updated = true;
-            } else {
-                updatedVaults[id] = vault;
-            }
-        }
-        if (!updated) return false;
-        await fsAsync.writeFile(configPath, JSON.stringify({ ...config, vaults: updatedVaults }), 'utf8');
-        return true;
-    } catch (error) {
-        Ec.warn(`⚠ 清理 vault 注册失败: ${error.message}`);
-        return false;
-    }
-};
-
-const _removeLocalObsidianConfig = async (targetDir) => {
-    const obsidianConfigPath = path.join(targetDir, '.obsidian');
-    try {
-        if (!fs.existsSync(obsidianConfigPath)) return false;
-        await fsAsync.rm(obsidianConfigPath, { recursive: true, force: true });
-        return true;
-    } catch (error) {
-        Ec.warn(`⚠ 清理本地 .obsidian 失败: ${error.message}`);
-        return false;
-    }
-};
-
-const _resetVaultConfig = async (targetDir) => {
-    Ec.waiting(`正在清理 Obsidian 配置: ${targetDir.cyan}...`);
-
-    const vaultId = _deriveVaultId(targetDir);
-    const isRunning = await _isVaultRunning(vaultId);
-    if (isRunning) await _closeVault(vaultId);
-
-    const removedVault = await _removeVaultRegistration(targetDir);
-    const removedConfig = await _removeLocalObsidianConfig(targetDir);
-
-    Ec.info(removedVault ? '✓ 已移除 Obsidian 中的 vault 注册' : '✓ 未发现需要移除的 vault 注册');
-    Ec.info(removedConfig ? '✓ 已删除目标目录下的 .obsidian 配置' : '✓ 目标目录下不存在 .obsidian 配置');
-    Ec.info('✅ Obsidian 配置清理完成');
-};
-
 /**
- * 通过 Obsidian URL scheme 打开 vault
- * 使用确定性 ID，保证每次打开的 ID 与注册时一致
- * @param {string} vaultId 确定性 vault ID
- * @returns {void}
+ * 使用 Obsidian 打开目录
+ * 直接调用 Obsidian 可执行文件，传递目录路径作为参数
+ * @param {string} targetDir 目标目录绝对路径
+ * @param {string} vaultId vault ID，用于 URL scheme
+ * @returns {Promise<void>}
  */
-const _openWithObsidian = (vaultId) => {
-    const url = `obsidian://open?vault=${vaultId}`;
+const _openWithObsidian = async (targetDir, vaultId = null) => {
     const platform = os.platform();
 
     if (platform === 'darwin') {
-        execSync(`open "${url}"`, { stdio: 'ignore' });
+        // macOS: 优先使用 vault ID 的 URL scheme，更可靠
+        if (vaultId) {
+            const obsidianUri = `obsidian://open?vault=${vaultId}`;
+
+            // 先退出 Obsidian，确保 URL scheme 能正确打开新 vault
+            try {
+                execSync('osascript -e \'tell application "Obsidian" to quit\'', {
+                    stdio: 'ignore',
+                    timeout: 2000
+                });
+                await new Promise(resolve => setTimeout(resolve, 1000));
+            } catch {
+                // Obsidian 可能未运行，忽略错误
+            }
+
+            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') {
-        execSync(`start "" "${url}"`, { stdio: 'ignore', shell: true });
+        // 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 {
-        execSync(`xdg-open "${url}"`, { stdio: 'ignore' });
+        // 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);
+        });
     }
 };
 
@@ -222,34 +357,38 @@ const _openWithObsidian = (vaultId) => {
  * @returns {string}
  */
 const _getOsName = () => {
-    switch (os.platform()) {
+    const platform = os.platform();
+    switch (platform) {
         case 'darwin': return 'macOS';
         case 'win32': return 'Windows';
         case 'linux': return 'Linux';
-        default: return os.platform();
+        default: return platform;
     }
 };
 
 /**
- * 初始化 .obsidian 目录（从模板复制）
+ * 初始化 .obsidian 目录
+ * 从模板目录复制默认配置
  * @param {string} targetDir 目标目录
- * @returns {Promise<boolean>}
+ * @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 配置目录');
@@ -261,73 +400,73 @@ const _initObsidianConfig = async (targetDir) => {
 };
 
 /**
- * 更新 .gitignore，添加 .obsidian/workspace.json
+ * 更新目标目录的 .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 content = fs.existsSync(gitignorePath)
-            ? await fsAsync.readFile(gitignorePath, 'utf8')
-            : '';
-
-        if (content.includes(ignoreEntry)) {
+        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 (content && !content.endsWith('\n')) content += '\n';
-        content += `${ignoreEntry}\n`;
-        await fsAsync.writeFile(gitignorePath, content, 'utf8');
+        
+        // 添加条目
+        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 () => {
+module.exports = async (options) => {
     try {
+        // 1. 解析 -d 参数，获取目标目录
         const dirArg = parseOptional('dir', 'd');
-        const removeArg = parseOptional('remove', 'r');
-
-        if (dirArg.hasFlag && removeArg.hasFlag) {
-            Ec.error('❌ 参数 -d/--dir 与 -r/--remove 不能同时使用');
-            process.exit(1);
-        }
-
-        let targetDir = process.cwd();
-        if (removeArg.hasFlag) {
-            targetDir = removeArg.value ? path.resolve(removeArg.value) : process.cwd();
-        } else if (dirArg.hasFlag) {
-            targetDir = dirArg.value ? path.resolve(dirArg.value) : process.cwd();
-        }
+        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);
         }
 
-        if (!fs.statSync(targetDir).isDirectory()) {
+        // 3. 检查目录是否是文件夹
+        const stat = fs.statSync(targetDir);
+        if (!stat.isDirectory()) {
             Ec.error(`❌ 路径不是目录: ${targetDir}`);
             process.exit(1);
         }
 
-        if (removeArg.hasFlag) {
-            await _resetVaultConfig(targetDir);
-            console.log('');
-            process.exit(0);
-        }
-
-        // 检查 .obsidian 配置，不存在则初始化
+        // 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 配置');
@@ -341,9 +480,14 @@ module.exports = async () => {
             Ec.info('✓ 检测到 .obsidian 配置');
         }
 
+        // 4.5. 更新 .gitignore，添加 .obsidian/workspace.json
         await _updateGitignore(targetDir);
 
-        if (!_isObsidianInstalled()) {
+        // 5. 检查 Obsidian 是否已安装
+        Ec.waiting('正在检查 Obsidian 安装状态...');
+        const obsidianInstalled = await _isObsidianInstalled();
+
+        if (!obsidianInstalled) {
             Ec.error('❌ 未检测到 Obsidian 安装');
             console.log('');
             Ec.error('请先安装 Obsidian:');
@@ -354,28 +498,32 @@ module.exports = async () => {
 
         Ec.info('✓ Obsidian 已安装');
 
-        // 派生确定性 ID 并注册（自动替换旧随机 ID 记录）
-        Ec.waiting('正在注册 vault...');
-        const vaultId = await _registerVaultToObsidian(targetDir);
-        if (!vaultId) {
-            Ec.error('❌ Vault 注册失败，无法打开');
-            process.exit(1);
+        // 6. 检查当前 vault 是否正在运行
+        const isVaultRunning = await _isVaultRunning(targetDir);
+        if (isVaultRunning) {
+            Ec.waiting('检测到该 vault 正在运行，正在关闭以重新加载...');
+            await _closeVault(targetDir);
         }
-        Ec.info(`✓ Vault 已注册 (ID: ${vaultId})`);
 
-        // 若 vault 正在运行，先关闭再重新打开
-        const isRunning = await _isVaultRunning(vaultId);
-        if (isRunning) {
-            Ec.waiting('检测到该 vault 正在运行，正在关闭以重新加载...');
-            await _closeVault(vaultId);
+        // 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 {
-            _openWithObsidian(vaultId);
+            await _openWithObsidian(targetDir, vaultId);
             console.log('');
-            Ec.info('✅ 已成功打开 Obsidian');
-            Ec.info('💡 提示: 该 vault 现在会出现在 Obsidian 的本地仓库列表中');
+            Ec.info(`✅ 已成功打开 Obsidian`);
+            if (vaultId) {
+                Ec.info(`💡 提示: 该 vault 现在会出现在 Obsidian 的本地仓库列表中`);
+            }
             console.log('');
         } catch (error) {
             console.log('');
@@ -385,7 +533,10 @@ module.exports = async () => {
             console.log('');
         }
 
-        setTimeout(() => process.exit(0), 1000);
+        // 短暂延迟后退出，确保进程完成
+        setTimeout(() => {
+            process.exit(0);
+        }, 1000);
 
     } catch (error) {
         Ec.error(`❌ 执行失败: ${error.message}`);