gitxelectron 1.4.3 → 1.4.4

package/out/main/index.js

@@ -678,6 +678,31 @@ function getGitBinary() {
   cachedGitBinary = "git";
   return "git";
 }
+async function ensureGitIdentity(sessionId, git) {
+  try {
+    const account = getActiveAccount(sessionId);
+    if (account && account.username) {
+      const email2 = account.id ? `${account.id}+${account.username}@users.noreply.github.com` : `${account.username}@users.noreply.github.com`;
+      const curName = await git.getConfig("user.name");
+      const curEmail = await git.getConfig("user.email");
+      const isPlaceholderName = !curName.value || curName.value === "GitElectron User" || curName.value === "gitelectron" || curName.value === "GitQuickPush User";
+      const isPlaceholderEmail = !curEmail.value || curEmail.value === "auto@gitelectron.local" || curEmail.value.includes("gitelectron.local") || curEmail.value.includes("gitquickpush.local");
+      if (isPlaceholderName) {
+        await git.addConfig("user.name", account.username);
+      }
+      if (isPlaceholderEmail) {
+        await git.addConfig("user.email", email2);
+      }
+      return;
+    }
+    const name = await git.getConfig("user.name");
+    if (!name.value) await git.addConfig("user.name", "GitQuickPush User");
+    const email = await git.getConfig("user.email");
+    if (!email.value) await git.addConfig("user.email", "noreply@gitquickpush.local");
+  } catch (e) {
+    console.warn("Failed to ensure git identity:", e);
+  }
+}
 function initGit(sessionId, baseDir) {
   recordSessionPath(sessionId, baseDir);
   const options = {
@@ -710,14 +735,7 @@ function initGit(sessionId, baseDir) {
   });
   (async () => {
     try {
-      const name = await git.getConfig("user.name");
-      if (!name.value) {
-        await git.addConfig("user.name", "GitElectron User");
-      }
-      const email = await git.getConfig("user.email");
-      if (!email.value) {
-        await git.addConfig("user.email", "auto@gitelectron.local");
-      }
+      await ensureGitIdentity(sessionId, git);
     } catch (e) {
       console.warn("Failed to ensure git identity:", e);
     }
@@ -1119,19 +1137,7 @@ async function unstageFiles(sessionId, files) {
 async function commitChanges(sessionId, message) {
   const { git } = getGitSession(sessionId);
   await ensureAiWeightsUseLfs(git);
-  try {
-    const nameConfig = await git.getConfig("user.name");
-    const emailConfig = await git.getConfig("user.email");
-    if (!nameConfig.value || !emailConfig.value) {
-      const account = getActiveAccount(sessionId);
-      const name = account?.username || "GitQuickPush User";
-      const email = account ? `${account.username}@users.noreply.github.com` : "noreply@gitquickpush.local";
-      if (!nameConfig.value) await git.addConfig("user.name", name);
-      if (!emailConfig.value) await git.addConfig("user.email", email);
-    }
-  } catch (e) {
-    console.warn("Failed to check or set git author identity", e);
-  }
+  await ensureGitIdentity(sessionId, git);
   return await git.commit(message);
 }
 function injectAuthToken(sessionId, remoteUrl) {
@@ -1333,6 +1339,53 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
   if (onProgress) onProgress("✅ Massive push completed successfully!");
   return true;
 }
+function cleanGitErrorMessage(rawMsg, token, branch) {
+  if (!rawMsg) return "Unknown Git error";
+  let msg = typeof rawMsg === "string" ? rawMsg : rawMsg?.message || String(rawMsg);
+  if (token) {
+    msg = msg.split(token).join("***");
+  }
+  msg = msg.replace(/https:\/\/[^@]+@github\.com/g, "https://github.com");
+  msg = msg.replace(/ghp_[A-Za-z0-9_]{30,}/g, "***");
+  msg = msg.replace(/github_pat_[A-Za-z0-9_]{30,}/g, "***");
+  msg = msg.replace(/^Error invoking remote method '[^']+':\s*/i, "");
+  msg = msg.replace(/^Error:\s*/i, "");
+  msg = msg.replace(/^fatal:\s*/i, "");
+  const lines = msg.split(/[\r\n]+/);
+  const meaningfulLines = lines.filter((line) => {
+    const trimmed = line.trim();
+    if (!trimmed) return false;
+    if (/^(?:Enumerating|Counting|Compressing|Writing)\s+objects:\s*\d+%/i.test(trimmed))
+      return false;
+    if (/^Delta compression using up to \d+ threads/i.test(trimmed)) return false;
+    if (/^Total \d+ \(delta \d+\), reused \d+/i.test(trimmed)) return false;
+    if (/^POST git-(?:receive|upload)-pack \([^)]+\)/i.test(trimmed)) return false;
+    if (/^To https:\/\/github\.com/i.test(trimmed)) return false;
+    return true;
+  });
+  const cleaned = meaningfulLines.join("\n").trim();
+  if (cleaned.includes("Protected branch update failed") || cleaned.includes("GH006") || cleaned.includes("Cannot force-push to a protected branch")) {
+    const b = branch ? ` "${branch}"` : "";
+    return `GitHub rejected push: Protected branch policy is enabled for${b}. Force-pushing to this branch is blocked in your repository settings on GitHub.`;
+  }
+  if (cleaned.includes("GH001") || cleaned.includes("exceeds GitHub's file size limit")) {
+    const match = cleaned.match(/File\s+([^\s]+)\s+is\s+([0-9.]+)\s+MB/i);
+    if (match) {
+      return `Large file rejected by GitHub: "${match[1]}" is ${match[2]} MB, which exceeds GitHub's 100 MB limit. Track this file with Git LFS or add it to .gitignore.`;
+    }
+    return `Large file rejected by GitHub: Files exceeding 100 MB must be tracked with Git LFS or excluded in .gitignore.`;
+  }
+  if (cleaned.includes("RPC failed") || cleaned.includes("the remote end hung up unexpectedly") || cleaned.includes("early EOF") || cleaned.includes("curl 55")) {
+    return "Push connection interrupted or payload too large. (Buffer increased to 1GB). Check network stability or use Git LFS if pushing large binaries.";
+  }
+  if (cleaned.includes("terminal prompts disabled") || cleaned.includes("Authentication failed") || cleaned.includes("could not read Username") || cleaned.includes("Permission to") && cleaned.includes("denied")) {
+    return "Authentication failed or permission denied for remote repository. Verify your GitHub account has write access.";
+  }
+  if (cleaned.includes("non-fast-forward") || cleaned.includes("fetch first") || cleaned.includes("Updates were rejected because the remote contains work")) {
+    return "Push rejected: Remote repository has new incoming changes. Pull latest changes first to synchronize.";
+  }
+  return cleaned || "Git operation failed. Please check repository state.";
+}
 async function pushToRemote(sessionId, remote, branch) {
   const remotes = await getRemotes(sessionId);
   const remoteObj = remotes.find((r) => r.name === remote);
@@ -1342,13 +1395,21 @@ async function pushToRemote(sessionId, remote, branch) {
       "-c",
       "credential.helper=",
       "-c",
+      "core.longpaths=true",
+      "-c",
       "lfs.allowincompletepush=true",
       "-c",
-      "pack.windowMemory=256m",
+      "pack.windowMemory=512m",
       "-c",
-      "pack.packSizeLimit=500m",
+      "pack.packSizeLimit=1024m",
       "-c",
-      "http.postBuffer=524288000",
+      "http.postBuffer=1048576000",
+      "-c",
+      "http.maxRequestBuffer=1048576000",
+      "-c",
+      "http.lowSpeedLimit=1000",
+      "-c",
+      "http.lowSpeedTime=180",
       "-c",
       "lfs.concurrenttransfers=8",
       "push",
@@ -1366,18 +1427,17 @@ async function pushToRemote(sessionId, remote, branch) {
     return await doPush();
   } catch (err) {
     if (err.message && (err.message.includes("non-fast-forward") || err.message.includes("fetch first") || err.message.includes("branch is behind"))) {
-      console.log("Push rejected because branch is behind. Auto-pulling with rebase...");
-      const { git } = getGitSession(sessionId);
-      const options = { "--rebase": "false", "--autostash": null, "-X": "ours" };
-      if (remoteObj && remoteObj.refs.fetch) {
-        const authUrl = injectAuthToken(sessionId, remoteObj.refs.fetch);
-        await git.pull(authUrl, branch, options);
-      } else {
-        await git.pull(remote, branch, options);
+      console.log("Push rejected because branch is behind. Auto-pulling before retry...");
+      try {
+        await pullFromRemote(sessionId, remote, branch);
+        return await doPush();
+      } catch (pullErr) {
+        throw new Error(
+          cleanGitErrorMessage(pullErr.message, getToken(sessionId) || void 0, branch)
+        );
       }
-      return await doPush();
     }
-    throw err;
+    throw new Error(cleanGitErrorMessage(err.message, getToken(sessionId) || void 0, branch));
   }
 }
 async function masterForcePush(sessionId, remote, branch) {
@@ -1411,18 +1471,14 @@ async function masterForcePush(sessionId, remote, branch) {
   }
   await ensureAiWeightsUseLfs(git);
   try {
-    await git.add(".");
+    await git.raw(["-c", "core.safecrlf=false", "-c", "core.autocrlf=false", "add", "-A"]);
   } catch {
-    await git.raw(["add", "-A"]);
-  }
-  try {
-    const name = await git.getConfig("user.name");
-    if (!name.value) await git.addConfig("user.name", "GitElectron User");
-    const email = await git.getConfig("user.email");
-    if (!email.value) await git.addConfig("user.email", "auto@gitelectron.local");
-  } catch (e) {
-    console.warn("Failed to ensure git identity before master push:", e);
+    try {
+      await git.add(".");
+    } catch {
+    }
   }
+  await ensureGitIdentity(sessionId, git);
   try {
     await git.commit("Master Force Push - Sync changes");
   } catch (e) {
@@ -1430,11 +1486,24 @@ async function masterForcePush(sessionId, remote, branch) {
       console.warn("Commit note:", e.message);
     }
   }
-  const tempGit = createSafeGit(repoPath, sessionId);
   const pushArgs = [
     "-c",
     "credential.helper=",
     "-c",
+    "core.longpaths=true",
+    "-c",
+    "http.postBuffer=1048576000",
+    "-c",
+    "http.maxRequestBuffer=1048576000",
+    "-c",
+    "pack.windowMemory=512m",
+    "-c",
+    "pack.packSizeLimit=1024m",
+    "-c",
+    "http.lowSpeedLimit=1000",
+    "-c",
+    "http.lowSpeedTime=180",
+    "-c",
     "filter.lfs.required=false",
     "-c",
     "lfs.allowincompletepush=true",
@@ -1444,11 +1513,75 @@ async function masterForcePush(sessionId, remote, branch) {
     "--no-verify",
     "-f"
   ];
-  if (remoteObj && remoteObj.refs?.push) {
-    const authUrl = injectAuthToken(sessionId, remoteObj.refs.push);
-    return await tempGit.raw([...pushArgs, authUrl, branch]);
+  const targetRemoteUrl = remoteObj && remoteObj.refs?.push ? injectAuthToken(sessionId, remoteObj.refs.push) : remote || "origin";
+  let currentActiveBranch = branch;
+  try {
+    const status = await git.status();
+    if (status.current && !status.current.includes("(no") && status.current !== "HEAD") {
+      currentActiveBranch = status.current;
+    }
+  } catch {
+  }
+  const targetBranch = branch || currentActiveBranch || "main";
+  const pushRefSpec = currentActiveBranch ? `${currentActiveBranch}:${targetBranch}` : targetBranch;
+  try {
+    return await new Promise((resolve, reject) => {
+      const child = child_process.spawn(getGitBinary(), [...pushArgs, targetRemoteUrl, pushRefSpec], {
+        cwd: repoPath,
+        env: {
+          ...process.env,
+          GCM_INTERACTIVE: "false",
+          GIT_TERMINAL_PROMPT: "0",
+          GIT_ASKPASS: "echo"
+        }
+      });
+      let stdout = "";
+      let stderr = "";
+      const wc = electron.webContents.fromId(sessionId);
+      child.stdout.on("data", (d) => {
+        stdout += d.toString();
+      });
+      child.stderr.on("data", (d) => {
+        const text = d.toString();
+        stderr += text;
+        const match = text.match(
+          /(Writing objects|Compressing objects|Counting objects|Enumerating objects):\s+(\d+)%/i
+        );
+        if (match && wc) {
+          const stage = match[1];
+          const progress = parseInt(match[2], 10);
+          try {
+            wc.send("git-progress", { method: "push", stage, progress });
+          } catch {
+          }
+        }
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve(stdout || stderr || "Force push successful");
+        } else {
+          const combined = (stderr + "\n" + stdout).trim();
+          const clean = cleanGitErrorMessage(
+            combined,
+            getToken(sessionId) || void 0,
+            targetBranch
+          );
+          reject(new Error(clean));
+        }
+      });
+      child.on("error", (err) => {
+        reject(
+          new Error(
+            cleanGitErrorMessage(err.message, getToken(sessionId) || void 0, targetBranch)
+          )
+        );
+      });
+    });
+  } catch (err) {
+    throw new Error(
+      cleanGitErrorMessage(err.message, getToken(sessionId) || void 0, targetBranch)
+    );
   }
-  return await tempGit.raw([...pushArgs, remote || "origin", branch]);
 }
 async function pullFromRemote(sessionId, remote, branch) {
   const { git, repoPath } = getGitSession(sessionId);
@@ -1458,14 +1591,7 @@ async function pullFromRemote(sessionId, remote, branch) {
   }
   const remoteObj = (remote ? remotes.find((r) => r.name === remote) : null) || remotes[0];
   const targetRemote = remoteObj.name;
-  try {
-    const name = await git.getConfig("user.name");
-    if (!name.value) await git.addConfig("user.name", "GitElectron User");
-    const email = await git.getConfig("user.email");
-    if (!email.value) await git.addConfig("user.email", "auto@gitelectron.local");
-  } catch (e) {
-    console.warn("Failed to ensure git identity before pull:", e);
-  }
+  await ensureGitIdentity(sessionId, git);
   let targetBranch = branch;
   if (!targetBranch) {
     const status = await git.status();
@@ -1480,6 +1606,37 @@ async function pullFromRemote(sessionId, remote, branch) {
     }
   }
   const authUrl = remoteObj.refs?.fetch ? injectAuthToken(sessionId, remoteObj.refs.fetch) : targetRemote;
+  let headBefore = null;
+  try {
+    headBefore = (await git.raw(["rev-parse", "HEAD"])).trim();
+  } catch {
+  }
+  try {
+    const fetchArgs = [
+      "-c",
+      "credential.helper=",
+      "-c",
+      "core.longpaths=true",
+      "fetch",
+      "--prune",
+      authUrl,
+      targetBranch
+    ];
+    await new Promise((resolve) => {
+      const child = child_process.spawn(getGitBinary(), fetchArgs, {
+        cwd: repoPath,
+        env: {
+          ...process.env,
+          GCM_INTERACTIVE: "false",
+          GIT_TERMINAL_PROMPT: "0",
+          GIT_ASKPASS: "echo"
+        }
+      });
+      child.on("close", () => resolve());
+      child.on("error", () => resolve());
+    });
+  } catch {
+  }
   let didStash = false;
   try {
     const status = await git.status();
@@ -1505,16 +1662,14 @@ async function pullFromRemote(sessionId, remote, branch) {
       "-c",
       "core.longpaths=true",
       "-c",
-      "filter.lfs.required=false",
+      "http.postBuffer=1048576000",
       "-c",
-      "filter.lfs.smudge=",
-      "-c",
-      "http.postBuffer=524288000",
+      "http.maxRequestBuffer=1048576000",
       "pull",
+      "--progress",
       "--no-rebase",
       "--allow-unrelated-histories",
-      "-X",
-      "ours",
+      "--stat",
       authUrl,
       targetBranch
     ];
@@ -1523,18 +1678,30 @@ async function pullFromRemote(sessionId, remote, branch) {
         cwd: repoPath,
         env: {
           ...process.env,
-          GIT_LFS_SKIP_SMUDGE: "1",
           GCM_INTERACTIVE: "false",
           GIT_TERMINAL_PROMPT: "0",
           GIT_ASKPASS: "echo"
         }
       });
       let out = "";
+      const wc = electron.webContents.fromId(sessionId);
       child.stdout.on("data", (d) => {
         out += d.toString();
       });
       child.stderr.on("data", (d) => {
-        out += d.toString();
+        const text = d.toString();
+        out += text;
+        const match = text.match(
+          /(Receiving objects|Resolving deltas|Compressing objects|Counting objects):\s+(\d+)%/i
+        );
+        if (match && wc) {
+          const stage = match[1];
+          const progress = parseInt(match[2], 10);
+          try {
+            wc.send("git-progress", { method: "pull", stage, progress });
+          } catch {
+          }
+        }
       });
       child.on("close", (code) => {
         if (code === 0) {
@@ -1553,15 +1720,30 @@ async function pullFromRemote(sessionId, remote, branch) {
       }
     }
     const alreadyUpToDate = pullOutput.includes("Already up to date.") || pullOutput.includes("Already up-to-date.");
-    const lines = pullOutput.split(/[\r\n]+/).map((l) => l.trim());
-    const changedFiles2 = [];
-    for (const l of lines) {
-      if (l.includes("|") && (l.includes("+") || l.includes("-"))) {
-        const filePart = l.split("|")[0].trim();
-        if (filePart) changedFiles2.push(filePart);
+    let changedFiles2 = [];
+    if (headBefore && !alreadyUpToDate) {
+      try {
+        const diffTree = await git.raw(["diff", "--name-only", headBefore, "HEAD"]);
+        const files = diffTree.split(/[\r\n]+/).map((f) => f.trim()).filter(Boolean);
+        if (files.length > 0) {
+          changedFiles2 = files;
+        }
+      } catch {
+      }
+    }
+    if (changedFiles2.length === 0 && !alreadyUpToDate) {
+      const lines = pullOutput.split(/[\r\n]+/).map((l) => l.trim());
+      for (const l of lines) {
+        if (l.includes("|") && (l.includes("+") || l.includes("-"))) {
+          const filePart = l.split("|")[0].trim();
+          if (filePart) changedFiles2.push(filePart);
+        }
       }
     }
-    const message = alreadyUpToDate ? "Already up to date with remote." : changedFiles2.length > 0 ? `Successfully pulled ${changedFiles2.length} file(s) from team!` : "Successfully pulled latest changes from team!";
+    const summaryMatch = pullOutput.match(/(\d+)\s+files?\s+changed/i);
+    const totalFilesChanged = summaryMatch ? parseInt(summaryMatch[1], 10) : changedFiles2.length;
+    const displayCount = Math.max(totalFilesChanged, changedFiles2.length);
+    const message = alreadyUpToDate ? "Already up to date with remote." : displayCount > 0 ? `Successfully pulled ${displayCount} file(s) from team!` : "Successfully pulled latest changes from team!";
     return {
       success: true,
       alreadyUpToDate,
@@ -1576,12 +1758,11 @@ async function pullFromRemote(sessionId, remote, branch) {
       } catch {
       }
     }
-    const token = getToken(sessionId);
-    let cleanMsg = err?.message || String(err);
-    if (token) {
-      cleanMsg = cleanMsg.split(token).join("***");
-    }
-    cleanMsg = cleanMsg.replace(/https:\/\/[^@]+@github\.com/g, "https://github.com");
+    const cleanMsg = cleanGitErrorMessage(
+      err?.message || String(err),
+      getToken(sessionId) || void 0,
+      targetBranch
+    );
     throw new Error(cleanMsg);
   }
 }
@@ -1629,6 +1810,111 @@ async function checkRemoteUpdates(sessionId) {
     return { behind: 0, ahead: 0, current: "" };
   }
 }
+async function masterForcePull(sessionId, remote, branch) {
+  const { git, repoPath } = getGitSession(sessionId);
+  const remotes = await getRemotes(sessionId);
+  if (!remotes || remotes.length === 0) {
+    throw new Error("No remote repository configured to force pull from.");
+  }
+  const remoteObj = (remote ? remotes.find((r) => r.name === remote) : null) || remotes[0];
+  const targetRemote = remoteObj.name;
+  await ensureGitIdentity(sessionId, git);
+  let targetBranch = branch;
+  if (!targetBranch) {
+    const status = await git.status();
+    targetBranch = status.current || "main";
+    if (targetBranch.includes("(no") || targetBranch === "HEAD") {
+      try {
+        const remoteHead = await git.raw(["rev-parse", "--abbrev-ref", `${targetRemote}/HEAD`]);
+        targetBranch = remoteHead.trim().replace(`${targetRemote}/`, "");
+      } catch {
+        targetBranch = "main";
+      }
+    }
+  }
+  const authUrl = remoteObj.refs?.fetch ? injectAuthToken(sessionId, remoteObj.refs.fetch) : targetRemote;
+  let headBefore = null;
+  try {
+    headBefore = (await git.raw(["rev-parse", "HEAD"])).trim();
+  } catch {
+  }
+  try {
+    const fetchArgs = [
+      "-c",
+      "credential.helper=",
+      "-c",
+      "core.longpaths=true",
+      "-c",
+      "http.postBuffer=1048576000",
+      "-c",
+      "http.maxRequestBuffer=1048576000",
+      "fetch",
+      "--progress",
+      "--prune",
+      authUrl,
+      targetBranch
+    ];
+    await new Promise((resolve, reject) => {
+      const child = child_process.spawn(getGitBinary(), fetchArgs, {
+        cwd: repoPath,
+        env: {
+          ...process.env,
+          GCM_INTERACTIVE: "false",
+          GIT_TERMINAL_PROMPT: "0",
+          GIT_ASKPASS: "echo"
+        }
+      });
+      let errOut = "";
+      const wc = electron.webContents.fromId(sessionId);
+      child.stderr.on("data", (d) => {
+        const text = d.toString();
+        errOut += text;
+        const match = text.match(
+          /(Receiving objects|Resolving deltas|Compressing objects|Counting objects):\s+(\d+)%/i
+        );
+        if (match && wc) {
+          const stage = match[1];
+          const progress = parseInt(match[2], 10);
+          try {
+            wc.send("git-progress", { method: "pull", stage, progress });
+          } catch {
+          }
+        }
+      });
+      child.on("close", (code) => {
+        if (code === 0) resolve();
+        else reject(new Error(errOut || `Fetch failed with exit code ${code}`));
+      });
+      child.on("error", (err) => reject(err));
+    });
+    await git.reset(["--hard", "FETCH_HEAD"]);
+    try {
+      await git.clean("f", ["-d"]);
+    } catch {
+    }
+    let changedFiles2 = [];
+    if (headBefore) {
+      try {
+        const diffTree = await git.raw(["diff", "--name-only", headBefore, "HEAD"]);
+        changedFiles2 = diffTree.split(/[\r\n]+/).map((f) => f.trim()).filter(Boolean);
+      } catch {
+      }
+    }
+    const message = changedFiles2.length > 0 ? `Force Pull successful! Synced ${changedFiles2.length} file(s) from GitHub.` : "Force Pull successful! All files are perfectly matched with GitHub.";
+    return {
+      success: true,
+      message,
+      filesChanged: changedFiles2
+    };
+  } catch (err) {
+    const cleanMsg = cleanGitErrorMessage(
+      err?.message || String(err),
+      getToken(sessionId) || void 0,
+      targetBranch
+    );
+    throw new Error(cleanMsg);
+  }
+}
 async function resetToRemote(sessionId, remote, branch) {
   const { git } = getGitSession(sessionId);
   const remotes = await getRemotes(sessionId);
@@ -2383,6 +2669,19 @@ async function generateWithGemini(genAI, contents) {
   }
   throw lastErr || new Error("All Gemini model fallbacks failed");
 }
+function extractJson(text) {
+  const cleaned = text.replace(/```json/gi, "").replace(/```/g, "").trim();
+  try {
+    return JSON.parse(cleaned);
+  } catch {
+    const firstBrace = cleaned.indexOf("{");
+    const lastBrace = cleaned.lastIndexOf("}");
+    if (firstBrace !== -1 && lastBrace !== -1 && lastBrace > firstBrace) {
+      return JSON.parse(cleaned.substring(firstBrace, lastBrace + 1));
+    }
+    throw new Error("No valid JSON object found in response");
+  }
+}
 async function analyzeGitError(provider, apiKeyInput, errorMsg, gitStatus, repoPath, githubToken) {
   const keys = apiKeyInput ? apiKeyInput.split(",").map((k) => k.trim()).filter((k) => k) : getBackupApiKeys();
   const prompt = `
@@ -2410,9 +2709,8 @@ ${errorMsg}
         ],
         response_format: { type: "json_object" }
       });
-      let responseText = response.choices[0].message.content || "{}";
-      responseText = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
-      const parsed = JSON.parse(responseText);
+      const responseText = response.choices[0].message.content || "{}";
+      const parsed = extractJson(responseText);
       if (parsed.explanation && Array.isArray(parsed.commandsToRun)) {
         console.log("[AI Service] Successfully used GitHub Copilot Models API!");
         return parsed;
@@ -2445,8 +2743,7 @@ ${errorMsg}
       } else {
         throw new Error(`Unsupported AI Provider: ${provider}`);
       }
-      responseText = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
-      const parsed = JSON.parse(responseText);
+      const parsed = extractJson(responseText);
       if (!parsed.explanation || !Array.isArray(parsed.commandsToRun)) {
         throw new Error("AI returned an invalid response format.");
       }
@@ -2565,9 +2862,8 @@ ${content}
         ],
         response_format: { type: "json_object" }
       });
-      let responseText = response.choices[0].message.content || "{}";
-      responseText = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
-      const parsed = JSON.parse(responseText);
+      const responseText = response.choices[0].message.content || "{}";
+      const parsed = extractJson(responseText);
       if (parsed.reason && parsed.proposedFix) {
         return parsed;
       }
@@ -2585,8 +2881,7 @@ ${content}
           { text: prompt }
         ]);
       }
-      responseText = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
-      const parsed = JSON.parse(responseText);
+      const parsed = extractJson(responseText);
       if (!parsed.reason || !parsed.proposedFix) {
         throw new Error("AI returned an invalid response format.");
       }
@@ -2738,7 +3033,7 @@ function toggleAutoSync(sessionId, repoPath, enabled, onLog, onErrorApproval, on
       }
     } catch {
     }
-  }, 25e3);
+  }, 1e4);
   currentWatcher = chokidar.watch(repoPath, {
     ignored: [
       /(^|[/\\])\.git([/\\]|$)/,
@@ -2837,14 +3132,18 @@ async function triggerSyncSequence(sessionId, _repoPath, onLog) {
     if (globalOnErrorApproval && !isResolving) {
       isResolving = true;
       onLog("Attempting to resolve push failure...");
-      handleAutoSyncError(sessionId, error.message, onLog).catch(
-        (err) => onLog(`Resolution failed: ${err.message}`)
-      );
+      handleAutoSyncError(sessionId, error.message, onLog).catch((err) => {
+        onLog(`Resolution failed: ${err.message}`);
+      }).finally(() => {
+        setTimeout(() => {
+          isResolving = false;
+        }, 3e4);
+      });
     }
   }
 }
 async function handleAutoSyncError(sessionId, errorMsg, onLog) {
-  const { git, repoPath } = getGitSession(sessionId);
+  const { repoPath } = getGitSession(sessionId);
   if (!repoPath) {
     isResolving = false;
     return;
@@ -2860,31 +3159,32 @@ async function handleAutoSyncError(sessionId, errorMsg, onLog) {
     return;
   }
   try {
-    onLog("Pulling remote changes with rebase...");
+    onLog("Syncing incoming remote changes from team...");
     const status2 = await getStatus(sessionId);
     const currentBranch = status2.current || "main";
-    await git.pull("origin", currentBranch, {
-      "--rebase": "false",
-      "--autostash": null,
-      "-X": "ours"
-    });
-    onLog("Pull successful, attempting push again...");
+    const pullResult = await pullFromRemote(sessionId, "origin", currentBranch);
+    onLog(`Pull result: ${pullResult.message}. Resuming push...`);
     await pushToRemote(sessionId, "origin", currentBranch);
     onLog("✅ Error resolved and push resumed!");
     isResolving = false;
     if (globalOnResolveComplete) globalOnResolveComplete();
     return;
   } catch (pullErr) {
-    onLog(`Pull failed (possible conflict): ${pullErr.message}`);
+    onLog(`Pull notice: ${pullErr.message}`);
   }
   const status = await getStatus(sessionId);
   if (status.conflicted.length === 0) {
-    onLog("No conflicts found but resolution failed. Giving up.");
+    onLog("Auto-push paused: Remote rejected push or requires review.");
     isResolving = false;
     if (globalOnErrorApproval) {
+      const cleanReason = cleanGitErrorMessage(
+        errorMsg,
+        getToken(sessionId) || void 0,
+        status.current || "main"
+      );
       globalOnErrorApproval({
-        reason: "Failed to resolve error automatically. No file conflicts found.",
-        proposedFix: "Manual intervention required.",
+        reason: cleanReason || "Remote repository rejected the push request.",
+        proposedFix: 'Click "Approve & Fix" to attempt auto-reconciliation and push your changes.',
         files: []
       });
     }
@@ -2936,7 +3236,8 @@ async function applyAiFixAndResume(sessionId, resolvedCode) {
   if (!repoPath) return false;
   if (globalOnLog) globalOnLog("Applying AI resolution to conflicted files...");
   try {
-    if (resolvedCode) {
+    const hasResolvedFiles = resolvedCode && Object.keys(resolvedCode).length > 0;
+    if (hasResolvedFiles) {
       for (const [file, content] of Object.entries(resolvedCode)) {
         await fs__namespace.writeFile(path__namespace.join(repoPath, file), content, "utf-8");
         try {
@@ -2957,14 +3258,20 @@ async function applyAiFixAndResume(sessionId, resolvedCode) {
           }
         }
       }
-    }
-    try {
-      await git.rebase({ "--continue": null });
-    } catch {
-      await git.commit("Auto-resolved merge conflict by AI");
+      try {
+        await git.rebase({ "--continue": null });
+      } catch {
+        await ensureGitIdentity(sessionId, git);
+        await git.commit("Auto-resolved merge conflict by AI");
+      }
+    } else {
+      try {
+        await pullFromRemote(sessionId);
+      } catch {
+      }
     }
     const status = await getStatus(sessionId);
-    if (globalOnLog) globalOnLog("Pushing AI-resolved changes...");
+    if (globalOnLog) globalOnLog("Pushing changes...");
     await pushToRemote(sessionId, "origin", status.current || "main");
     if (globalOnLog) globalOnLog("✅ Push successful!");
     isResolving = false;
@@ -3246,6 +3553,9 @@ electron.app.whenReady().then(async () => {
   electron.ipcMain.handle("master-push", async (event, remote, branch) => {
     return await masterForcePush(event.sender.id, remote, branch);
   });
+  electron.ipcMain.handle("master-pull", async (event, remote, branch) => {
+    return await masterForcePull(event.sender.id, remote, branch);
+  });
   electron.ipcMain.handle("pull-from-remote", async (event, remote, branch) => {
     return await pullFromRemote(event.sender.id, remote, branch);
   });