gitxelectron 1.3.7 → 1.3.9

package/out/main/index.js

@@ -408,7 +408,10 @@ async function getCollaborators(sessionId, remoteUrl) {
       return await fetch(url, { headers });
     } catch (e) {
       console.error(`Fetch failed for ${url}:`, e.message);
-      return { ok: false, json: async () => ({ message: e.message || "Network error" }) };
+      return {
+        ok: false,
+        json: async () => ({ message: e.message || "Network error" })
+      };
     }
   };
   const [collabRes, invRes, contribRes] = await Promise.all([
@@ -609,6 +612,20 @@ function initGit(sessionId, baseDir) {
     GIT_ASKPASS: "echo"
   });
   gitSessions.set(sessionId, { git, repoPath: 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");
+      }
+    } catch (e) {
+      console.warn("Failed to ensure git identity:", e);
+    }
+  })();
 }
 function createSafeGit(baseDir, sessionId) {
   const options = {
@@ -1157,6 +1174,49 @@ async function pushToRemote(sessionId, remote, branch) {
     throw err;
   }
 }
+async function masterForcePush(sessionId, remote, branch) {
+  const { git } = getGitSession(sessionId);
+  const remotes = await getRemotes(sessionId);
+  const remoteObj = remotes.find((r) => r.name === remote);
+  await git.raw(["add", "-A", "-f"]);
+  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.commit("Master Force Push - Including all files");
+  } catch (e) {
+    if (!e.message.includes("nothing to commit")) {
+      throw e;
+    }
+  }
+  const tempGit = simpleGit.simpleGit({
+    baseDir: getGitSession(sessionId).repoPath,
+    unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true }
+  }).env({
+    ...process.env,
+    GCM_INTERACTIVE: "false",
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_ASKPASS: "echo"
+  });
+  const pushArgs = [
+    "-c",
+    "credential.helper=",
+    "push",
+    "--progress",
+    "--no-verify",
+    "-f"
+  ];
+  if (remoteObj && remoteObj.refs.push) {
+    const authUrl = injectAuthToken(sessionId, remoteObj.refs.push);
+    return await tempGit.raw([...pushArgs, authUrl, branch]);
+  }
+  return await tempGit.raw([...pushArgs, remote, branch]);
+}
 async function pullFromRemote(sessionId, remote, branch) {
   const { git, repoPath } = getGitSession(sessionId);
   const remotes = await getRemotes(sessionId);
@@ -1165,6 +1225,14 @@ 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);
+  }
   let targetBranch = branch;
   if (!targetBranch) {
     const status = await git.status();
@@ -1182,11 +1250,19 @@ async function pullFromRemote(sessionId, remote, branch) {
   let didStash = false;
   try {
     const status = await git.status();
+    if (status.conflicted && status.conflicted.length > 0) {
+      throw new Error(
+        `Pulling is not possible because you have unmerged files (${status.conflicted.join(", ")}). Please resolve conflicts or abort the merge.`
+      );
+    }
     if (!status.isClean()) {
       await git.raw(["stash", "push", "-u", "-m", "gitquickpush-autostash-before-pull"]);
       didStash = true;
     }
   } catch (err) {
+    if (err.message && err.message.includes("unmerged files")) {
+      throw err;
+    }
     console.warn("Stash check before pull warning:", err);
   }
   try {
@@ -1996,182 +2072,6 @@ async function removeGitLock(sessionId) {
     return false;
   }
 }
-async function masterPush(sessionId, remote, branch) {
-  const { git, repoPath } = getGitSession(sessionId);
-  const remotes = await getRemotes(sessionId);
-  const remoteObj = (remote ? remotes.find((r) => r.name === remote) : null) || remotes[0];
-  if (!remoteObj) throw new Error("No remote repository configured.");
-  const targetRemote = remoteObj.name;
-  const authUrl = remoteObj.refs?.push ? injectAuthToken(sessionId, remoteObj.refs.push) : targetRemote;
-  let originalBranch = branch;
-  try {
-    const branchSummary = await git.branchLocal();
-    originalBranch = branchSummary.current || branch;
-  } catch (e) {
-  }
-  const tempBranch = `__master_push_temp_${Date.now()}`;
-  const hiddenPointers = [];
-  const cleanedAttrsFiles = [];
-  const lfsOffFlags = [
-    "-c",
-    "filter.lfs.clean=cat",
-    "-c",
-    "filter.lfs.smudge=cat",
-    "-c",
-    "filter.lfs.process=",
-    "-c",
-    "filter.lfs.required=false",
-    "-c",
-    "lfs.allowincompletepush=true",
-    "-c",
-    "http.postBuffer=524288000",
-    "-c",
-    "credential.helper="
-  ];
-  function runGit(args, allowFail = false) {
-    return new Promise((resolve, reject) => {
-      const child = child_process.spawn("git", [...lfsOffFlags, ...args], {
-        cwd: repoPath,
-        env: {
-          ...process.env,
-          GIT_LFS_SKIP_SMUDGE: "1",
-          GIT_LFS_SKIP_PUSH: "1",
-          GCM_INTERACTIVE: "false",
-          GIT_TERMINAL_PROMPT: "0",
-          GIT_ASKPASS: "echo"
-        }
-      });
-      const stdout = [];
-      const stderr = [];
-      child.stdout?.on("data", (d) => stdout.push(d.toString()));
-      child.stderr?.on("data", (d) => stderr.push(d.toString()));
-      child.on("error", (err) => allowFail ? resolve("") : reject(err));
-      child.on("close", (code) => {
-        if (code === 0 || allowFail) {
-          resolve(stdout.join(""));
-        } else {
-          reject(new Error(stderr.join("") || `git exited with code ${code}`));
-        }
-      });
-    });
-  }
-  async function processRepo(dir) {
-    let entries;
-    try {
-      entries = await fs__namespace.readdir(dir, { withFileTypes: true });
-    } catch (e) {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.name === ".git" || entry.name === "node_modules" || entry.name.endsWith(".__lfs_ptr_bak__")) continue;
-      const fullPath = path__namespace.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await processRepo(fullPath);
-        continue;
-      }
-      if (!entry.isFile()) continue;
-      try {
-        if (entry.name === ".gitattributes") {
-          const content = await fs__namespace.readFile(fullPath, "utf8");
-          if (content.includes("filter=lfs") || content.includes("lfs")) {
-            cleanedAttrsFiles.push({ filePath: fullPath, original: content });
-            const cleaned = content.split("\n").filter((line) => !line.toLowerCase().includes("lfs")).join("\n");
-            await fs__namespace.writeFile(fullPath, cleaned);
-          }
-          continue;
-        }
-        const stat = await fs__namespace.stat(fullPath);
-        if (stat.size < 4096 && stat.size > 20) {
-          const buf = await fs__namespace.readFile(fullPath);
-          const text = buf.toString("utf8");
-          if (text.includes("version https://git-lfs.github.com/spec/v1") && text.includes("oid sha256:")) {
-            const backupPath = fullPath + ".__lfs_ptr_bak__";
-            await fs__namespace.rename(fullPath, backupPath);
-            hiddenPointers.push({ original: fullPath, backup: backupPath });
-          }
-        }
-      } catch (e) {
-      }
-    }
-  }
-  try {
-    try {
-      await git.raw(["lfs", "uninstall", "--local"]);
-    } catch (e) {
-    }
-    try {
-      await git.addConfig("filter.lfs.clean", "cat");
-      await git.addConfig("filter.lfs.smudge", "cat");
-      await git.addConfig("filter.lfs.process", "");
-      await git.addConfig("filter.lfs.required", "false");
-    } catch (e) {
-    }
-    await processRepo(repoPath);
-    await runGit(["checkout", "--orphan", tempBranch]);
-    await runGit(["add", "."]);
-    try {
-      const grepResult = await runGit(
-        ["grep", "--cached", "-l", "version https://git-lfs.github.com/spec/v1"],
-        true
-      );
-      if (grepResult.trim()) {
-        const lfsFiles = grepResult.trim().split("\n").filter(Boolean);
-        for (const f of lfsFiles) {
-          await runGit(["rm", "--cached", "--force", f.trim()], true);
-        }
-      }
-    } catch (e) {
-    }
-    try {
-      await runGit(["commit", "-m", "Master Override Push", "--no-verify"]);
-    } catch (e) {
-    }
-    await runGit(["push", "--force", "--no-verify", authUrl, `${tempBranch}:${branch}`]);
-  } finally {
-    try {
-      await runGit(["checkout", "-f", originalBranch], true);
-    } catch (e) {
-      try {
-        await runGit(["checkout", "-f", branch], true);
-      } catch (e2) {
-        try {
-          await runGit(["checkout", "-b", branch], true);
-        } catch (e3) {
-        }
-      }
-    }
-    try {
-      const branchList = await runGit(["branch", "--list", "__master_push_temp_*"], true);
-      if (branchList.trim()) {
-        const branches = branchList.trim().split("\n").map((b) => b.trim().replace(/^\*\s*/, "")).filter(Boolean);
-        for (const b of branches) {
-          await runGit(["branch", "-D", b], true);
-        }
-      }
-    } catch (e) {
-    }
-    try {
-      await runGit(["branch", "-D", tempBranch], true);
-    } catch (e) {
-    }
-    for (const { original, backup } of hiddenPointers) {
-      try {
-        await fs__namespace.rename(backup, original);
-      } catch (e) {
-      }
-    }
-    for (const { filePath, original } of cleanedAttrsFiles) {
-      try {
-        await fs__namespace.writeFile(filePath, original);
-      } catch (e) {
-      }
-    }
-    try {
-      await git.raw(["lfs", "install", "--local"]);
-    } catch (e) {
-    }
-  }
-}
 const SYSTEM_PROMPT = `You are an autonomous Git Healer Agent for the "GitElectron" app. 
 The user has encountered a Git error during a push, pull, or merge operation and you are executing as a background process to silently fix it.
 You will receive the Git Status and the Raw Error Message.
@@ -2292,10 +2192,14 @@ ${errorMsg}
       ]
     };
   }
-  if (lowerError.includes("unmerged files") || lowerError.includes("you have unmerged paths")) {
+  if (lowerError.includes("unmerged files") || lowerError.includes("you have unmerged paths") || lowerError.includes("unresolved conflict")) {
     return {
-      explanation: "Unmerged paths detected. Committing current state to proceed...",
-      commandsToRun: ["git add .", 'git commit -m "Auto-resolve unmerged paths"']
+      explanation: "Unmerged files detected. Resolving conflicts by keeping local changes...",
+      commandsToRun: [
+        "git checkout --ours .",
+        "git add .",
+        'git commit -m "Auto-resolved unmerged conflicts (kept local changes)"'
+      ]
     };
   }
   if (lowerError.includes("please tell me who you are")) {
@@ -2928,15 +2832,15 @@ electron.app.whenReady().then(async () => {
     }
     return await pushToRemote(event.sender.id, remote, branch);
   });
+  electron.ipcMain.handle("master-push", async (event, remote, branch) => {
+    return await masterForcePush(event.sender.id, remote, branch);
+  });
   electron.ipcMain.handle("pull-from-remote", async (event, remote, branch) => {
     return await pullFromRemote(event.sender.id, remote, branch);
   });
   electron.ipcMain.handle("check-remote-updates", async (event) => {
     return await checkRemoteUpdates(event.sender.id);
   });
-  electron.ipcMain.handle("master-push", async (event, remote, branch) => {
-    return await masterPush(event.sender.id, remote, branch);
-  });
   electron.ipcMain.handle("reset-to-remote", async (event, remote, branch) => {
     return await resetToRemote(event.sender.id, remote, branch);
   });