crabatool 1.0.817 → 1.0.820

package/lib/git-permission-tester.js

@@ -0,0 +1,480 @@
+const { exec } = require('child_process');
+const util = require('util');
+const path = require('path');
+const execPromise = util.promisify(exec);
+
+class GitPushPermissionTester {
+    /**
+     * @param {Object} options 配置选项
+     * @param {string} options.repoPath - Git仓库的绝对或相对路径
+     * @param {string} options.targetBranch - 要测试的目标分支（如 'main'）
+     * @param {string} [options.remote='origin'] - 远程仓库名称
+     * @param {boolean} [options.verbose=false] - 是否输出详细日志
+     */
+    constructor(options) {
+        this.repoPath = path.resolve(options.repoPath);
+        this.targetBranch = options.targetBranch;
+        this.remote = options.remote || 'origin';
+        this.verbose = options.verbose || false;
+        this.originalCwd = process.cwd(); // 保存原始工作目录
+        this.testTag = `push_test_backup_${Date.now()}`;
+        
+        this._log(`📁 测试仓库: ${this.repoPath}`);
+        this._log(`🎯 目标分支: ${this.remote}/${this.targetBranch}`);
+    }
+
+    _log(...args) {
+        if (this.verbose) {
+            console.log(...args);
+        }
+    }
+
+    /**
+     * 在指定目录执行命令
+     */
+    async _executeCommand(command, timeout = 30000) {
+        this._log(`执行: ${command}`);
+        
+        try {
+            const { stdout, stderr } = await execPromise(command, {
+                cwd: this.repoPath,
+                timeout,
+                maxBuffer: 10 * 1024 * 1024,
+                encoding: 'utf-8'
+            });
+            
+            if (stderr && this.verbose) {
+                this._log(`stderr: ${stderr.trim()}`);
+            }
+            
+            return { success: true, stdout: stdout.trim(), stderr: stderr.trim() };
+        } catch (error) {
+            return {
+                success: false,
+                code: error.code,
+                stdout: error.stdout ? error.stdout.trim() : '',
+                stderr: error.stderr ? error.stderr.trim() : error.message,
+                error: error.message
+            };
+        }
+    }
+
+    /**
+     * 验证仓库状态
+     */
+    async _validateRepository() {
+        this._log('🔍 验证仓库状态...');
+        
+        // 1. 检查目录是否存在Git仓库
+        const gitCheck = await this._executeCommand('git rev-parse --is-inside-work-tree');
+        if (!gitCheck.success) {
+            throw new Error(`路径 ${this.repoPath} 不是一个有效的Git仓库`);
+        }
+        
+        // 2. 检查是否在目标分支上
+        const branchCheck = await this._executeCommand('git branch --show-current');
+        if (!branchCheck.success || branchCheck.stdout !== this.targetBranch) {
+            throw new Error(`当前不在 ${this.targetBranch} 分支上，当前分支: ${branchCheck.stdout || '未知'}`);
+        }
+        
+        // 3. 检查是否有未提交的更改
+        const statusCheck = await this._executeCommand('git status --porcelain');
+        if (statusCheck.success && statusCheck.stdout) {
+            this._log('⚠️  警告: 工作区有未提交的更改，测试可能会失败');
+        }
+        
+        // 4. 检查远程仓库配置
+        const remoteCheck = await this._executeCommand(`git remote get-url ${this.remote}`);
+        if (!remoteCheck.success) {
+            throw new Error(`远程仓库 ${this.remote} 未配置`);
+        }
+        
+        this._log(`🌐 远程仓库: ${remoteCheck.stdout}`);
+        return true;
+    }
+
+    /**
+     * 执行推送权限测试
+     */
+    async testPushPermission() {
+        try {
+            // 切换到目标目录
+            this._log(`📂 切换到目录: ${this.repoPath}`);
+            process.chdir(this.repoPath);
+            
+            // 验证仓库
+            await this._validateRepository();
+            
+            // 保存原始状态
+            await this._saveOriginalState();
+            
+            // 创建测试提交
+            await this._createTestCommit();
+            
+            // 执行推送测试
+            const pushResult = await this._executePushTest();
+            
+            // 恢复原始状态
+            await this._restoreOriginalState();
+            
+            // 返回结果
+            return this._formatResult(pushResult, true);
+            
+        } catch (error) {
+            // 紧急恢复
+            await this._emergencyCleanup();
+            
+            // 恢复原始工作目录
+            process.chdir(this.originalCwd);
+            
+            return this._formatResult(error, false);
+            
+        } finally {
+            // 确保总是恢复原始工作目录
+            process.chdir(this.originalCwd);
+            this._log('🔄 已恢复原始工作目录');
+        }
+    }
+
+    /**
+     * 保存原始状态
+     */
+    async _saveOriginalState() {
+        this._log('💾 保存原始状态...');
+        
+        // 获取当前提交
+        const commitResult = await this._executeCommand('git rev-parse HEAD');
+        if (!commitResult.success) {
+            throw new Error('无法获取当前提交ID');
+        }
+        
+        const originalCommit = commitResult.stdout;
+        
+        // 创建备份标签
+        const tagResult = await this._executeCommand(`git tag ${this.testTag} ${originalCommit}`);
+        if (!tagResult.success) {
+            throw new Error('创建备份标签失败');
+        }
+        
+        this._log(`📌 备份标签: ${this.testTag} -> ${originalCommit}`);
+    }
+
+    /**
+     * 创建测试提交
+     */
+    async _createTestCommit() {
+        this._log('📝 创建测试提交...');
+        
+        const commitResult = await this._executeCommand(
+            'git commit --allow-empty -m "[权限测试] 临时提交，将自动回退" --no-verify'
+        );
+        
+        if (!commitResult.success) {
+            throw new Error(`创建测试提交失败: ${commitResult.stderr}`);
+        }
+        
+        this._log('✅ 测试提交已创建');
+    }
+
+    /**
+     * 执行推送测试
+     */
+    async _executePushTest() {
+        this._log('🚀 执行推送测试...');
+        
+        const pushResult = await this._executeCommand(
+            `git push ${this.remote} ${this.targetBranch}`,
+            60000 // 推送可能需要更长时间
+        );
+        
+        return pushResult;
+    }
+
+    /**
+     * 恢复原始状态
+     */
+    async _restoreOriginalState() {
+        this._log('🔄 恢复原始状态...');
+        
+        // 1. 重置到原始提交
+        const resetResult = await this._executeCommand(`git reset --hard ${this.testTag}`);
+        if (!resetResult.success) {
+            throw new Error(`重置失败: ${resetResult.stderr}`);
+        }
+        
+        // 2. 强制推送到远程（覆盖测试提交）
+        const forcePushResult = await this._executeCommand(
+            `git push ${this.remote} ${this.targetBranch}`
+        );
+        
+        if (!forcePushResult.success) {
+            this._log(`⚠️  强制推送可能失败: ${forcePushResult.stderr}`);
+            // 不抛出异常，继续清理
+        }
+        
+        // 3. 删除备份标签
+        await this._executeCommand(`git tag -d ${this.testTag}`);
+        
+        this._log('✅ 原始状态已恢复');
+    }
+
+    /**
+     * 紧急清理
+     */
+    async _emergencyCleanup() {
+        this._log('⚠️  执行紧急清理...');
+        
+        try {
+            // 尝试用备份标签恢复
+            await this._executeCommand(`git reset --hard ${this.testTag}`);
+            
+            // 尝试强制推送
+            await this._executeCommand(`git push --force ${this.remote} ${this.targetBranch}`);
+            
+            // 删除标签
+            await this._executeCommand(`git tag -d ${this.testTag}`);
+            
+        } catch (error) {
+            this._log(`❌ 紧急清理失败，可能需要手动干预`);
+            this._log(`手动恢复命令:`);
+            this._log(`  cd ${this.repoPath}`);
+            this._log(`  git reset --hard ${this.testTag}`);
+            this._log(`  git push --force ${this.remote} ${this.targetBranch}`);
+        }
+    }
+
+    /**
+     * 格式化结果
+     */
+    _formatResult(data, isSuccess) {
+        if (isSuccess) {
+            return {
+                hasPermission: true,
+                code: 0,
+                message: '✅ 拥有推送权限',
+                repoPath: this.repoPath,
+                branch: this.targetBranch,
+                details: {
+                    stdout: data.stdout,
+                    stderr: data.stderr
+                },
+                timestamp: new Date().toISOString()
+            };
+        } else {
+            const errorType = this._classifyError(data.stderr || data.message, data.code);
+            
+            return {
+                hasPermission: false,
+                code: data.code || -1,
+                errorType,
+                message: this._getErrorMessage(errorType),
+                repoPath: this.repoPath,
+                branch: this.targetBranch,
+                details: {
+                    stdout: data.stdout || '',
+                    stderr: data.stderr || data.message || '未知错误'
+                },
+                suggestion: this._getSuggestion(errorType),
+                timestamp: new Date().toISOString()
+            };
+        }
+    }
+
+    /**
+     * 错误分类
+     */
+    _classifyError(stderr, code) {
+        const err = stderr.toLowerCase();
+        
+        if (err.includes('permission denied') || err.includes('not allowed')) {
+            return 'PERMISSION_DENIED';
+        }
+        if (err.includes('protected branch')) {
+            return 'BRANCH_PROTECTED';
+        }
+        if (err.includes('authentication') || err.includes('auth failed')) {
+            return 'AUTH_FAILED';
+        }
+        if (err.includes('hook declined')) {
+            return 'HOOK_REJECTED';
+        }
+        if (err.includes('cannot lock ref') || err.includes('would be overwritten')) {
+            return 'CONFLICT_ERROR';
+        }
+        if (code === 128 || err.includes('fatal:')) {
+            return 'GIT_FATAL_ERROR';
+        }
+        if (err.includes('timeout') || code === 124) {
+            return 'TIMEOUT_ERROR';
+        }
+        
+        return 'UNKNOWN_ERROR';
+    }
+
+    _getErrorMessage(type) {
+        const messages = {
+            'PERMISSION_DENIED': '账户对该分支无推送权限',
+            'BRANCH_PROTECTED': '分支受保护，禁止直接推送',
+            'AUTH_FAILED': '身份验证失败',
+            'HOOK_REJECTED': '被服务器钩子脚本拒绝',
+            'CONFLICT_ERROR': '存在冲突或引用被锁定',
+            'GIT_FATAL_ERROR': 'Git命令执行失败',
+            'TIMEOUT_ERROR': '操作超时',
+            'UNKNOWN_ERROR': '未知错误'
+        };
+        return messages[type] || '检测过程中发生错误';
+    }
+
+    _getSuggestion(type) {
+        const suggestions = {
+            'PERMISSION_DENIED': `联系仓库管理员将你的账户添加到 ${this.targetBranch} 分支的推送许可列表`,
+            'BRANCH_PROTECTED': `分支 ${this.targetBranch} 受保护，请使用合并请求(MR/PR)方式提交变更`,
+            'AUTH_FAILED': '检查访问令牌(TOKEN)或SSH密钥是否正确配置，并确保有仓库写入权限',
+            'HOOK_REJECTED': '需要查看服务器pre-receive钩子日志了解具体拒绝原因',
+            'CONFLICT_ERROR': '先执行 git pull 同步最新代码，或检查是否有其他进程在操作Git',
+            'GIT_FATAL_ERROR': '检查Git配置、网络连接和仓库完整性',
+            'TIMEOUT_ERROR': '网络连接较慢，请检查网络或增加超时时间',
+            'UNKNOWN_ERROR': '请查看详细错误输出并联系系统管理员'
+        };
+        return suggestions[type] || '请检查详细错误信息';
+    }
+}
+
+/**
+ * 批量测试多个仓库的权限
+ */
+class BatchPermissionTester {
+    constructor() {
+        this.results = [];
+    }
+    
+    async testRepositories(repositories) {
+        for (const repo of repositories) {
+            const tester = new GitPushPermissionTester({
+                repoPath: repo.path,
+                targetBranch: repo.branch || 'main',
+                remote: repo.remote || 'origin',
+                verbose: repo.verbose || false
+            });
+            
+            const result = await tester.testPushPermission();
+            this.results.push(result);
+            
+            console.log(`\n${'-'.repeat(50)}`);
+            console.log(`仓库: ${repo.path}`);
+            console.log(`分支: ${repo.branch || 'main'}`);
+            console.log(`权限: ${result.hasPermission ? '✅ 有' : '❌ 无'}`);
+            console.log(`信息: ${result.message}`);
+        }
+        
+        return this.results;
+    }
+}
+
+// ============ 使用示例 ============
+
+// 示例1: 测试单个仓库
+async function testSingleRepository() {
+    const tester = new GitPushPermissionTester({
+        repoPath: '/path/to/your/git/repo', // 替换为实际路径
+        targetBranch: 'main',
+        remote: 'origin',
+        verbose: true
+    });
+    
+    console.log('开始测试Git推送权限...\n');
+    
+    const result = await tester.testPushPermission();
+    
+    console.log('\n' + '='.repeat(60));
+    console.log('测试完成!');
+    console.log('='.repeat(60));
+    console.log(`仓库路径: ${result.repoPath}`);
+    console.log(`目标分支: ${result.branch}`);
+    console.log(`权限状态: ${result.hasPermission ? '✅ 有权限' : '❌ 无权限'}`);
+    console.log(`详细信息: ${result.message}`);
+    
+    if (!result.hasPermission) {
+        console.log(`建议: ${result.suggestion}`);
+        console.log(`错误详情: ${result.details.stderr}`);
+    }
+    
+    return result;
+}
+
+// 示例2: 测试多个仓库
+async function testMultipleRepositories() {
+    const repositories = [
+        { path: '/projects/repo1', branch: 'main' },
+        { path: '/projects/repo2', branch: 'develop' },
+        { path: '/projects/repo3', branch: 'production', remote: 'upstream' }
+    ];
+    
+    const batchTester = new BatchPermissionTester();
+    const results = await batchTester.testRepositories(repositories);
+    
+    // 生成报告
+    const summary = {
+        total: results.length,
+        hasPermission: results.filter(r => r.hasPermission).length,
+        noPermission: results.filter(r => !r.hasPermission).length,
+        errors: results.filter(r => r.errorType === 'GIT_FATAL_ERROR').length
+    };
+    
+    console.log('\n' + '='.repeat(60));
+    console.log('批量测试报告');
+    console.log('='.repeat(60));
+    console.log(`总仓库数: ${summary.total}`);
+    console.log(`有权限: ${summary.hasPermission}`);
+    console.log(`无权限: ${summary.noPermission}`);
+    console.log(`错误数: ${summary.errors}`);
+    
+    return results;
+}
+
+// 示例3: 命令行使用
+async function main() {
+    // 从命令行参数获取路径和分支
+    const args = process.argv.slice(2);
+    const repoPath = args[0] || process.cwd();
+    const targetBranch = args[1] || 'main';
+    
+    console.log(`测试目录: ${repoPath}`);
+    console.log(`目标分支: ${targetBranch}`);
+    
+    const tester = new GitPushPermissionTester({
+        repoPath,
+        targetBranch,
+        verbose: true
+    });
+    
+    try {
+        const result = await tester.testPushPermission();
+        
+        // 退出码：0=有权限，1=无权限，2=错误
+        if (result.hasPermission) {
+            console.log('\n✅ 成功: 账户拥有推送权限');
+            process.exit(0);
+        } else {
+            console.log(`\n❌ 失败: ${result.message}`);
+            process.exit(1);
+        }
+    } catch (error) {
+        console.error(`\n💥 错误: ${error.message}`);
+        process.exit(2);
+    }
+}
+
+// 根据需求选择执行方式
+if (require.main === module) {
+    // 直接运行脚本
+    main().catch(console.error);
+}
+
+// 导出模块供其他文件引用
+module.exports = {
+    GitPushPermissionTester,
+    BatchPermissionTester,
+    testSingleRepository,
+    testMultipleRepositories
+};

package/lib/gitCheck.js

@@ -0,0 +1,194 @@
+const { exec } = require('child_process');
+const util = require('util');
+const execPromise = util.promisify(exec);
+
+class DirectBranchPushTester {
+    constructor(targetBranch, remote = 'origin') {
+        this.targetBranch = targetBranch;
+        this.remote = remote;
+        this.testTag = null; // 用于标记原始提交
+    }
+
+    /**
+     * 主测试方法
+     * @returns {Promise<Object>} 测试结果
+     */
+    async testPushPermission() {
+        console.log(`🔍 开始测试对 ${this.remote}/${this.targetBranch} 的直接推送权限...`);
+
+        try {
+            // 1. 保存当前状态
+            await this._saveOriginalState();
+            
+            // 2. 创建空测试提交
+            await this._createTestCommit();
+            
+            // 3. 执行真实推送测试（核心权限检查点）
+            const pushResult = await this._executePush();
+            
+            // 4. 无论成功与否，都尝试恢复原始状态
+            await this._restoreOriginalState();
+            
+            // 5. 返回格式化的测试结果
+            return this._formatSuccessResult(pushResult);
+            
+        } catch (error) {
+            // 6. 失败时，尽最大努力恢复并返回错误信息
+            await this._emergencyCleanup().catch(() => {});
+            return this._formatErrorResult(error);
+        }
+    }
+
+    /* ---------- 核心步骤 ---------- */
+    async _saveOriginalState() {
+        // 获取当前分支最新的提交ID，并创建一个临时标签以便回退
+        const { stdout } = await execPromise(`git rev-parse HEAD`);
+        const originalCommit = stdout.trim();
+        this.testTag = `push_test_backup_${Date.now()}`;
+        await execPromise(`git tag ${this.testTag} ${originalCommit}`);
+        console.log(`📌 已创建备份标签: ${this.testTag}`);
+    }
+
+    async _createTestCommit() {
+        // 创建一个不改变工作区的空提交
+        await execPromise(
+            `git commit --allow-empty -m "[自动化权限测试] 临时提交，即将回退" --no-verify`
+        );
+        console.log('📝 已创建空测试提交');
+    }
+
+    async _executePush() {
+        try {
+            // 关键：执行真实推送
+            const { stdout, stderr } = await execPromise(
+                `git push ${this.remote} ${this.targetBranch}`,
+                { timeout: 30000, maxBuffer: 10 * 1024 * 1024 }
+            );
+            return { code: 0, stdout, stderr };
+        } catch (error) {
+            return {
+                code: error.code,
+                stdout: error.stdout,
+                stderr: error.stderr,
+                message: error.message
+            };
+        }
+    }
+
+    async _restoreOriginalState() {
+        console.log('🔄 开始恢复分支原始状态...');
+        
+        // 1. 硬重置到原始提交（丢弃测试提交）
+        await execPromise(`git reset --hard ${this.testTag}`);
+        
+        // 2. 强制推送到远程（覆盖远程的测试提交）
+        await execPromise(`git push --force ${this.remote} ${this.targetBranch}`);
+        
+        // 3. 删除本地备份标签
+        await execPromise(`git tag -d ${this.testTag}`);
+        
+        console.log('✅ 分支状态已完全恢复');
+    }
+
+    async _emergencyCleanup() {
+        // 应急清理：如果上述流程中断，尝试用备份标签恢复
+        if (this.testTag) {
+            try {
+                await execPromise(`git reset --hard ${this.testTag}`);
+                await execPromise(`git push --force ${this.remote} ${this.targetBranch}`);
+                await execPromise(`git tag -d ${this.testTag}`);
+            } catch (e) {
+                console.error('⚠️  应急清理失败，可能需要手动处理');
+                console.error(`手动恢复命令: git reset --hard ${this.testTag} && git push --force ${this.remote} ${this.targetBranch}`);
+            }
+        }
+    }
+
+    /* ---------- 结果处理 ---------- */
+    _formatSuccessResult(pushResult) {
+        return {
+            hasPermission: true,
+            code: 0,
+            message: '✅ 拥有直接推送权限',
+            details: {
+                stdout: pushResult.stdout,
+                stderr: pushResult.stderr
+            },
+            note: '分支已恢复至测试前状态'
+        };
+    }
+
+    _formatErrorResult(error) {
+        // 分析错误类型
+        const errorType = this._classifyError(error.stderr || error.message, error.code);
+        
+        return {
+            hasPermission: false,
+            code: error.code || -1,
+            errorType,
+            message: this._getErrorMessage(errorType),
+            details: {
+                stdout: error.stdout,
+                stderr: error.stderr || error.message
+            },
+            suggestion: this._getSuggestion(errorType),
+            note: '分支已恢复至测试前状态'
+        };
+    }
+
+    _classifyError(stderr, code) {
+        const err = stderr.toLowerCase();
+        if (err.includes('permission denied') || err.includes('not allowed')) return 'PERMISSION_DENIED';
+        if (err.includes('protected branch')) return 'BRANCH_PROTECTED';
+        if (err.includes('authentication')) return 'AUTH_FAILED';
+        if (err.includes('hook declined')) return 'HOOK_REJECTED';
+        if (code === 128) return 'NETWORK_OR_AUTH_ERROR';
+        return 'UNKNOWN_ERROR';
+    }
+
+    _getErrorMessage(type) {
+        const messages = {
+            'PERMISSION_DENIED': '账户对该分支无推送权限',
+            'BRANCH_PROTECTED': '分支受保护，禁止直接推送',
+            'AUTH_FAILED': '身份验证失败',
+            'HOOK_REJECTED': '被服务器钩子拒绝',
+            'NETWORK_OR_AUTH_ERROR': '网络或基础认证错误',
+            'UNKNOWN_ERROR': '未知错误'
+        };
+        return messages[type] || '检测过程中发生错误';
+    }
+
+    _getSuggestion(type) {
+        const suggestions = {
+            'PERMISSION_DENIED': '联系仓库管理员将你的账户添加到分支推送许可列表',
+            'BRANCH_PROTECTED': '通常需要创建合并请求(MR/PR)，请检查分支保护规则',
+            'AUTH_FAILED': '检查使用的访问令牌(TOKEN)或SSH密钥是否有对应仓库的写入权限',
+            'HOOK_REJECTED': '需查看服务器pre-receive钩子日志了解具体拒绝原因',
+            'NETWORK_OR_AUTH_ERROR': '检查远程仓库地址、网络连接及基础Git认证信息',
+            'UNKNOWN_ERROR': '请提供完整错误信息以便进一步排查'
+        };
+        return suggestions[type] || '请查看详细错误输出';
+    }
+}
+module.exports = DirectBranchPushTester;
+
+// /* ---------- 使用示例 ---------- */
+// async function main() {
+//     // 测试对 main 分支的推送权限
+//     const tester = new DirectBranchPushTester('main', 'origin');
+    
+//     const result = await tester.testPushPermission();
+    
+//     console.log('\n=== 测试结果 ===');
+//     console.log(JSON.stringify(result, null, 2));
+    
+//     if (result.hasPermission) {
+//         console.log('\n结论: 账户拥有对该分支的直接推送权限。');
+//     } else {
+//         console.log(`\n结论: ${result.message}`);
+//         console.log(`建议: ${result.suggestion}`);
+//     }
+// }
+
+// // 执行
+// main().catch(console.error);

package/lib/server.js

@@ -160,21 +160,6 @@ function createServer(app, options) {
 
   app.webPath = webPath; // handler.js里面动态获取当前app的网站路径（多个server实例的时候需要）
 
-
-  // 业务ap的代理转发（可能转发静态资源，放到前面）
-  if (config.proxy) {
-    var { createProxyMiddleware } = require('http-proxy-middleware');
-    if (Array.isArray(config.proxy)) { // 兼容代理配置是数组
-      for (const item of config.proxy) {
-        app.use(createProxyMiddleware(item))
-      }
-    } else {
-      for (let key in config.proxy) {
-        app.use(key, createProxyMiddleware(config.proxy[key]));
-      }
-    }
-  }
-
   app.use(express.static(webPath, {
     maxage: '100h', // 强制缓存资源
     setHeaders: function(res, pathname, stat) {
@@ -195,6 +180,20 @@ function createServer(app, options) {
     }
   }));
 
+  // 业务ap的代理转发
+  if (config.proxy) {
+    var { createProxyMiddleware } = require('http-proxy-middleware');
+    if (Array.isArray(config.proxy)) { // 兼容代理配置是数组
+      for (const item of config.proxy) {
+        app.use(createProxyMiddleware(item))
+      }
+    } else {
+      for (let key in config.proxy) {
+        app.use(key, createProxyMiddleware(config.proxy[key]));
+      }
+    }
+  }
+
   var bodyParser = require('body-parser');
   app.use(bodyParser.json(utils._getJsonDefaultOptions({})));
   app.use(bodyParser.raw(utils._getJsonDefaultOptions({})));

package/lib/utils.js

@@ -9,6 +9,8 @@ var compressing = require('compressing');
 var axios = require('axios');
 var os = require('os');
 const { execSync } = require('child_process');
+const util = require('util');
+const execPromise = util.promisify(execSync);
 
 if (!String.prototype.replaceAll) {
   String.prototype.replaceAll = function(search, replacement) {
@@ -1229,6 +1231,32 @@ class Utils {
       }
     }
   }
+
+
+  /**
+ * 在指定目录执行命令
+ */
+  async executeCommand(command, repoPath = config.webPath, timeout = 30000) {
+    console.log(`执行: ${command}`);
+
+    try {
+      const { stdout, stderr } = await execPromise(command, {
+        cwd: repoPath,
+        timeout,
+        maxBuffer: 10 * 1024 * 1024,
+        encoding: 'utf-8'
+      });
+      return { success: true, stdout: stdout.trim(), stderr: stderr.trim() };
+    } catch (error) {
+      return {
+        success: false,
+        code: error.code,
+        stdout: error.stdout ? error.stdout.trim() : '',
+        stderr: error.stderr ? error.stderr.trim() : error.message,
+        error: error.message
+      };
+    }
+  }
 }
 var utils = new Utils();
 module = module.exports = utils;

package/package.json

@@ -1,6 +1,6 @@
 {
   "name": "crabatool",
-  "version": "1.0.817",
+  "version": "1.0.820",
   "description": "crabatool",
   "main": "index.js",
   "bin": {
@@ -13,7 +13,8 @@
     "sale-doc": "node ./test/test.js -convertJavadoc -targetPath F:/docs/sale -outPath F:/docs/sale.json",
     "start": "node run.js",
     "test": "node ./test/test.js",
-    "run": "node ./test/test.js -run -webPath F:/basicweb/www -refresh true",
+    "test_git": "node ./test/git.js -webPath F:/basicweb/www",
+    "run": "node ./test/test.js -run -webPath F:/basicweb/www -refresh true -proxy \"{'/shell/framework/':{'target':'http://127.0.0.1:8339','changeOrigin':true,'logLevel':'debug'}}\"",
     "mergeinitjs": "node ./test/test.js -mergeinitjs",
     "export": "node ./test/test.js -exportgspx -webPath F:/Beefun/srcs",
     "checkjs": "node ./test/test.js -checkjs",

package/tool/merge/mergeTool.js

@@ -93,13 +93,19 @@ function buildFolder(options) {
     if (config.exp) {
       var list = config.exp.split(';');
       list.forEach(function(item) {
+        if (!item) return;
         var arr = item.split('=');
-        var key = arr[0].trim();
+        var key = (arr[0] || '').trim();
+        if (!key) return;
+
         var value;
         if (key == '$versionDate$') {
           value = new Date().toString('yyyyMMddhh');
-        } else {
+        } else if (arr.length > 1 && arr[1] != null) {
           value = arr[1].trim();
+        } else {
+          utils.log('exp变量格式不正确，已忽略:' + item);
+          return;
         }
         content = content.replaceAll(key, value);
 
@@ -280,4 +286,4 @@ function copyByteToCache(filePath, content, stats, options) {
   utils.debug("拷贝到缓存:" + cachePath);
   fs.writeFileSync(cachePath, content, 'utf8');
   fs.utimesSync(cachePath, stats.atime, stats.mtime); // 必须同步文件时间
-}
+}

package/tool/upgrade.js

@@ -58,7 +58,87 @@ class Upgrade {
     return { version: version, date: vDate };
   }
 
-  checkUpdateCraba() {
+  async checkUpdateCraba() {
+    var result = await this.checkGitPermission();
+    if (!result) {
+      console.log('没有git推送权限，取消craba的更新操作');
+      return;
+    }
+
+    console.log('当前git有推送权限,开始检查更新craba');
+
+    this.checkUpdateCrabaNext();
+  }
+
+  async checkGitPermission() {
+    //git commit --allow-empty -m "测试空提交"
+    console.log('检查当前git是否有推送权限');
+
+    console.log('🚀 创建空白提交...');
+    const commitResult = await utils.executeCommand(
+      'git commit --allow-empty -m "[检测推送权限测试提交] 空白提交，无需关注" --no-verify'
+    );
+
+    if (!commitResult.success) {
+      console.log(`创建测试提交失败: ${commitResult.stderr}`);
+      return false;
+    }
+
+    var branchName = config.branchName || config.version;
+    branchName = branchName.replace('origin/', '');
+
+    var gitCmd = `git push origin ${branchName}`;
+    console.log('🚀 执行推送测试是否有权限...');
+    const pushResult = await utils.executeCommand(
+      gitCmd,
+      60000 // 推送可能需要更长时间
+    );
+
+    if (!pushResult.success) {
+      console.log(`没有推送权限: ${pushResult.stderr}`);
+      return false;
+    }
+
+    if (this.classifyError(pushResult.stderr || pushResult.message, pushResult.code)) {
+      return false;
+    }
+
+    return true;
+  }
+
+  /**
+    * 错误分类
+    */
+  classifyError(stderr, code) {
+    if (!stderr) return false;
+    const err = stderr.toLowerCase();
+    if (err.includes('permission denied') || err.includes('not allowed')) {
+      return 'PERMISSION_DENIED';
+    }
+    if (err.includes('protected branch')) {
+      return 'BRANCH_PROTECTED';
+    }
+    if (err.includes('authentication') || err.includes('auth failed')) {
+      return 'AUTH_FAILED';
+    }
+    if (err.includes('hook declined')) {
+      return 'HOOK_REJECTED';
+    }
+    if (err.includes('cannot lock ref') || err.includes('would be overwritten')) {
+      return 'CONFLICT_ERROR';
+    }
+    if (code === 128 || err.includes('fatal:')) {
+      return 'GIT_FATAL_ERROR';
+    }
+    if (err.includes('timeout') || code === 124) {
+      return 'TIMEOUT_ERROR';
+    }
+
+    return false;
+  }
+
+
+  checkUpdateCrabaNext() {
     var host = config.SourceHost;
     var version = config.version; // 默认临时目录下
     var host = config.host || config.SourceHost;