phantomx-tool-client 2.1.0 → 2.1.2

package/dist/githubOperationsHanlder.js

@@ -64,6 +64,19 @@ function executeShell(command) {
         });
     });
 }
+// ---------------------------------------------------------------------------
+// Per-repo async mutex — serialises all git remote set-url operations so that
+// concurrent tool calls never race on .git/config.lock for the same repo.
+// ---------------------------------------------------------------------------
+const repoLocks = new Map();
+function withRepoLock(repoName, fn) {
+    var _a;
+    const prev = (_a = repoLocks.get(repoName)) !== null && _a !== void 0 ? _a : Promise.resolve();
+    let releaseLock;
+    const lockAcquired = new Promise(res => { releaseLock = res; });
+    repoLocks.set(repoName, prev.then(() => lockAcquired));
+    return prev.then(() => fn()).finally(() => releaseLock());
+}
 // Use the official 'octokit' package import via require to avoid missing types for '@octokit/rest'
 const { Octokit } = require('octokit');
 const logger = (0, Logger_1.createLogger)('GithubOperationsService');
@@ -597,25 +610,26 @@ class GithubOperationsService {
         const repoPath = `${tool_server_1.folderPath}/${repoName}`;
         const installationToken = await fetchInstallationToken();
         const gitOrgName = await getGithubOrganizationName();
-        try {
-            logger.info('Getting repository origin/default branch', { repoName });
-            // Set authenticated remote URL
-            await executeShell(`cd ${repoPath} && sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git`);
-            // Fetch remote HEAD to find the default branch
-            const result = await executeShell(`cd ${repoPath} && sudo git remote show origin | grep 'HEAD branch' | awk '{print $NF}'`);
-            // Restore unauthenticated remote URL
-            await executeShell(`cd ${repoPath} && sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git`);
-            if (!result.success || !result.output.trim()) {
-                throw new Error(`Failed to get origin branch for repo '${repoName}': ${result.error || result.output}`);
-            }
-            const originBranch = result.output.trim();
-            logger.success('Repository origin branch retrieved', { repoName, originBranch });
-            return {
-                repoName,
-                originBranch
-            };
-        }
-        finally { }
+        return withRepoLock(repoName, async () => {
+            try {
+                logger.info('Getting repository origin/default branch', { repoName });
+                // Set token URL, query origin, restore URL — single pipeline to prevent lock races.
+                const result = await executeShell(`cd ${repoPath} && rm -f .git/config.lock && ` +
+                    `git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git && ` +
+                    `sudo git remote show origin | grep 'HEAD branch' | awk '{print $NF}' && ` +
+                    `git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git`);
+                if (!result.success || !result.output.trim()) {
+                    throw new Error(`Failed to get origin branch for repo '${repoName}': ${result.error || result.output}`);
+                }
+                const originBranch = result.output.trim();
+                logger.success('Repository origin branch retrieved', { repoName, originBranch });
+                return {
+                    repoName,
+                    originBranch
+                };
+            }
+            finally { }
+        }); // end withRepoLock
     }
     /**
      * List branches for a repository
@@ -636,40 +650,38 @@ class GithubOperationsService {
         const repoPath = `${tool_server_1.folderPath}/${repoName}`;
         const installationToken = await fetchInstallationToken();
         const gitOrgName = await getGithubOrganizationName();
-        try {
-            // Get current local branch name
-            let result = await executeShell(`cd ${repoPath} && sudo git rev-parse --abbrev-ref HEAD`);
-            if (!result.success) {
-                throw new Error(`Failed to get current branch: ${result.error}`);
-            }
-            const currentBranch = result.output.trim();
-            logger.info('starting git pull operation', { repoName, currentBranch });
-            // Set remote url with token
-            result = await executeShell(`cd ${repoPath} && sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git`);
-            if (!result.success) {
-                throw new Error(`Failed to set remote URL: ${result.error}`);
-            }
-            result = await executeShell(`cd ${repoPath} && sudo git fetch origin`);
-            if (!result.success) {
-                throw new Error(`Failed to fetch from remote: ${result.error}`);
+        return withRepoLock(repoName, async () => {
+            try {
+                // Get current local branch name
+                let result = await executeShell(`cd ${repoPath} && sudo git rev-parse --abbrev-ref HEAD`);
+                if (!result.success) {
+                    throw new Error(`Failed to get current branch: ${result.error}`);
+                }
+                const currentBranch = result.output.trim();
+                logger.info('starting git pull operation', { repoName, currentBranch });
+                // Token-URL, fetch, pull, restore URL — all in one pipeline to prevent
+                // concurrent operations from racing on .git/config.lock.
+                result = await executeShell(`cd ${repoPath} && rm -f .git/config.lock && ` +
+                    `git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git && ` +
+                    `sudo git fetch origin && ` +
+                    `sudo git pull --no-rebase origin ${currentBranch} ; ` +
+                    `git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git`);
+                if (!result.success && result.code !== 128) {
+                    throw new Error(`Failed to pull branch ${currentBranch}: ${result.error}`);
+                }
+                logger.success('Git pull completed successfully', { repoName, currentBranch });
+                // Get merge conflicts
+                const mergeConflicts = await this.getMergeConflicts(repoName);
+                return {
+                    repoName,
+                    branchName: currentBranch,
+                    lastCommit: result.output.trim(),
+                    mergeConflicts
+                };
             }
-            result = await executeShell(`cd ${repoPath} && sudo git pull --no-rebase origin ${currentBranch}`);
-            if (!result.success && result.code !== 128) {
-                throw new Error(`Failed to pull branch ${currentBranch}: ${result.error}`);
+            finally {
             }
-            await executeShell(`cd ${repoPath} && sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git`);
-            logger.success('Git pull completed successfully', { repoName, currentBranch });
-            // Get merge conflicts
-            const mergeConflicts = await this.getMergeConflicts(socket, repoName);
-            return {
-                repoName,
-                branchName: currentBranch,
-                lastCommit: result.output.trim(),
-                mergeConflicts
-            };
-        }
-        finally {
-        }
+        }); // end withRepoLock
     }
     /**
      * Push repository to remote
@@ -678,55 +690,58 @@ class GithubOperationsService {
         const repoPath = `${tool_server_1.folderPath}/${repoName}`;
         const installationToken = await fetchInstallationToken();
         const gitOrgName = await getGithubOrganizationName();
-        try {
-            logger.info('Starting git push operation', { repoName });
-            // Combine all commands into a single SSH call
-            const combinedCommand = `
+        return withRepoLock(repoName, async () => {
+            try {
+                logger.info('Starting git push operation', { repoName });
+                // Combine all commands into a single SSH call
+                const combinedCommand = `
                 cd ${repoPath} &&
+                rm -f .git/config.lock &&
                 BRANCH=$(sudo git rev-parse --abbrev-ref HEAD) &&
                 COMMITS_AHEAD=$(sudo git rev-list --count origin/$BRANCH..HEAD 2>/dev/null || echo 0) &&
                 if [ "$COMMITS_AHEAD" = "0" ]; then
                     echo "ERROR:NO_COMMITS";
                     exit 1;
                 fi &&
-                sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
+                git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
                 sudo git push origin $BRANCH &&
-                sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git &&
+                git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git &&
                 COMMIT_HASH=$(sudo git rev-parse HEAD) &&
                 echo "BRANCH:$BRANCH" &&
                 echo "COMMITS_AHEAD:$COMMITS_AHEAD" &&
                 echo "COMMIT_HASH:$COMMIT_HASH"
             `.replace(/\n\s+/g, ' ');
-            const result = await executeShell(combinedCommand);
-            if (!result.success) {
-                if (result.output && result.output.includes('ERROR:NO_COMMITS')) {
-                    throw new Error('No commits to push');
+                const result = await executeShell(combinedCommand);
+                if (!result.success) {
+                    if (result.output && result.output.includes('ERROR:NO_COMMITS')) {
+                        throw new Error('No commits to push');
+                    }
+                    throw new Error('Failed to push repository');
+                }
+                // Parse output
+                const output = result.output;
+                const branchMatch = output.match(/BRANCH:([^\n]+)/);
+                const commitsAheadMatch = output.match(/COMMITS_AHEAD:(\d+)/);
+                const commitHashMatch = output.match(/COMMIT_HASH:([a-f0-9]+)/);
+                const currentBranch = branchMatch ? branchMatch[1].trim() : 'unknown';
+                const commitsAhead = commitsAheadMatch ? parseInt(commitsAheadMatch[1]) : 0;
+                const commitHash = commitHashMatch ? commitHashMatch[1].trim() : 'unknown';
+                logger.success('Git push completed successfully', { repoName, currentBranch, commitHash, commitsAhead });
+                // Emit socket event to refresh repo on client (only when called by AI agent)
+                if (socket) {
+                    socket.emit('refresh_repo', { repoName });
                 }
-                throw new Error('Failed to push repository');
+                return {
+                    repoName,
+                    branchName: currentBranch,
+                    commitHash,
+                    commitsAhead,
+                    pushedAt: new Date().toISOString()
+                };
             }
-            // Parse output
-            const output = result.output;
-            const branchMatch = output.match(/BRANCH:([^\n]+)/);
-            const commitsAheadMatch = output.match(/COMMITS_AHEAD:(\d+)/);
-            const commitHashMatch = output.match(/COMMIT_HASH:([a-f0-9]+)/);
-            const currentBranch = branchMatch ? branchMatch[1].trim() : 'unknown';
-            const commitsAhead = commitsAheadMatch ? parseInt(commitsAheadMatch[1]) : 0;
-            const commitHash = commitHashMatch ? commitHashMatch[1].trim() : 'unknown';
-            logger.success('Git push completed successfully', { repoName, currentBranch, commitHash, commitsAhead });
-            // Emit socket event to refresh repo on client (only when called by AI agent)
-            if (socket) {
-                socket.emit('refresh_repo', { repoName });
+            finally {
             }
-            return {
-                repoName,
-                branchName: currentBranch,
-                commitHash,
-                commitsAhead,
-                pushedAt: new Date().toISOString()
-            };
-        }
-        finally {
-        }
+        }); // end withRepoLock
     }
     /**
      * Check repository status
@@ -735,15 +750,21 @@ class GithubOperationsService {
         const repoPath = `${tool_server_1.folderPath}/${repoName}`;
         const installationToken = await fetchInstallationToken();
         const gitOrgName = await getGithubOrganizationName();
-        try {
-            logger.info('Checking repository status', { repoName });
-            // Combine all git commands into a single SSH call
-            const combinedCommand = `
+        return withRepoLock(repoName, async () => {
+            try {
+                logger.info('Checking repository status', { repoName });
+                // Combine all git commands into a single SSH call
+                // Remove any stale .git/config.lock before touching remote config
+                // (a crashed/interrupted previous run can leave this lock behind).
+                // Also avoid sudo for git remote set-url so the lock file is never
+                // created as root-owned, which would block subsequent cleanup.
+                const combinedCommand = `
                 cd ${repoPath} &&
+                rm -f .git/config.lock &&
                 BRANCH=$(sudo git rev-parse --abbrev-ref HEAD) &&
-                sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
+                git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
                 sudo git fetch origin &&
-                sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git &&
+                git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git &&
                 BEHIND=$(sudo git rev-list --count HEAD..origin/$BRANCH 2>/dev/null || echo 0) &&
                 AHEAD=$(sudo git rev-list --count origin/$BRANCH..HEAD 2>/dev/null || echo 0) &&
                 STATUS=$(sudo git status --porcelain) &&
@@ -756,54 +777,55 @@ class GithubOperationsService {
                 echo "CURRENT:$CURRENT_HASH" &&
                 echo "REMOTE:$REMOTE_HASH"
             `.replace(/\n\s+/g, ' ');
-            const result = await executeShell(combinedCommand);
-            if (!result.success) {
-                throw new Error('Failed to check repository status');
+                const result = await executeShell(combinedCommand);
+                if (!result.success) {
+                    throw new Error('Failed to check repository status: ' + result.error);
+                }
+                // Parse the output
+                const output = result.output;
+                const branchMatch = output.match(/BRANCH:([^\n]+)/);
+                const behindMatch = output.match(/BEHIND:(\d+)/);
+                const aheadMatch = output.match(/AHEAD:(\d+)/);
+                const statusMatch = output.match(/STATUS:([\s\S]*?)(?=CURRENT:|$)/);
+                const currentMatch = output.match(/CURRENT:([a-f0-9]+)/);
+                const remoteMatch = output.match(/REMOTE:([a-f0-9]+|unknown)/);
+                const currentBranch = branchMatch ? branchMatch[1].trim() : 'unknown';
+                const commitsBehind = behindMatch ? parseInt(behindMatch[1]) : 0;
+                const commitsAhead = aheadMatch ? parseInt(aheadMatch[1]) : 0;
+                const statusOutput = statusMatch ? statusMatch[1].trim() : '';
+                const hasUncommittedChanges = statusOutput.length > 0;
+                const currentCommitHash = currentMatch ? currentMatch[1].trim() : 'unknown';
+                const remoteCommitHash = remoteMatch ? remoteMatch[1].trim() : 'unknown';
+                const isUpToDate = commitsBehind === 0 && commitsAhead === 0;
+                const needsPull = commitsBehind > 0;
+                const needsPush = commitsAhead > 0;
+                logger.info('Repository status checked', {
+                    repoName,
+                    commitsBehind,
+                    commitsAhead,
+                    hasUncommittedChanges,
+                    isUpToDate
+                });
+                // Check for merge conflicts
+                const mergeConflicts = await this.getMergeConflicts(repoName);
+                return {
+                    repoName,
+                    branchName: currentBranch,
+                    currentCommitHash,
+                    remoteCommitHash,
+                    commitsBehind,
+                    commitsAhead,
+                    hasUncommittedChanges,
+                    isUpToDate,
+                    needsPull,
+                    needsPush,
+                    mergeConflicts,
+                    status: isUpToDate ? 'up-to-date' : (needsPull && needsPush ? 'diverged' : needsPull ? 'behind' : 'ahead')
+                };
             }
-            // Parse the output
-            const output = result.output;
-            const branchMatch = output.match(/BRANCH:([^\n]+)/);
-            const behindMatch = output.match(/BEHIND:(\d+)/);
-            const aheadMatch = output.match(/AHEAD:(\d+)/);
-            const statusMatch = output.match(/STATUS:([\s\S]*?)(?=CURRENT:|$)/);
-            const currentMatch = output.match(/CURRENT:([a-f0-9]+)/);
-            const remoteMatch = output.match(/REMOTE:([a-f0-9]+|unknown)/);
-            const currentBranch = branchMatch ? branchMatch[1].trim() : 'unknown';
-            const commitsBehind = behindMatch ? parseInt(behindMatch[1]) : 0;
-            const commitsAhead = aheadMatch ? parseInt(aheadMatch[1]) : 0;
-            const statusOutput = statusMatch ? statusMatch[1].trim() : '';
-            const hasUncommittedChanges = statusOutput.length > 0;
-            const currentCommitHash = currentMatch ? currentMatch[1].trim() : 'unknown';
-            const remoteCommitHash = remoteMatch ? remoteMatch[1].trim() : 'unknown';
-            const isUpToDate = commitsBehind === 0 && commitsAhead === 0;
-            const needsPull = commitsBehind > 0;
-            const needsPush = commitsAhead > 0;
-            logger.info('Repository status checked', {
-                repoName,
-                commitsBehind,
-                commitsAhead,
-                hasUncommittedChanges,
-                isUpToDate
-            });
-            // Check for merge conflicts
-            const mergeConflicts = await this.getMergeConflicts(socket, repoName);
-            return {
-                repoName,
-                branchName: currentBranch,
-                currentCommitHash,
-                remoteCommitHash,
-                commitsBehind,
-                commitsAhead,
-                hasUncommittedChanges,
-                isUpToDate,
-                needsPull,
-                needsPush,
-                mergeConflicts,
-                status: isUpToDate ? 'up-to-date' : (needsPull && needsPush ? 'diverged' : needsPull ? 'behind' : 'ahead')
-            };
-        }
-        finally {
-        }
+            finally {
+            }
+        }); // end withRepoLock
     }
     /**
      * Get repository history
@@ -1049,183 +1071,186 @@ class GithubOperationsService {
         const repoPath = `${tool_server_1.folderPath}/${repoName}`;
         const installationToken = await fetchInstallationToken();
         const gitOrgName = await getGithubOrganizationName();
-        try {
-            logger.info('Creating pull request', { repoName, targetBranch });
-            // Combine commands into a single SSH call, with remote URL set/unset
-            const combinedCommand = `
+        return withRepoLock(repoName, async () => {
+            try {
+                logger.info('Creating pull request', { repoName, targetBranch });
+                // Combine commands into a single SSH call, with remote URL set/unset
+                const combinedCommand = `
                 cd ${repoPath} &&
-                sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
+                rm -f .git/config.lock &&
+                git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
                 HEAD_BRANCH=$(sudo git rev-parse --abbrev-ref HEAD) &&
                 sudo git fetch origin ${targetBranch} 2>/dev/null &&
                 COMMITS_AHEAD=$(sudo git rev-list --count origin/${targetBranch}..$HEAD_BRANCH 2>/dev/null || echo 0) &&
                 if [ "$COMMITS_AHEAD" = "0" ]; then
                     echo "ERROR:NO_COMMITS:$HEAD_BRANCH";
-                    sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git;
+                    git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git;
                     exit 1;
                 fi &&
                 echo "HEAD_BRANCH:$HEAD_BRANCH" &&
                 echo "COMMITS_AHEAD:$COMMITS_AHEAD" &&
-                sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git
+                git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git
             `.replace(/\n\s+/g, ' ');
-            let result = await executeShell(combinedCommand);
-            const output = result.output || '';
-            const headBranchMatch = output.match(/HEAD_BRANCH:([^\n]+)/);
-            const commitsAheadMatch = output.match(/COMMITS_AHEAD:(\d+)/);
-            const errorMatch = output.match(/ERROR:NO_COMMITS:([^\n]+)/);
-            let headBranch = headBranchMatch ? headBranchMatch[1].trim() : 'unknown';
-            const commitsAhead = commitsAheadMatch ? parseInt(commitsAheadMatch[1]) : 0;
-            if (!result.success && errorMatch) {
-                headBranch = errorMatch[1].trim();
-            }
-            // using 'octokit' package (already installed, @octokit/rest is not installed)
-            const { Octokit } = require('octokit');
-            const octokit = new Octokit({
-                auth: installationToken
-            });
-            // Always check for existing PR first even if there are no new commits
-            try {
-                const existingPRs = await octokit.rest.pulls.list({
-                    owner: gitOrgName,
-                    repo: repoName,
-                    head: `${gitOrgName}:${headBranch}`,
-                    base: targetBranch,
-                    state: 'open'
+                let result = await executeShell(combinedCommand);
+                const output = result.output || '';
+                const headBranchMatch = output.match(/HEAD_BRANCH:([^\n]+)/);
+                const commitsAheadMatch = output.match(/COMMITS_AHEAD:(\d+)/);
+                const errorMatch = output.match(/ERROR:NO_COMMITS:([^\n]+)/);
+                let headBranch = headBranchMatch ? headBranchMatch[1].trim() : 'unknown';
+                const commitsAhead = commitsAheadMatch ? parseInt(commitsAheadMatch[1]) : 0;
+                if (!result.success && errorMatch) {
+                    headBranch = errorMatch[1].trim();
+                }
+                // using 'octokit' package (already installed, @octokit/rest is not installed)
+                const { Octokit } = require('octokit');
+                const octokit = new Octokit({
+                    auth: installationToken
                 });
-                if (existingPRs.data.length > 0) {
-                    const existingPR = existingPRs.data[0];
-                    logger.info('Pull request already exists', {
+                // Always check for existing PR first even if there are no new commits
+                try {
+                    const existingPRs = await octokit.rest.pulls.list({
+                        owner: gitOrgName,
+                        repo: repoName,
+                        head: `${gitOrgName}:${headBranch}`,
+                        base: targetBranch,
+                        state: 'open'
+                    });
+                    if (existingPRs.data.length > 0) {
+                        const existingPR = existingPRs.data[0];
+                        logger.info('Pull request already exists', {
+                            repoName,
+                            prNumber: existingPR.number,
+                            prUrl: existingPR.html_url
+                        });
+                        const resultData = {
+                            repoName,
+                            headBranch,
+                            targetBranch,
+                            prNumber: existingPR.number,
+                            prUrl: existingPR.html_url,
+                            prTitle: existingPR.title,
+                            commitsAhead,
+                            createdAt: existingPR.created_at,
+                            alreadyExists: true
+                        };
+                        // Emit socket event to refresh PR status on client
+                        if (socket) {
+                            socket.emit('refresh_pr_status', { repoName, prNumber: existingPR.number });
+                        }
+                        // the socket server our main server will automatically update the pr metadata in db when i recvs the result of the given tool.
+                        //   this.updatePRMetadata(userId, resultData);
+                        return resultData;
+                    }
+                }
+                catch (fetchError) {
+                    logger.error('Failed to check for existing PR', fetchError);
+                }
+                // No existing PR found - check if we have commits to create one
+                if (!result.success) {
+                    if (errorMatch) {
+                        throw new Error(`No commits to create PR. Branch '${headBranch}' is not ahead of '${targetBranch}'`);
+                    }
+                    throw new Error('Failed to prepare pull request');
+                }
+                // Create new PR
+                const prTitle = title || `Merge ${headBranch} into ${targetBranch}`;
+                const prBody = body || `This pull request merges changes from ${headBranch} into ${targetBranch}.\n\nCreated by AI-Playgrounds`;
+                try {
+                    const prResponse = await octokit.rest.pulls.create({
+                        owner: gitOrgName,
+                        repo: repoName,
+                        title: prTitle,
+                        body: prBody,
+                        head: headBranch,
+                        base: targetBranch
+                    });
+                    const prUrl = prResponse.data.html_url;
+                    const prNumber = prResponse.data.number;
+                    logger.success('Pull request created successfully', {
                         repoName,
-                        prNumber: existingPR.number,
-                        prUrl: existingPR.html_url
+                        prNumber,
+                        prUrl
                     });
+                    // taskInfo.status = TaskStatus.Completed;
+                    // taskInfo.nonRunningSince = new Date();
+                    // //updating the task status in the db
+                    // let dbService = await getDBService();
+                    // let taskHanlder = dbService.getRepository<Task>(ds.UserInfo.get(userId as any)?.dbName, CollectionNames.TASKS);
+                    // taskHanlder.updateOne({
+                    //     taskId: taskId
+                    // },
+                    //     {
+                    //         "$set": {
+                    //             status: TaskStatus.Completed
+                    //         }
+                    //     });
                     const resultData = {
                         repoName,
                         headBranch,
                         targetBranch,
-                        prNumber: existingPR.number,
-                        prUrl: existingPR.html_url,
-                        prTitle: existingPR.title,
+                        prNumber,
+                        prUrl,
+                        prTitle,
                         commitsAhead,
-                        createdAt: existingPR.created_at,
-                        alreadyExists: true
+                        createdAt: new Date().toISOString()
                     };
-                    // Emit socket event to refresh PR status on client
-                    if (socket) {
-                        socket.emit('refresh_pr_status', { repoName, prNumber: existingPR.number });
-                    }
-                    // the socket server our main server will automatically update the pr metadata in db when i recvs the result of the given tool.
-                    //   this.updatePRMetadata(userId, resultData);
+                    // // Emit socket event to refresh PR status on client
+                    // if (socket) {
+                    //     socket.emit('refresh_pr_status', { repoName, prNumber });
+                    // }
+                    // // Update database asynchronously (non-blocking)
+                    // this.updatePRMetadata(userId, resultData);
                     return resultData;
                 }
-            }
-            catch (fetchError) {
-                logger.error('Failed to check for existing PR', fetchError);
-            }
-            // No existing PR found - check if we have commits to create one
-            if (!result.success) {
-                if (errorMatch) {
-                    throw new Error(`No commits to create PR. Branch '${headBranch}' is not ahead of '${targetBranch}'`);
-                }
-                throw new Error('Failed to prepare pull request');
-            }
-            // Create new PR
-            const prTitle = title || `Merge ${headBranch} into ${targetBranch}`;
-            const prBody = body || `This pull request merges changes from ${headBranch} into ${targetBranch}.\n\nCreated by AI-Playgrounds`;
-            try {
-                const prResponse = await octokit.rest.pulls.create({
-                    owner: gitOrgName,
-                    repo: repoName,
-                    title: prTitle,
-                    body: prBody,
-                    head: headBranch,
-                    base: targetBranch
-                });
-                const prUrl = prResponse.data.html_url;
-                const prNumber = prResponse.data.number;
-                logger.success('Pull request created successfully', {
-                    repoName,
-                    prNumber,
-                    prUrl
-                });
-                // taskInfo.status = TaskStatus.Completed;
-                // taskInfo.nonRunningSince = new Date();
-                // //updating the task status in the db
-                // let dbService = await getDBService();
-                // let taskHanlder = dbService.getRepository<Task>(ds.UserInfo.get(userId as any)?.dbName, CollectionNames.TASKS);
-                // taskHanlder.updateOne({
-                //     taskId: taskId
-                // },
-                //     {
-                //         "$set": {
-                //             status: TaskStatus.Completed
-                //         }
-                //     });
-                const resultData = {
-                    repoName,
-                    headBranch,
-                    targetBranch,
-                    prNumber,
-                    prUrl,
-                    prTitle,
-                    commitsAhead,
-                    createdAt: new Date().toISOString()
-                };
-                // // Emit socket event to refresh PR status on client
-                // if (socket) {
-                //     socket.emit('refresh_pr_status', { repoName, prNumber });
-                // }
-                // // Update database asynchronously (non-blocking)
-                // this.updatePRMetadata(userId, resultData);
-                return resultData;
-            }
-            catch (prError) {
-                // Check if PR already exists
-                if (prError.status === 422) {
-                    // Fetch existing PR
-                    try {
-                        const existingPRs = await octokit.rest.pulls.list({
-                            owner: gitOrgName,
-                            repo: repoName,
-                            head: `${gitOrgName}:${headBranch}`,
-                            base: targetBranch,
-                            state: 'open'
-                        });
-                        if (existingPRs.data.length > 0) {
-                            const existingPR = existingPRs.data[0];
-                            logger.info('Pull request already exists', {
-                                repoName,
-                                prNumber: existingPR.number,
-                                prUrl: existingPR.html_url
+                catch (prError) {
+                    // Check if PR already exists
+                    if (prError.status === 422) {
+                        // Fetch existing PR
+                        try {
+                            const existingPRs = await octokit.rest.pulls.list({
+                                owner: gitOrgName,
+                                repo: repoName,
+                                head: `${gitOrgName}:${headBranch}`,
+                                base: targetBranch,
+                                state: 'open'
                             });
-                            const resultData = {
-                                repoName,
-                                headBranch,
-                                targetBranch,
-                                prNumber: existingPR.number,
-                                prUrl: existingPR.html_url,
-                                prTitle: existingPR.title,
-                                commitsAhead,
-                                createdAt: existingPR.created_at,
-                                alreadyExists: true
-                            };
-                            // Emit socket event to refresh PR status on client
-                            if (socket) {
-                                socket.emit('refresh_pr_status', { repoName, prNumber: existingPR.number });
+                            if (existingPRs.data.length > 0) {
+                                const existingPR = existingPRs.data[0];
+                                logger.info('Pull request already exists', {
+                                    repoName,
+                                    prNumber: existingPR.number,
+                                    prUrl: existingPR.html_url
+                                });
+                                const resultData = {
+                                    repoName,
+                                    headBranch,
+                                    targetBranch,
+                                    prNumber: existingPR.number,
+                                    prUrl: existingPR.html_url,
+                                    prTitle: existingPR.title,
+                                    commitsAhead,
+                                    createdAt: existingPR.created_at,
+                                    alreadyExists: true
+                                };
+                                // Emit socket event to refresh PR status on client
+                                if (socket) {
+                                    socket.emit('refresh_pr_status', { repoName, prNumber: existingPR.number });
+                                }
+                                // Update database asynchronously (non-blocking)
+                                //   this.updatePRMetadata(userId, resultData);
+                                return resultData;
                             }
-                            // Update database asynchronously (non-blocking)
-                            //   this.updatePRMetadata(userId, resultData);
-                            return resultData;
+                        }
+                        catch (fetchError) {
+                            logger.error('Failed to fetch existing PR', fetchError);
                         }
                     }
-                    catch (fetchError) {
-                        logger.error('Failed to fetch existing PR', fetchError);
-                    }
+                    throw prError;
                 }
-                throw prError;
             }
-        }
-        finally {
-        }
+            finally {
+            }
+        }); // end withRepoLock
     }
     /**
      * Check if pull request exists
@@ -1234,35 +1259,37 @@ class GithubOperationsService {
         const repoPath = `${tool_server_1.folderPath}/${repoName}`;
         const installationToken = await fetchInstallationToken();
         const gitOrgName = await getGithubOrganizationName();
-        try {
-            const trimmedSourceBranch = (sourceBranch || '').trim();
-            const trimmedTargetBranch = (targetBranch || '').trim();
-            if (!trimmedSourceBranch || !trimmedTargetBranch) {
-                throw new Error('Both sourceBranch and targetBranch are required');
-            }
-            if (trimmedSourceBranch === trimmedTargetBranch) {
-                throw new Error('sourceBranch and targetBranch cannot be the same');
-            }
-            logger.info('Starting branch merge operation', {
-                repoName,
-                sourceBranch: trimmedSourceBranch,
-                targetBranch: trimmedTargetBranch,
-                pushToRemote
-            });
-            let result = await executeShell(`cd ${repoPath} && sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git`);
-            if (!result.success) {
-                throw new Error(`Failed to set authenticated remote URL: ${result.error || result.output || 'Unknown error'}`);
-            }
-            const fetchResult = await executeShell(`cd ${repoPath} && sudo git fetch origin --prune`);
-            if (!fetchResult.success) {
-                throw new Error(`Failed to fetch remote branches: ${fetchResult.error || fetchResult.output || 'Unknown error'}`);
-            }
-            const resolvedSource = await this.resolveBranchReference(repoPath, repoName, trimmedSourceBranch);
-            const resolvedTarget = await this.resolveBranchReference(repoPath, repoName, trimmedTargetBranch);
-            const targetLocalBranch = resolvedTarget.displayBranch;
-            const safeTargetLocalBranch = this.escapeSingleQuotedShell(targetLocalBranch);
-            const safeSourceRef = this.escapeSingleQuotedShell(resolvedSource.resolvedRef);
-            const prepareBranchCommand = `
+        return withRepoLock(repoName, async () => {
+            try {
+                const trimmedSourceBranch = (sourceBranch || '').trim();
+                const trimmedTargetBranch = (targetBranch || '').trim();
+                if (!trimmedSourceBranch || !trimmedTargetBranch) {
+                    throw new Error('Both sourceBranch and targetBranch are required');
+                }
+                if (trimmedSourceBranch === trimmedTargetBranch) {
+                    throw new Error('sourceBranch and targetBranch cannot be the same');
+                }
+                logger.info('Starting branch merge operation', {
+                    repoName,
+                    sourceBranch: trimmedSourceBranch,
+                    targetBranch: trimmedTargetBranch,
+                    pushToRemote
+                });
+                let result = await executeShell(`cd ${repoPath} && rm -f .git/config.lock && ` +
+                    `git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git`);
+                if (!result.success) {
+                    throw new Error(`Failed to set authenticated remote URL: ${result.error || result.output || 'Unknown error'}`);
+                }
+                const fetchResult = await executeShell(`cd ${repoPath} && sudo git fetch origin --prune`);
+                if (!fetchResult.success) {
+                    throw new Error(`Failed to fetch remote branches: ${fetchResult.error || fetchResult.output || 'Unknown error'}`);
+                }
+                const resolvedSource = await this.resolveBranchReference(repoPath, repoName, trimmedSourceBranch);
+                const resolvedTarget = await this.resolveBranchReference(repoPath, repoName, trimmedTargetBranch);
+                const targetLocalBranch = resolvedTarget.displayBranch;
+                const safeTargetLocalBranch = this.escapeSingleQuotedShell(targetLocalBranch);
+                const safeSourceRef = this.escapeSingleQuotedShell(resolvedSource.resolvedRef);
+                const prepareBranchCommand = `
                 cd ${repoPath} &&
                 TARGET_LOCAL='${safeTargetLocalBranch}' &&
                 if sudo git show-ref --verify --quiet "refs/heads/$TARGET_LOCAL"; then
@@ -1277,174 +1304,178 @@ class GithubOperationsService {
                     sudo git pull --ff-only origin "$TARGET_LOCAL" 2>/dev/null || true;
                 fi
             `.replace(/\n\s+/g, ' ');
-            result = await executeShell(prepareBranchCommand);
-            if (!result.success) {
-                throw new Error(`Failed to prepare target branch for merge: ${result.error || result.output || 'Unknown error'}`);
-            }
-            const mergeCommand = `cd ${repoPath} && SOURCE_REF='${safeSourceRef}' && sudo git merge --no-ff --no-edit "$SOURCE_REF"`;
-            const mergeResult = await executeShell(mergeCommand);
-            if (!mergeResult.success) {
-                const conflictResult = await executeShell(`cd ${repoPath} && sudo git diff --name-only --diff-filter=U`);
-                const conflictFiles = (conflictResult.output || '')
-                    .split('\n')
-                    .map((line) => line.trim())
-                    .filter((line) => line.length > 0);
-                if (conflictFiles.length > 0) {
-                    logger.warn('Merge completed with conflicts', {
-                        repoName,
-                        sourceBranch: resolvedSource.displayBranch,
-                        targetBranch: targetLocalBranch,
-                        conflictFiles
-                    });
-                    return {
-                        repoName,
-                        sourceBranch: resolvedSource.displayBranch,
-                        targetBranch: targetLocalBranch,
-                        merged: false,
-                        hasConflicts: true,
-                        conflictFiles,
-                        currentBranch: targetLocalBranch,
-                        pushedToRemote: false,
-                        mergedAt: new Date().toISOString(),
-                        message: `Merge has conflicts. Resolve conflicts in target branch '${targetLocalBranch}'.`
-                    };
+                result = await executeShell(prepareBranchCommand);
+                if (!result.success) {
+                    throw new Error(`Failed to prepare target branch for merge: ${result.error || result.output || 'Unknown error'}`);
                 }
-                throw new Error(`Failed to merge branches: ${mergeResult.error || mergeResult.output || 'Unknown error'}`);
-            }
-            const summaryResult = await executeShell(`cd ${repoPath} && COMMIT_HASH=$(sudo git rev-parse HEAD) && CURRENT_BRANCH=$(sudo git rev-parse --abbrev-ref HEAD) && echo "COMMIT_HASH:$COMMIT_HASH" && echo "CURRENT_BRANCH:$CURRENT_BRANCH"`);
-            if (!summaryResult.success) {
-                throw new Error(`Merge succeeded but failed to fetch merge summary: ${summaryResult.error || summaryResult.output || 'Unknown error'}`);
-            }
-            const summaryOutput = summaryResult.output || '';
-            const commitHashMatch = summaryOutput.match(/COMMIT_HASH:([^\n]+)/);
-            const currentBranchMatch = summaryOutput.match(/CURRENT_BRANCH:([^\n]+)/);
-            const commitHash = commitHashMatch ? commitHashMatch[1].trim() : '';
-            const currentBranch = currentBranchMatch ? currentBranchMatch[1].trim() : targetLocalBranch;
-            let pushedToRemote = false;
-            if (pushToRemote) {
-                const pushResult = await executeShell(`cd ${repoPath} && sudo git push origin '${safeTargetLocalBranch}'`);
-                if (!pushResult.success) {
-                    throw new Error(`Merge succeeded but push failed: ${pushResult.error || pushResult.output || 'Unknown error'}`);
+                const mergeCommand = `cd ${repoPath} && SOURCE_REF='${safeSourceRef}' && sudo git merge --no-ff --no-edit "$SOURCE_REF"`;
+                const mergeResult = await executeShell(mergeCommand);
+                if (!mergeResult.success) {
+                    const conflictResult = await executeShell(`cd ${repoPath} && sudo git diff --name-only --diff-filter=U`);
+                    const conflictFiles = (conflictResult.output || '')
+                        .split('\n')
+                        .map((line) => line.trim())
+                        .filter((line) => line.length > 0);
+                    if (conflictFiles.length > 0) {
+                        logger.warn('Merge completed with conflicts', {
+                            repoName,
+                            sourceBranch: resolvedSource.displayBranch,
+                            targetBranch: targetLocalBranch,
+                            conflictFiles
+                        });
+                        return {
+                            repoName,
+                            sourceBranch: resolvedSource.displayBranch,
+                            targetBranch: targetLocalBranch,
+                            merged: false,
+                            hasConflicts: true,
+                            conflictFiles,
+                            currentBranch: targetLocalBranch,
+                            pushedToRemote: false,
+                            mergedAt: new Date().toISOString(),
+                            message: `Merge has conflicts. Resolve conflicts in target branch '${targetLocalBranch}'.`
+                        };
+                    }
+                    throw new Error(`Failed to merge branches: ${mergeResult.error || mergeResult.output || 'Unknown error'}`);
                 }
-                pushedToRemote = true;
-            }
-            logger.success('Branch merge completed successfully', {
-                repoName,
-                sourceBranch: resolvedSource.displayBranch,
-                targetBranch: targetLocalBranch,
-                commitHash,
-                pushedToRemote
-            });
-            if (socket) {
-                socket.emit('refresh_repo', { repoName });
-            }
-            return {
-                repoName,
-                sourceBranch: resolvedSource.displayBranch,
-                targetBranch: targetLocalBranch,
-                merged: true,
-                hasConflicts: false,
-                conflictFiles: [],
-                currentBranch,
-                commitHash,
-                pushedToRemote,
-                mergedAt: new Date().toISOString(),
-                message: pushedToRemote
-                    ? `Merged '${resolvedSource.displayBranch}' into '${targetLocalBranch}' and pushed to remote.`
-                    : `Merged '${resolvedSource.displayBranch}' into '${targetLocalBranch}' locally.`
-            };
-        }
-        finally {
-            try {
-                await executeShell(`cd ${repoPath} && sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git`);
-            }
-            catch (restoreError) {
-                logger.error('Failed to restore unauthenticated remote URL after merge operation', {
+                const summaryResult = await executeShell(`cd ${repoPath} && COMMIT_HASH=$(sudo git rev-parse HEAD) && CURRENT_BRANCH=$(sudo git rev-parse --abbrev-ref HEAD) && echo "COMMIT_HASH:$COMMIT_HASH" && echo "CURRENT_BRANCH:$CURRENT_BRANCH"`);
+                if (!summaryResult.success) {
+                    throw new Error(`Merge succeeded but failed to fetch merge summary: ${summaryResult.error || summaryResult.output || 'Unknown error'}`);
+                }
+                const summaryOutput = summaryResult.output || '';
+                const commitHashMatch = summaryOutput.match(/COMMIT_HASH:([^\n]+)/);
+                const currentBranchMatch = summaryOutput.match(/CURRENT_BRANCH:([^\n]+)/);
+                const commitHash = commitHashMatch ? commitHashMatch[1].trim() : '';
+                const currentBranch = currentBranchMatch ? currentBranchMatch[1].trim() : targetLocalBranch;
+                let pushedToRemote = false;
+                if (pushToRemote) {
+                    const pushResult = await executeShell(`cd ${repoPath} && sudo git push origin '${safeTargetLocalBranch}'`);
+                    if (!pushResult.success) {
+                        throw new Error(`Merge succeeded but push failed: ${pushResult.error || pushResult.output || 'Unknown error'}`);
+                    }
+                    pushedToRemote = true;
+                }
+                logger.success('Branch merge completed successfully', {
                     repoName,
-                    error: restoreError instanceof Error ? restoreError.message : String(restoreError)
+                    sourceBranch: resolvedSource.displayBranch,
+                    targetBranch: targetLocalBranch,
+                    commitHash,
+                    pushedToRemote
                 });
+                if (socket) {
+                    socket.emit('refresh_repo', { repoName });
+                }
+                return {
+                    repoName,
+                    sourceBranch: resolvedSource.displayBranch,
+                    targetBranch: targetLocalBranch,
+                    merged: true,
+                    hasConflicts: false,
+                    conflictFiles: [],
+                    currentBranch,
+                    commitHash,
+                    pushedToRemote,
+                    mergedAt: new Date().toISOString(),
+                    message: pushedToRemote
+                        ? `Merged '${resolvedSource.displayBranch}' into '${targetLocalBranch}' and pushed to remote.`
+                        : `Merged '${resolvedSource.displayBranch}' into '${targetLocalBranch}' locally.`
+                };
             }
-        }
+            finally {
+                try {
+                    await executeShell(`cd ${repoPath} && git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git`);
+                }
+                catch (restoreError) {
+                    logger.error('Failed to restore unauthenticated remote URL after merge operation', {
+                        repoName,
+                        error: restoreError instanceof Error ? restoreError.message : String(restoreError)
+                    });
+                }
+            }
+        }); // end withRepoLock
     }
     async checkPullRequestExists(repoName, targetBranch) {
         const repoPath = `${tool_server_1.folderPath}/${repoName}`;
         const installationToken = await fetchInstallationToken();
         const gitOrgName = await getGithubOrganizationName();
-        try {
-            logger.info('Checking if PR exists', { repoName, targetBranch });
-            // Get current branch and commits ahead
-            const combinedCommand = `
+        return withRepoLock(repoName, async () => {
+            try {
+                logger.info('Checking if PR exists', { repoName, targetBranch });
+                // Get current branch and commits ahead
+                const combinedCommand = `
                 cd ${repoPath} &&
-                sudo git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
+                rm -f .git/config.lock &&
+                git remote set-url origin https://x-access-token:${installationToken}@github.com/${gitOrgName}/${repoName}.git &&
                 HEAD_BRANCH=$(sudo git rev-parse --abbrev-ref HEAD) &&
                 sudo git fetch origin --prune 2>/dev/null || true &&
                 sudo git fetch origin ${targetBranch} 2>/dev/null || true &&
                 COMMITS_AHEAD=$(sudo git rev-list --count origin/${targetBranch}..$HEAD_BRANCH 2>/dev/null || echo 0) &&
-                sudo git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git &&
+                git remote set-url origin https://github.com/${gitOrgName}/${repoName}.git &&
                 echo "HEAD_BRANCH:$HEAD_BRANCH" &&
                 echo "COMMITS_AHEAD:$COMMITS_AHEAD"
             `.replace(/\n\s+/g, ' ');
-            const result = await executeShell(combinedCommand);
-            // Check for command execution failure
-            if (!result.success) {
-                logger.error('Failed to check PR status', {
-                    repoName,
-                    error: result.error,
-                    code: result.code,
-                    output: result.output
+                const result = await executeShell(combinedCommand);
+                // Check for command execution failure
+                if (!result.success) {
+                    logger.error('Failed to check PR status', {
+                        repoName,
+                        error: result.error,
+                        code: result.code,
+                        output: result.output
+                    });
+                    throw new Error(`Failed to check PR status: ${result.error}`);
+                }
+                const output = result.output || '';
+                const headBranchMatch = output.match(/HEAD_BRANCH:([^\n]+)/);
+                const commitsAheadMatch = output.match(/COMMITS_AHEAD:(\d+)/);
+                const headBranch = headBranchMatch ? headBranchMatch[1].trim() : 'unknown';
+                const commitsAhead = commitsAheadMatch ? parseInt(commitsAheadMatch[1]) : 0;
+                logger.info('Branch info retrieved', { headBranch, commitsAhead });
+                // Check for existing PR - using 'octokit' package (already installed)
+                const { Octokit } = require('octokit');
+                const octokit = new Octokit({
+                    auth: installationToken
                 });
-                throw new Error(`Failed to check PR status: ${result.error}`);
-            }
-            const output = result.output || '';
-            const headBranchMatch = output.match(/HEAD_BRANCH:([^\n]+)/);
-            const commitsAheadMatch = output.match(/COMMITS_AHEAD:(\d+)/);
-            const headBranch = headBranchMatch ? headBranchMatch[1].trim() : 'unknown';
-            const commitsAhead = commitsAheadMatch ? parseInt(commitsAheadMatch[1]) : 0;
-            logger.info('Branch info retrieved', { headBranch, commitsAhead });
-            // Check for existing PR - using 'octokit' package (already installed)
-            const { Octokit } = require('octokit');
-            const octokit = new Octokit({
-                auth: installationToken
-            });
-            const existingPRs = await octokit.rest.pulls.list({
-                owner: gitOrgName,
-                repo: repoName,
-                head: `${gitOrgName}:${headBranch}`,
-                base: targetBranch,
-                state: 'open'
-            });
-            if (existingPRs.data.length > 0) {
-                const existingPR = existingPRs.data[0];
-                logger.info('Pull request exists', {
-                    repoName,
-                    prNumber: existingPR.number,
-                    prUrl: existingPR.html_url
+                const existingPRs = await octokit.rest.pulls.list({
+                    owner: gitOrgName,
+                    repo: repoName,
+                    head: `${gitOrgName}:${headBranch}`,
+                    base: targetBranch,
+                    state: 'open'
                 });
-                return {
-                    repoName,
-                    headBranch,
-                    targetBranch,
-                    prExists: true,
-                    prNumber: existingPR.number,
-                    prUrl: existingPR.html_url,
-                    prTitle: existingPR.title,
-                    commitsAhead,
-                    createdAt: existingPR.created_at
-                };
+                if (existingPRs.data.length > 0) {
+                    const existingPR = existingPRs.data[0];
+                    logger.info('Pull request exists', {
+                        repoName,
+                        prNumber: existingPR.number,
+                        prUrl: existingPR.html_url
+                    });
+                    return {
+                        repoName,
+                        headBranch,
+                        targetBranch,
+                        prExists: true,
+                        prNumber: existingPR.number,
+                        prUrl: existingPR.html_url,
+                        prTitle: existingPR.title,
+                        commitsAhead,
+                        createdAt: existingPR.created_at
+                    };
+                }
+                else {
+                    logger.info('No pull request found', { repoName, headBranch, targetBranch });
+                    return {
+                        repoName,
+                        headBranch,
+                        targetBranch,
+                        prExists: false,
+                        commitsAhead
+                    };
+                }
             }
-            else {
-                logger.info('No pull request found', { repoName, headBranch, targetBranch });
-                return {
-                    repoName,
-                    headBranch,
-                    targetBranch,
-                    prExists: false,
-                    commitsAhead
-                };
+            finally {
             }
-        }
-        finally {
-        }
+        }); // end withRepoLock
     }
     /**
      * Get commit list with commit IDs for a branch
@@ -1943,7 +1974,7 @@ class GithubOperationsService {
     /**
      * Helper method to get merge conflicts
      */
-    async getMergeConflicts(socket, repoName) {
+    async getMergeConflicts(repoName) {
         return new Promise((resolve) => {
             this.getMergeConflictsImplementation(repoName, tool_server_1.folderPath).then((mergeData) => {
                 resolve(mergeData);