gitxelectron 1.2.9 → 1.3.1

package/out/main/index.js

@@ -577,7 +577,12 @@ function initGit(sessionId, baseDir) {
     baseDir,
     binary: "git",
     maxConcurrentProcesses: 6,
-    unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true },
+    unsafe: {
+      allowUnsafeEditor: true,
+      allowUnsafeAskPass: true,
+      allowUnsafeCredentialHelper: true,
+      allowUnsafeFilter: true
+    },
     progress: ({ method, stage, progress }) => {
       try {
         const wc = electron.webContents.fromId(sessionId);
@@ -598,7 +603,12 @@ function createSafeGit(baseDir, sessionId) {
   const options = {
     binary: "git",
     maxConcurrentProcesses: 6,
-    unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true },
+    unsafe: {
+      allowUnsafeEditor: true,
+      allowUnsafeAskPass: true,
+      allowUnsafeCredentialHelper: true,
+      allowUnsafeFilter: true
+    },
     progress: ({ method, stage, progress }) => {
       if (!sessionId) return;
       try {
@@ -1017,15 +1027,148 @@ async function pushToRemote(sessionId, remote, branch) {
   }
 }
 async function pullFromRemote(sessionId, remote, branch) {
-  const { git } = getGitSession(sessionId);
+  const { git, repoPath } = getGitSession(sessionId);
   const remotes = await getRemotes(sessionId);
-  const remoteObj = remotes.find((r) => r.name === remote);
-  const options = { "--allow-unrelated-histories": null };
-  if (remoteObj && remoteObj.refs.fetch) {
-    const authUrl = injectAuthToken(sessionId, remoteObj.refs.fetch);
-    return await git.pull(authUrl, branch, options);
+  if (!remotes || remotes.length === 0) {
+    throw new Error("No remote repository configured to pull from.");
+  }
+  const remoteObj = (remote ? remotes.find((r) => r.name === remote) : null) || remotes[0];
+  const targetRemote = remoteObj.name;
+  let targetBranch = branch;
+  if (!targetBranch) {
+    const status = await git.status();
+    targetBranch = status.current || "main";
+  }
+  const authUrl = remoteObj.refs?.fetch ? injectAuthToken(sessionId, remoteObj.refs.fetch) : targetRemote;
+  let didStash = false;
+  try {
+    const status = await git.status();
+    if (!status.isClean()) {
+      await git.raw(["stash", "push", "-u", "-m", "gitquickpush-autostash-before-pull"]);
+      didStash = true;
+    }
+  } catch (err) {
+    console.warn("Stash check before pull warning:", err);
+  }
+  try {
+    const pullArgs = [
+      "-c",
+      "credential.helper=",
+      "-c",
+      "core.longpaths=true",
+      "-c",
+      "filter.lfs.required=false",
+      "-c",
+      "filter.lfs.smudge=",
+      "-c",
+      "http.postBuffer=524288000",
+      "pull",
+      "--no-rebase",
+      "--allow-unrelated-histories",
+      authUrl,
+      targetBranch
+    ];
+    const pullOutput = await new Promise((resolve, reject) => {
+      const child = child_process.spawn("git", pullArgs, {
+        cwd: repoPath,
+        env: {
+          ...process.env,
+          GIT_LFS_SKIP_SMUDGE: "1",
+          GCM_INTERACTIVE: "false",
+          GIT_TERMINAL_PROMPT: "0",
+          GIT_ASKPASS: "echo"
+        }
+      });
+      let out = "";
+      child.stdout.on("data", (d) => {
+        out += d.toString();
+      });
+      child.stderr.on("data", (d) => {
+        out += d.toString();
+      });
+      child.on("close", (code) => {
+        if (code === 0) {
+          resolve(out);
+        } else {
+          reject(new Error(out || `Git pull exited with code ${code}`));
+        }
+      });
+      child.on("error", (err) => reject(err));
+    });
+    if (didStash) {
+      try {
+        await git.raw(["stash", "pop"]);
+      } catch (popErr) {
+        console.warn("Auto-stash pop had merge notice:", popErr?.message);
+      }
+    }
+    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);
+      }
+    }
+    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!";
+    return {
+      success: true,
+      alreadyUpToDate,
+      message,
+      filesChanged: changedFiles2,
+      raw: pullOutput
+    };
+  } catch (err) {
+    if (didStash) {
+      try {
+        await git.raw(["stash", "pop"]);
+      } 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");
+    throw new Error(cleanMsg);
+  }
+}
+async function checkRemoteUpdates(sessionId) {
+  const { git, repoPath } = getGitSession(sessionId);
+  try {
+    const remotes = await getRemotes(sessionId);
+    if (!remotes || remotes.length === 0) return { behind: 0, ahead: 0, current: "" };
+    const remoteObj = remotes[0];
+    const authUrl = remoteObj.refs?.fetch ? injectAuthToken(sessionId, remoteObj.refs.fetch) : remoteObj.name;
+    await new Promise((resolve) => {
+      const child = child_process.spawn(
+        "git",
+        ["-c", "credential.helper=", "-c", "core.longpaths=true", "fetch", "--prune", authUrl],
+        {
+          cwd: repoPath,
+          env: {
+            ...process.env,
+            GIT_LFS_SKIP_SMUDGE: "1",
+            GCM_INTERACTIVE: "false",
+            GIT_TERMINAL_PROMPT: "0",
+            GIT_ASKPASS: "echo"
+          }
+        }
+      );
+      child.on("close", () => resolve());
+      child.on("error", () => resolve());
+    });
+    const status = await git.status();
+    return {
+      behind: status.behind,
+      ahead: status.ahead,
+      current: status.current || "main"
+    };
+  } catch {
+    return { behind: 0, ahead: 0, current: "" };
   }
-  return await git.pull(remote, branch, options);
 }
 async function resetToRemote(sessionId, remote, branch) {
   const { git } = getGitSession(sessionId);
@@ -1405,39 +1548,122 @@ async function cloneRepository(sessionId, remoteUrl, destPath) {
           await existingGit.raw(["remote", "add", "origin", authUrl]);
         }
         await existingGit.raw(["-c", "credential.helper=", "fetch", "--progress", "origin"]);
-        const st = await existingGit.status();
-        const branch = st.current || "main";
-        try {
-          await existingGit.raw(["-c", "credential.helper=", "pull", "--progress", "origin", branch]);
-        } catch (e) {
-        }
+        await new Promise((resolve) => {
+          const child = child_process.spawn(
+            "git",
+            ["-c", "core.longpaths=true", "-c", "filter.lfs.required=false", "-c", "filter.lfs.smudge=", "checkout", "-f"],
+            {
+              cwd: destPath,
+              env: { ...process.env, GIT_LFS_SKIP_SMUDGE: "1" }
+            }
+          );
+          child.on("close", () => resolve());
+          child.on("error", () => resolve());
+        });
         return destPath;
       } catch (err) {
         console.warn("Re-using existing repo failed, falling through to clone attempt:", err);
       }
     }
-    if (destExists && destIsEmpty) {
-      const emptyDirGit = createSafeGit(destPath, sessionId);
-      await emptyDirGit.raw(["-c", "credential.helper=", "clone", "--progress", authUrl, "."]);
-      try {
-        await createSafeGit(void 0, sessionId).raw(["config", "--global", "--add", "safe.directory", destPath]);
-      } catch (e) {
-      }
-      return destPath;
-    }
     if (destExists && !destIsEmpty && !destHasGit) {
       throw new Error(
         `The folder '${path__namespace.basename(destPath)}' already contains files. Please select an empty folder or a different location to clone.`
       );
     }
-    const baseDir = path__namespace.dirname(destPath);
-    const targetDirName = path__namespace.basename(destPath);
-    const parentGit = createSafeGit(baseDir, sessionId);
-    await parentGit.raw(["-c", "credential.helper=", "clone", "--progress", authUrl, targetDirName]);
-    try {
-      await createSafeGit(void 0, sessionId).raw(["config", "--global", "--add", "safe.directory", destPath]);
-    } catch (e) {
+    const wc = electron.webContents.fromId(sessionId);
+    const cloneArgs = [
+      "-c",
+      "credential.helper=",
+      "-c",
+      "core.longpaths=true",
+      "-c",
+      "filter.lfs.required=false",
+      "-c",
+      "filter.lfs.smudge=",
+      "-c",
+      "http.postBuffer=524288000",
+      "-c",
+      "core.compression=0",
+      "-c",
+      "pack.windowMemory=256m",
+      "clone",
+      "--progress",
+      authUrl
+    ];
+    let cwd;
+    if (destExists && destIsEmpty) {
+      cloneArgs.push(".");
+      cwd = destPath;
+    } else {
+      cloneArgs.push(path__namespace.basename(destPath));
+      cwd = path__namespace.dirname(destPath);
     }
+    await new Promise((resolve, reject) => {
+      const child = child_process.spawn("git", cloneArgs, {
+        cwd,
+        env: {
+          ...process.env,
+          GIT_LFS_SKIP_SMUDGE: "1",
+          GCM_INTERACTIVE: "false",
+          GIT_TERMINAL_PROMPT: "0",
+          GIT_ASKPASS: "echo"
+        }
+      });
+      const errorLines = [];
+      child.stderr.on("data", (data) => {
+        const text = data.toString();
+        const match = text.match(
+          /(Receiving objects|Resolving deltas|Counting objects|Compressing objects):\s+(\d+)%/i
+        );
+        if (match && wc) {
+          const stage = match[1];
+          const progress = parseInt(match[2], 10);
+          try {
+            wc.send("git-progress", { method: "clone", stage, progress });
+          } catch {
+          }
+        }
+        const lines = text.split(/[\r\n]+/).map((l) => l.trim()).filter(Boolean);
+        for (const line of lines) {
+          if (!line.startsWith("Receiving objects:") && !line.startsWith("Resolving deltas:") && !line.startsWith("Counting objects:") && !line.startsWith("Compressing objects:") && !line.startsWith("Cloning into") && !line.startsWith("remote:")) {
+            errorLines.push(line);
+            if (errorLines.length > 10) errorLines.shift();
+          }
+        }
+      });
+      child.on("error", (err) => reject(err));
+      child.on("close", async (code) => {
+        if (code === 0) {
+          try {
+            await createSafeGit(void 0, sessionId).raw([
+              "config",
+              "--global",
+              "--add",
+              "safe.directory",
+              destPath
+            ]);
+          } catch {
+          }
+          resolve();
+        } else {
+          const token = getToken(sessionId);
+          let errorMsg = errorLines.join("\n") || `Git clone failed (exit code ${code})`;
+          if (token) {
+            errorMsg = errorMsg.split(token).join("***");
+          }
+          errorMsg = errorMsg.replace(/https:\/\/[^@]+@github\.com/g, "https://github.com");
+          if (errorMsg.includes("terminal prompts disabled") || errorMsg.includes("Authentication failed") || errorMsg.includes("could not read Username")) {
+            reject(
+              new Error(
+                "Authentication failed for GitHub repository. Please verify your account is logged in and has access to this repository."
+              )
+            );
+          } else {
+            reject(new Error(errorMsg));
+          }
+        }
+      });
+    });
     return destPath;
   } catch (err) {
     const token = getToken(sessionId);
@@ -1802,6 +2028,7 @@ const getLastWorkspace = async () => {
 };
 let currentWatcher = null;
 let syncTimeout = null;
+let remotePollInterval = null;
 let isAutoSyncEnabled = false;
 let isResolving = false;
 let globalOnLog = null;
@@ -1822,13 +2049,33 @@ function toggleAutoSync(sessionId, repoPath, enabled, onLog, onErrorApproval, on
   }
   if (syncTimeout) {
     clearTimeout(syncTimeout);
+    syncTimeout = null;
+  }
+  if (remotePollInterval) {
+    clearInterval(remotePollInterval);
+    remotePollInterval = null;
   }
   changedFiles.clear();
   if (!enabled) {
     onLog("Auto-Sync disabled.");
     return;
   }
-  onLog("⚡ Auto-Sync enabled. Watching for changes...");
+  onLog("⚡ Auto-Sync enabled (Watching local edits & syncing team changes from GitHub)...");
+  remotePollInterval = setInterval(async () => {
+    if (!isAutoSyncEnabled || isResolving) return;
+    try {
+      const updates = await checkRemoteUpdates(sessionId);
+      if (updates.behind > 0 && !isResolving) {
+        onLog(`📥 Found ${updates.behind} new commit(s) from team members on GitHub! Syncing to your computer...`);
+        const result = await pullFromRemote(sessionId);
+        onLog(`✅ ${result.message}`);
+        if (globalOnResolveComplete) {
+          globalOnResolveComplete();
+        }
+      }
+    } catch {
+    }
+  }, 25e3);
   currentWatcher = chokidar.watch(repoPath, {
     ignored: [
       /(^|[\/\\])\../,
@@ -2195,6 +2442,9 @@ electron.app.whenReady().then(async () => {
   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("reset-to-remote", async (event, remote, branch) => {
     return await resetToRemote(event.sender.id, remote, branch);
   });

package/out/preload/index.js

@@ -20,6 +20,7 @@ const api = {
   commitChanges: (message) => electron.ipcRenderer.invoke("commit-changes", message),
   pushToRemote: (remote, branch) => electron.ipcRenderer.invoke("push-to-remote", remote, branch),
   pullFromRemote: (remote, branch) => electron.ipcRenderer.invoke("pull-from-remote", remote, branch),
+  checkRemoteUpdates: () => electron.ipcRenderer.invoke("check-remote-updates"),
   resetToRemote: (remote, branch) => electron.ipcRenderer.invoke("reset-to-remote", remote, branch),
   fetchRemote: () => electron.ipcRenderer.invoke("fetch-remote"),
   getBranches: () => electron.ipcRenderer.invoke("get-branches"),