gitxelectron 1.3.5 → 1.3.7

package/out/main/index.js

@@ -330,14 +330,16 @@ async function getCollaboratedRepos(sessionId) {
     ownedRepos.map(async (repo) => {
       try {
         const [collabRes, invRes] = await Promise.all([
-          fetch(`https://api.github.com/repos/${repo.owner.login}/${repo.name}/collaborators`, { headers }),
-          fetch(`https://api.github.com/repos/${repo.owner.login}/${repo.name}/invitations`, { headers })
+          fetch(`https://api.github.com/repos/${repo.owner.login}/${repo.name}/collaborators`, {
+            headers
+          }),
+          fetch(`https://api.github.com/repos/${repo.owner.login}/${repo.name}/invitations`, {
+            headers
+          })
         ]);
         const collabs = collabRes.ok ? await collabRes.json() : [];
         const invs = invRes.ok ? await invRes.json() : [];
-        const hasOtherCollabs = Array.isArray(collabs) && collabs.some(
-          (c) => c.login && c.login.toLowerCase() !== currentUsername
-        );
+        const hasOtherCollabs = Array.isArray(collabs) && collabs.some((c) => c.login && c.login.toLowerCase() !== currentUsername);
         const hasPendingInvs = Array.isArray(invs) && invs.length > 0;
         if (hasOtherCollabs || hasPendingInvs) {
           return {
@@ -382,12 +384,13 @@ async function createGitHubRepository(sessionId, name, description, isPrivate, a
   return await res.json();
 }
 function parseGithubUrl(remoteUrl) {
-  if (!remoteUrl.includes("github.com")) throw new Error("Not a GitHub repository");
-  let parts = remoteUrl.split("github.com");
+  const url = remoteUrl.trim();
+  if (!url.includes("github.com")) throw new Error("Not a GitHub repository");
+  let parts = url.split("github.com");
   let pathPart = parts[1].replace(/^[:\/]/, "").replace(/\.git$/, "");
   const pathSplits = pathPart.split("/");
   if (pathSplits.length >= 2) {
-    return { owner: pathSplits[0], repo: pathSplits[1] };
+    return { owner: pathSplits[0].trim(), repo: pathSplits[1].trim() };
   }
   throw new Error("Invalid GitHub repository URL");
 }
@@ -400,10 +403,18 @@ async function getCollaborators(sessionId, remoteUrl) {
     Accept: "application/vnd.github.v3+json",
     "User-Agent": "gitelectron-App"
   };
+  const safeFetch = async (url) => {
+    try {
+      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" }) };
+    }
+  };
   const [collabRes, invRes, contribRes] = await Promise.all([
-    fetch(`https://api.github.com/repos/${owner}/${repo}/collaborators`, { headers }),
-    fetch(`https://api.github.com/repos/${owner}/${repo}/invitations`, { headers }),
-    fetch(`https://api.github.com/repos/${owner}/${repo}/contributors`, { headers })
+    safeFetch(`https://api.github.com/repos/${owner}/${repo}/collaborators`),
+    safeFetch(`https://api.github.com/repos/${owner}/${repo}/invitations`),
+    safeFetch(`https://api.github.com/repos/${owner}/${repo}/contributors`)
   ]);
   if (!collabRes.ok) {
     const errorData = await collabRes.json().catch(() => ({}));
@@ -636,6 +647,58 @@ function getGitSession(sessionId) {
   if (!session) throw new Error("Git not initialized for this window");
   return session;
 }
+const DEFAULT_LFS_EXTENSIONS = [
+  "*.pt",
+  "*.ckpt",
+  "*.safetensors",
+  "*.bin",
+  "*.onnx",
+  "*.pb",
+  "*.h5",
+  "*.pkl",
+  "*.model",
+  "*.mp4",
+  "*.mov",
+  "*.avi",
+  "*.wav",
+  "*.mp3",
+  "*.uasset",
+  "*.umap",
+  "*.pak",
+  "*.dll",
+  "*.so",
+  "*.dylib",
+  "*.exe",
+  "*.zip",
+  "*.tar",
+  "*.gz",
+  "*.rar",
+  "*.7z",
+  "*.blend",
+  "*.fbx",
+  "*.obj"
+];
+async function setupDefaultGitAttributes(repoPath) {
+  try {
+    const attrsPath = path__namespace.join(repoPath, ".gitattributes");
+    let existing = "";
+    try {
+      existing = await fs__namespace.readFile(attrsPath, "utf8");
+    } catch (e) {
+    }
+    let newLines = [];
+    for (const ext of DEFAULT_LFS_EXTENSIONS) {
+      if (!existing.includes(ext)) {
+        newLines.push(`${ext} filter=lfs diff=lfs merge=lfs -text`);
+      }
+    }
+    if (newLines.length > 0) {
+      const appendContent = (existing && !existing.endsWith("\n") ? "\n" : "") + newLines.join("\n") + "\n";
+      await fs__namespace.appendFile(attrsPath, appendContent);
+    }
+  } catch (e) {
+  }
+}
 async function isGitRepo(dir) {
   let hasGitFolder = false;
   try {
@@ -678,7 +741,14 @@ async function isGitRepo(dir) {
 }
 async function initializeRepo(sessionId, dir) {
   try {
-    const tempGit = simpleGit.simpleGit({ baseDir: dir, unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true } });
+    const tempGit = simpleGit.simpleGit({
+      baseDir: dir,
+      unsafe: {
+        allowUnsafeEditor: true,
+        allowUnsafeAskPass: true,
+        allowUnsafeCredentialHelper: true
+      }
+    });
     await tempGit.init();
     const branches = await tempGit.branchLocal();
     if (branches.all.length === 0) {
@@ -693,6 +763,7 @@ async function initializeRepo(sessionId, dir) {
         "Initial repository setup"
       ]);
     }
+    await setupDefaultGitAttributes(dir);
     initGit(sessionId, dir);
     return true;
   } catch (e) {
@@ -772,7 +843,9 @@ async function stageFiles(sessionId, files) {
       try {
         await git.raw(["lfs", "install"]);
         for (const file of largeFiles) {
-          await git.raw(["lfs", "track", file]);
+          const ext = file.includes(".") ? "." + file.split(".").pop() : "";
+          const trackPattern = ext ? `*${ext}` : file;
+          await git.raw(["lfs", "track", trackPattern]);
         }
         if (!fileArray.includes(".gitattributes")) {
           fileArray.push(".gitattributes");
@@ -786,7 +859,15 @@ async function stageFiles(sessionId, files) {
   for (let i = 0; i < fileArray.length; i += chunkSize) {
     const chunk = fileArray.slice(i, i + chunkSize);
     try {
-      await git.raw(["-c", "core.safecrlf=false", "-c", "core.autocrlf=false", "add", "--force", ...chunk]);
+      await git.raw([
+        "-c",
+        "core.safecrlf=false",
+        "-c",
+        "core.autocrlf=false",
+        "add",
+        "--force",
+        ...chunk
+      ]);
     } catch (e) {
       if (e.message && e.message.includes("LF will be replaced by CRLF") && !e.message.includes("fatal:")) {
         console.warn("Ignored CRLF warning during stage");
@@ -840,7 +921,10 @@ function injectAuthToken(sessionId, remoteUrl) {
     }
   } catch (e) {
     if (remoteUrl.includes("github.com")) {
-      return remoteUrl.replace(/https:\/\/(?:[^@]+@)?github\.com\//, `https://x-access-token:${token}@github.com/`);
+      return remoteUrl.replace(
+        /https:\/\/(?:[^@]+@)?github\.com\//,
+        `https://x-access-token:${token}@github.com/`
+      );
     }
   }
   return remoteUrl;
@@ -898,7 +982,8 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
       return `${sec}s left`;
     };
     const etaStr = formatEta(etaMs);
-    if (onProgress) onProgress(`Processing chunk ${chunkCount} (${chunk.length} files)... ETA: ${etaStr}`);
+    if (onProgress)
+      onProgress(`Processing chunk ${chunkCount} (${chunk.length} files)... ETA: ${etaStr}`);
     if (onDetailedProgress) {
       onDetailedProgress({
         processed: processedFiles,
@@ -909,20 +994,24 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
     }
     const LARGE_FILE_LIMIT = 50 * 1024 * 1024;
     const largeFiles = [];
-    await Promise.all(chunk.map(async (file) => {
-      try {
-        const stats = await fs__namespace.stat(path__namespace.join(repoPath, file));
-        if (stats.isFile() && stats.size > LARGE_FILE_LIMIT) {
-          largeFiles.push(file);
+    await Promise.all(
+      chunk.map(async (file) => {
+        try {
+          const stats = await fs__namespace.stat(path__namespace.join(repoPath, file));
+          if (stats.isFile() && stats.size > LARGE_FILE_LIMIT) {
+            largeFiles.push(file);
+          }
+        } catch (e) {
         }
-      } catch (e) {
-      }
-    }));
+      })
+    );
     if (largeFiles.length > 0) {
       try {
         await git.raw(["lfs", "install"]);
         for (const file of largeFiles) {
-          await git.raw(["lfs", "track", file]);
+          const ext = file.includes(".") ? "." + file.split(".").pop() : "";
+          const trackPattern = ext ? `*${ext}` : file;
+          await git.raw(["lfs", "track", trackPattern]);
         }
         if (!chunk.includes(".gitattributes")) {
           chunk.push(".gitattributes");
@@ -934,7 +1023,14 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
     const tempFile = path__namespace.join(repoPath, ".git", "massive_chunk.txt");
     await fs__namespace.writeFile(tempFile, chunk.join("\0") + "\0", "utf-8");
     try {
-      await git.raw(["-c", "core.safecrlf=false", "add", "--force", "--pathspec-from-file=" + tempFile, "--pathspec-file-nul"]);
+      await git.raw([
+        "-c",
+        "core.safecrlf=false",
+        "add",
+        "--force",
+        "--pathspec-from-file=" + tempFile,
+        "--pathspec-file-nul"
+      ]);
     } catch (e) {
       if (e.message && e.message.includes("fatal:")) {
         throw e;
@@ -973,7 +1069,23 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
   } catch (e) {
   }
   if (onProgress) onProgress("Pushing to remote...");
-  const pushArgs = ["-c", "credential.helper=", "-c", "pack.windowMemory=256m", "-c", "pack.packSizeLimit=500m", "-c", "http.postBuffer=524288000", "-c", "lfs.concurrenttransfers=8", "push", "--progress", "--no-verify"];
+  const pushArgs = [
+    "-c",
+    "credential.helper=",
+    "-c",
+    "lfs.allowincompletepush=true",
+    "-c",
+    "pack.windowMemory=256m",
+    "-c",
+    "pack.packSizeLimit=500m",
+    "-c",
+    "http.postBuffer=524288000",
+    "-c",
+    "lfs.concurrenttransfers=8",
+    "push",
+    "--progress",
+    "--no-verify"
+  ];
   try {
     await git.raw([...pushArgs, authUrl, branch]);
   } catch (err) {
@@ -994,14 +1106,33 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
 async function pushToRemote(sessionId, remote, branch) {
   const remotes = await getRemotes(sessionId);
   const remoteObj = remotes.find((r) => r.name === remote);
-  const tempGit = simpleGit.simpleGit({ baseDir: getGitSession(sessionId).repoPath, unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true } }).env({
+  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 doPush = async () => {
-    const pushArgs = ["-c", "credential.helper=", "-c", "pack.windowMemory=256m", "-c", "pack.packSizeLimit=500m", "-c", "http.postBuffer=524288000", "-c", "lfs.concurrenttransfers=8", "push", "--progress", "--no-verify"];
+    const pushArgs = [
+      "-c",
+      "credential.helper=",
+      "-c",
+      "lfs.allowincompletepush=true",
+      "-c",
+      "pack.windowMemory=256m",
+      "-c",
+      "pack.packSizeLimit=500m",
+      "-c",
+      "http.postBuffer=524288000",
+      "-c",
+      "lfs.concurrenttransfers=8",
+      "push",
+      "--progress",
+      "--no-verify"
+    ];
     if (remoteObj && remoteObj.refs.push) {
       const authUrl = injectAuthToken(sessionId, remoteObj.refs.push);
       return await tempGit.raw([...pushArgs, authUrl, branch]);
@@ -1153,7 +1284,16 @@ async function checkRemoteUpdates(sessionId) {
     await new Promise((resolve) => {
       const child = child_process.spawn(
         "git",
-        ["-c", "credential.helper=", "-c", "core.longpaths=true", "fetch", "--prune", authUrl, `+refs/heads/*:refs/remotes/${remoteObj.name}/*`],
+        [
+          "-c",
+          "credential.helper=",
+          "-c",
+          "core.longpaths=true",
+          "fetch",
+          "--prune",
+          authUrl,
+          `+refs/heads/*:refs/remotes/${remoteObj.name}/*`
+        ],
         {
           cwd: repoPath,
           env: {
@@ -1201,7 +1341,14 @@ async function getBranches(sessionId) {
     const remotes = await git.getRemotes(true);
     if (remotes.length > 0) {
       const remoteObj = remotes[0];
-      const tempGit = simpleGit.simpleGit({ baseDir: getGitSession(sessionId).repoPath, unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true } }).env({
+      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",
@@ -1286,7 +1433,14 @@ async function createBranch(sessionId, branch, baseBranch) {
       const remoteName = remotes[0].name;
       await git.addConfig(`branch.${branch}.remote`, remoteName);
       await git.addConfig(`branch.${branch}.merge`, `refs/heads/${branch}`);
-      const tempGit = simpleGit.simpleGit({ baseDir: getGitSession(sessionId).repoPath, unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true } }).env({
+      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",
@@ -1312,7 +1466,10 @@ async function addRemote(sessionId, name, url) {
 async function pushAllBranches(sessionId, remote) {
   const remotes = await getRemotes(sessionId);
   const remoteObj = remotes.find((r) => r.name === remote);
-  const tempGit = simpleGit.simpleGit({ baseDir: getGitSession(sessionId).repoPath, unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true } }).env({
+  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",
@@ -1335,7 +1492,14 @@ async function getCommitHistory(sessionId) {
     if (remotes.length > 0) {
       const remoteObj = remotes[0];
       const authUrl = remoteObj.refs?.fetch ? injectAuthToken(sessionId, remoteObj.refs.fetch) : remoteObj.name;
-      await git.raw(["-c", "credential.helper=", "fetch", "--prune", authUrl, `+refs/heads/*:refs/remotes/${remoteObj.name}/*`]);
+      await git.raw([
+        "-c",
+        "credential.helper=",
+        "fetch",
+        "--prune",
+        authUrl,
+        `+refs/heads/*:refs/remotes/${remoteObj.name}/*`
+      ]);
     }
   } catch (e) {
   }
@@ -1433,8 +1597,12 @@ async function setupUniversalWorkspace(sessionId, remoteUrl, branch, baseBranch,
   const tempId = crypto.randomUUID();
   const workspacePath = path__namespace.join(electron.app.getPath("temp"), `gitelectron_universal_${tempId}`);
   await fs__namespace.mkdir(workspacePath, { recursive: true });
-  const git = simpleGit.simpleGit({ baseDir: workspacePath, unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true } });
+  const git = simpleGit.simpleGit({
+    baseDir: workspacePath,
+    unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true }
+  });
   await git.init();
+  await setupDefaultGitAttributes(workspacePath);
   let authUrl = remoteUrl;
   if (remoteUrl.includes("github.com")) {
     let cleanUrl = remoteUrl.replace("git@github.com:", "https://github.com/");
@@ -1493,7 +1661,10 @@ async function checkUniversalCollisions(workspacePath, sourceFiles, destinationP
   };
 }
 async function getUniversalDiff(workspacePath, filePath) {
-  const git = simpleGit.simpleGit({ baseDir: workspacePath, unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true } });
+  const git = simpleGit.simpleGit({
+    baseDir: workspacePath,
+    unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true }
+  });
   try {
     const diff = await git.raw(["diff", "--", filePath]);
     return diff;
@@ -1502,14 +1673,25 @@ async function getUniversalDiff(workspacePath, filePath) {
   }
 }
 async function commitUniversalWorkspace(workspacePath, message, branch) {
-  const git = simpleGit.simpleGit({ baseDir: workspacePath, unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true } }).env({
+  const git = simpleGit.simpleGit({
+    baseDir: workspacePath,
+    unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true }
+  }).env({
     ...process.env,
     GCM_INTERACTIVE: "false",
     GIT_TERMINAL_PROMPT: "0",
     GIT_ASKPASS: "echo"
   });
   try {
-    await git.raw(["-c", "core.safecrlf=false", "-c", "core.autocrlf=false", "add", "--sparse", "."]);
+    await git.raw([
+      "-c",
+      "core.safecrlf=false",
+      "-c",
+      "core.autocrlf=false",
+      "add",
+      "--sparse",
+      "."
+    ]);
   } catch (e) {
     if (e.message && e.message.includes("LF will be replaced by CRLF") && !e.message.includes("fatal:")) {
       console.warn("Ignored CRLF warning in universal workspace");
@@ -1586,7 +1768,16 @@ async function cloneRepository(sessionId, remoteUrl, destPath) {
         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"],
+            [
+              "-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" }
@@ -1806,18 +1997,180 @@ async function removeGitLock(sessionId) {
   }
 }
 async function masterPush(sessionId, remote, branch) {
-  const { git } = getGitSession(sessionId);
+  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;
-  await git.add(".");
+  let originalBranch = branch;
   try {
-    await git.commit("Master Override Push", ["--no-verify"]);
+    const branchSummary = await git.branchLocal();
+    originalBranch = branchSummary.current || branch;
   } catch (e) {
   }
-  return await git.push(authUrl, branch, ["--force"]);
+  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.
@@ -1931,7 +2284,12 @@ ${errorMsg}
   if (lowerError.includes("merge conflict") || lowerError.includes("conflict") || lowerError.includes("automatic merge failed")) {
     return {
       explanation: "Merge conflict detected. Forcing resolution by keeping local changes...",
-      commandsToRun: ["git merge --abort", "git pull -X ours --no-edit", "git add .", 'git commit -m "Auto-resolve merge conflict"']
+      commandsToRun: [
+        "git merge --abort",
+        "git pull -X ours --no-edit",
+        "git add .",
+        'git commit -m "Auto-resolve merge conflict"'
+      ]
     };
   }
   if (lowerError.includes("unmerged files") || lowerError.includes("you have unmerged paths")) {
@@ -1943,13 +2301,22 @@ ${errorMsg}
   if (lowerError.includes("please tell me who you are")) {
     return {
       explanation: "Git identity not set. Setting temporary identity...",
-      commandsToRun: ['git config user.email "gitelectron@example.com"', 'git config user.name "Git Electron"']
+      commandsToRun: [
+        'git config user.email "gitelectron@example.com"',
+        'git config user.name "Git Electron"'
+      ]
     };
   }
   if (lowerError.includes("would be overwritten by merge") || lowerError.includes("local changes to the following files would be overwritten")) {
     return {
       explanation: "Local changes would be overwritten. Stashing, pulling, and popping...",
-      commandsToRun: ["git stash", "git pull --no-edit", "git stash pop", "git add .", 'git commit -m "Auto-resolved stashed changes"']
+      commandsToRun: [
+        "git stash",
+        "git pull --no-edit",
+        "git stash pop",
+        "git add .",
+        'git commit -m "Auto-resolved stashed changes"'
+      ]
     };
   }
   throw new Error(
@@ -2028,7 +2395,10 @@ ${content}
       if (provider === "gemini") {
         const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
         const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
-        const result = await model.generateContent([{ text: AUTO_SYNC_SYSTEM_PROMPT }, { text: prompt }]);
+        const result = await model.generateContent([
+          { text: AUTO_SYNC_SYSTEM_PROMPT },
+          { text: prompt }
+        ]);
         responseText = result.response.text();
       }
       responseText = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
@@ -2158,7 +2528,9 @@ function toggleAutoSync(sessionId, repoPath, enabled, onLog, onErrorApproval, on
     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...`);
+        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) {
@@ -2361,7 +2733,15 @@ async function applyAiFixAndResume(sessionId, resolvedCode) {
       for (const [file, content] of Object.entries(resolvedCode)) {
         await fs__namespace.writeFile(path__namespace.join(repoPath, file), content, "utf-8");
         try {
-          await git.raw(["-c", "core.safecrlf=false", "-c", "core.autocrlf=false", "add", "--force", file]);
+          await git.raw([
+            "-c",
+            "core.safecrlf=false",
+            "-c",
+            "core.autocrlf=false",
+            "add",
+            "--force",
+            file
+          ]);
         } catch (e) {
           if (e.message && e.message.includes("LF will be replaced by CRLF") && !e.message.includes("fatal:")) {
             console.warn("Ignored CRLF warning during AI fix apply");