gitxelectron 1.3.0 → 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);
@@ -1885,6 +2028,7 @@ const getLastWorkspace = async () => {
 };
 let currentWatcher = null;
 let syncTimeout = null;
+let remotePollInterval = null;
 let isAutoSyncEnabled = false;
 let isResolving = false;
 let globalOnLog = null;
@@ -1905,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: [
       /(^|[\/\\])\../,
@@ -2278,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"),