gitxelectron 1.3.9 → 1.4.2

package/out/main/index.js

@@ -2,9 +2,11 @@
 const electron = require("electron");
 const path = require("path");
 const fs = require("fs/promises");
+const https = require("https");
+const child_process = require("child_process");
 const simpleGit = require("simple-git");
 const crypto = require("crypto");
-const child_process = require("child_process");
+const fs$1 = require("fs");
 const generativeAi = require("@google/generative-ai");
 const OpenAI = require("openai");
 const chokidar = require("chokidar");
@@ -27,6 +29,7 @@ function _interopNamespaceDefault(e) {
 }
 const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
 const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const https__namespace = /* @__PURE__ */ _interopNamespaceDefault(https);
 const GITHUB_CLIENT_ID = "Ov23livWfiaPADGiwSXq";
 let accounts = [];
 const activeSessions = /* @__PURE__ */ new Map();
@@ -111,8 +114,24 @@ async function logout(sessionId) {
 }
 async function getAuthStatus(sessionId) {
   const activeAccount = getActiveAccount(sessionId);
-  if (!activeAccount) return { status: "Not Authenticated", username: null };
-  return { status: "Verified", username: activeAccount.username };
+  if (!activeAccount) {
+    return {
+      status: "Not Authenticated",
+      username: null,
+      avatarUrl: null,
+      authMethod: "Local Git Credentials",
+      aiProvider: "GitHub Models",
+      securityStatus: "Encrypted Local Keystore"
+    };
+  }
+  return {
+    status: "Verified",
+    username: activeAccount.username,
+    avatarUrl: activeAccount.avatar_url || null,
+    authMethod: "GitHub OAuth (Verified)",
+    aiProvider: "GitHub Models (gpt-4o-mini)",
+    securityStatus: "End-to-End Encrypted Session"
+  };
 }
 async function startDeviceFlow(_sessionId) {
   const response = await fetch("https://github.com/login/device/code", {
@@ -379,6 +398,25 @@ async function createGitHubRepository(sessionId, name, description, isPrivate, a
   });
   if (!res.ok) {
     const errorData = await res.json().catch(() => ({}));
+    const activeAccount = getActiveAccount(sessionId);
+    if (res.status === 422 && activeAccount?.username) {
+      try {
+        const existingRes = await fetch(
+          `https://api.github.com/repos/${activeAccount.username}/${encodeURIComponent(name)}`,
+          {
+            headers: {
+              Authorization: `Bearer ${token}`,
+              Accept: "application/vnd.github.v3+json",
+              "User-Agent": "gitelectron-App"
+            }
+          }
+        );
+        if (existingRes.ok) {
+          return await existingRes.json();
+        }
+      } catch {
+      }
+    }
     throw new Error(errorData.message || "Failed to create repository");
   }
   return await res.json();
@@ -586,22 +624,78 @@ async function declineInvitation(sessionId, invitationId) {
   }
 }
 const gitSessions = /* @__PURE__ */ new Map();
+const sessionRepoPaths = /* @__PURE__ */ new Map();
+function recordSessionPath(sessionId, repoPath) {
+  if (sessionId && repoPath) {
+    sessionRepoPaths.set(sessionId, repoPath);
+  }
+}
+let cachedGitBinary = null;
+function getGitBinary() {
+  if (cachedGitBinary) return cachedGitBinary;
+  try {
+    child_process.execSync("git --version", { stdio: "ignore" });
+    cachedGitBinary = "git";
+    return "git";
+  } catch {
+  }
+  if (process.platform === "win32") {
+    const programFiles = process.env.ProgramFiles || "C:\\Program Files";
+    const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
+    const localAppData = process.env.LOCALAPPDATA || "";
+    const userProfile = process.env.USERPROFILE || "";
+    const candidates = [
+      path__namespace.join(programFiles, "Git", "cmd", "git.exe"),
+      path__namespace.join(programFiles, "Git", "bin", "git.exe"),
+      path__namespace.join(programFiles, "Git", "mingw64", "bin", "git.exe"),
+      path__namespace.join(programFilesX86, "Git", "cmd", "git.exe"),
+      path__namespace.join(programFilesX86, "Git", "bin", "git.exe"),
+      path__namespace.join(localAppData, "Programs", "Git", "cmd", "git.exe"),
+      path__namespace.join(localAppData, "Programs", "Git", "bin", "git.exe"),
+      path__namespace.join(userProfile, "scoop", "shims", "git.exe")
+    ];
+    for (const cand of candidates) {
+      try {
+        if (fs$1.existsSync(cand)) {
+          cachedGitBinary = cand;
+          return cand;
+        }
+      } catch {
+      }
+    }
+  } else if (process.platform === "darwin") {
+    const candidates = ["/opt/homebrew/bin/git", "/usr/local/bin/git", "/usr/bin/git", "/bin/git"];
+    for (const cand of candidates) {
+      try {
+        if (fs$1.existsSync(cand)) {
+          cachedGitBinary = cand;
+          return cand;
+        }
+      } catch {
+      }
+    }
+  }
+  cachedGitBinary = "git";
+  return "git";
+}
 function initGit(sessionId, baseDir) {
+  recordSessionPath(sessionId, baseDir);
   const options = {
     baseDir,
-    binary: "git",
+    binary: getGitBinary(),
     maxConcurrentProcesses: 6,
     unsafe: {
       allowUnsafeEditor: true,
       allowUnsafeAskPass: true,
       allowUnsafeCredentialHelper: true,
-      allowUnsafeFilter: true
+      allowUnsafeFilter: true,
+      allowUnsafeCustomBinary: true
     },
     progress: ({ method, stage, progress }) => {
       try {
         const wc = electron.webContents.fromId(sessionId);
         if (wc) wc.send("git-progress", { method, stage, progress });
-      } catch (e) {
+      } catch {
       }
     }
   };
@@ -612,6 +706,8 @@ function initGit(sessionId, baseDir) {
     GIT_ASKPASS: "echo"
   });
   gitSessions.set(sessionId, { git, repoPath: baseDir });
+  checkAndHealZombieGitState(baseDir).catch(() => {
+  });
   (async () => {
     try {
       const name = await git.getConfig("user.name");
@@ -629,20 +725,21 @@ function initGit(sessionId, baseDir) {
 }
 function createSafeGit(baseDir, sessionId) {
   const options = {
-    binary: "git",
+    binary: getGitBinary(),
     maxConcurrentProcesses: 6,
     unsafe: {
       allowUnsafeEditor: true,
       allowUnsafeAskPass: true,
       allowUnsafeCredentialHelper: true,
-      allowUnsafeFilter: true
+      allowUnsafeFilter: true,
+      allowUnsafeCustomBinary: true
     },
     progress: ({ method, stage, progress }) => {
       if (!sessionId) return;
       try {
         const wc = electron.webContents.fromId(sessionId);
         if (wc) wc.send("git-progress", { method, stage, progress });
-      } catch (e) {
+      } catch {
       }
     }
   };
@@ -658,9 +755,31 @@ function createSafeGit(baseDir, sessionId) {
 }
 function cleanupGitSession(sessionId) {
   gitSessions.delete(sessionId);
+  sessionRepoPaths.delete(sessionId);
 }
 function getGitSession(sessionId) {
-  const session = gitSessions.get(sessionId);
+  let session = gitSessions.get(sessionId);
+  if (!session) {
+    const knownPath = sessionRepoPaths.get(sessionId);
+    if (knownPath) {
+      try {
+        const gitDir = path__namespace.join(knownPath, ".git");
+        if (fs$1.existsSync(gitDir)) {
+          initGit(sessionId, knownPath);
+          session = gitSessions.get(sessionId);
+        }
+      } catch (e) {
+        console.warn("Auto-recovery of git session failed:", e);
+      }
+    }
+  }
+  if (!session && gitSessions.size === 1) {
+    const singleSession = gitSessions.values().next().value;
+    if (singleSession) {
+      gitSessions.set(sessionId, singleSession);
+      session = singleSession;
+    }
+  }
   if (!session) throw new Error("Git not initialized for this window");
   return session;
 }
@@ -701,9 +820,9 @@ async function setupDefaultGitAttributes(repoPath) {
     let existing = "";
     try {
       existing = await fs__namespace.readFile(attrsPath, "utf8");
-    } catch (e) {
+    } catch {
     }
-    let newLines = [];
+    const newLines = [];
     for (const ext of DEFAULT_LFS_EXTENSIONS) {
       if (!existing.includes(ext)) {
         newLines.push(`${ext} filter=lfs diff=lfs merge=lfs -text`);
@@ -713,136 +832,228 @@ async function setupDefaultGitAttributes(repoPath) {
       const appendContent = (existing && !existing.endsWith("\n") ? "\n" : "") + newLines.join("\n") + "\n";
       await fs__namespace.appendFile(attrsPath, appendContent);
     }
-  } catch (e) {
+  } catch {
   }
 }
-async function isGitRepo(dir) {
-  let hasGitFolder = false;
+async function findGitRoot(dir) {
+  if (!dir) return null;
+  const cleanDir = path__namespace.normalize(dir.trim());
   try {
-    await fs__namespace.access(path__namespace.join(dir, ".git"));
-    hasGitFolder = true;
+    if (fs$1.existsSync(path__namespace.join(cleanDir, ".git"))) {
+      try {
+        await createSafeGit().raw(["config", "--global", "--add", "safe.directory", cleanDir]);
+      } catch {
+      }
+      return cleanDir;
+    }
   } catch {
-    hasGitFolder = false;
   }
   try {
-    const tempGit = simpleGit.simpleGit(dir).env({
-      ...process.env,
-      GCM_INTERACTIVE: "false",
-      GIT_TERMINAL_PROMPT: "0",
-      GIT_ASKPASS: "echo"
-    });
+    const tempGit = createSafeGit(cleanDir);
     const isRepo = await tempGit.checkIsRepo();
-    if (isRepo) return true;
-    if (hasGitFolder) {
-      await simpleGit.simpleGit().raw(["config", "--global", "--add", "safe.directory", dir]);
-      return await tempGit.checkIsRepo();
+    if (isRepo) {
+      const topLevel = (await tempGit.revparse(["--show-toplevel"])).trim();
+      if (topLevel) {
+        const normTop = path__namespace.normalize(topLevel);
+        try {
+          await createSafeGit().raw(["config", "--global", "--add", "safe.directory", normTop]);
+        } catch {
+        }
+        return normTop;
+      }
+      return cleanDir;
+    }
+  } catch {
+  }
+  try {
+    let current = path__namespace.dirname(cleanDir);
+    while (current && current.length > 3) {
+      if (fs$1.existsSync(path__namespace.join(current, ".git"))) {
+        try {
+          await createSafeGit().raw(["config", "--global", "--add", "safe.directory", current]);
+        } catch {
+        }
+        return current;
+      }
+      const parent = path__namespace.dirname(current);
+      if (!parent || parent === current) break;
+      current = parent;
+    }
+  } catch {
+  }
+  try {
+    const entries = await fs__namespace.readdir(cleanDir, { withFileTypes: true });
+    for (const entry of entries) {
+      if (entry.isDirectory() && !entry.name.startsWith(".")) {
+        const subPath = path__namespace.join(cleanDir, entry.name);
+        if (fs$1.existsSync(path__namespace.join(subPath, ".git"))) {
+          try {
+            await createSafeGit().raw(["config", "--global", "--add", "safe.directory", subPath]);
+          } catch {
+          }
+          return subPath;
+        }
+      }
     }
-    return false;
   } catch {
-    if (hasGitFolder) {
+  }
+  return null;
+}
+async function isGitRepo(dir) {
+  if (!dir) return false;
+  const cleanDir = path__namespace.normalize(dir.trim());
+  try {
+    if (fs$1.existsSync(path__namespace.join(cleanDir, ".git"))) {
       try {
-        await simpleGit.simpleGit().raw(["config", "--global", "--add", "safe.directory", dir]);
-        const tempGit = simpleGit.simpleGit(dir).env({
-          ...process.env,
-          GCM_INTERACTIVE: "false",
-          GIT_TERMINAL_PROMPT: "0",
-          GIT_ASKPASS: "echo"
-        });
-        return await tempGit.checkIsRepo();
+        await createSafeGit().raw(["config", "--global", "--add", "safe.directory", cleanDir]);
       } catch {
-        return true;
       }
+      return true;
     }
-    return false;
+  } catch {
   }
+  const root = await findGitRoot(cleanDir);
+  return root !== null;
 }
 async function initializeRepo(sessionId, dir) {
   try {
-    const tempGit = simpleGit.simpleGit({
-      baseDir: dir,
-      unsafe: {
-        allowUnsafeEditor: true,
-        allowUnsafeAskPass: true,
-        allowUnsafeCredentialHelper: true
-      }
+    recordSessionPath(sessionId, dir);
+    await fs__namespace.mkdir(dir, { recursive: true }).catch(() => {
     });
-    await tempGit.init();
-    const branches = await tempGit.branchLocal();
-    if (branches.all.length === 0) {
-      await tempGit.raw([
-        "-c",
-        "user.name=gitelectron",
-        "-c",
-        "user.email=noreply@gitelectron.local",
-        "commit",
-        "--allow-empty",
-        "-m",
-        "Initial repository setup"
-      ]);
+    try {
+      await createSafeGit().raw(["config", "--global", "--add", "safe.directory", dir]);
+    } catch {
     }
-    await setupDefaultGitAttributes(dir);
+    const tempGit = createSafeGit(dir, sessionId);
+    await tempGit.init();
     initGit(sessionId, dir);
+    try {
+      const branches = await tempGit.branchLocal();
+      if (branches.all.length === 0) {
+        await tempGit.raw([
+          "-c",
+          "user.name=gitelectron",
+          "-c",
+          "user.email=noreply@gitelectron.local",
+          "-c",
+          "commit.gpgsign=false",
+          "commit",
+          "--allow-empty",
+          "--no-verify",
+          "--no-gpg-sign",
+          "-m",
+          "Initial repository setup"
+        ]);
+      }
+    } catch (commitErr) {
+      console.warn("Initial commit in new repo skipped or failed:", commitErr);
+    }
+    try {
+      await setupDefaultGitAttributes(dir);
+    } catch (attrErr) {
+      console.warn("Default gitattributes setup failed:", attrErr);
+    }
     return true;
   } catch (e) {
     console.error("Failed to init repo", e);
-    return false;
+    throw new Error(`Failed to initialize Git repository in ${dir}: ${e?.message || e}`);
+  }
+}
+async function checkAndHealZombieGitState(repoPath) {
+  if (!repoPath) return;
+  try {
+    const gitDir = path__namespace.join(repoPath, ".git");
+    if (!fs$1.existsSync(gitDir)) return;
+    const rebaseMerge = path__namespace.join(gitDir, "rebase-merge");
+    const rebaseApply = path__namespace.join(gitDir, "rebase-apply");
+    const rebaseHead = path__namespace.join(gitDir, "REBASE_HEAD");
+    const indexLock = path__namespace.join(gitDir, "index.lock");
+    if (fs$1.existsSync(rebaseMerge) || fs$1.existsSync(rebaseApply) || fs$1.existsSync(rebaseHead)) {
+      console.warn(
+        "Zombie or interrupted rebase detected at:",
+        repoPath,
+        "- attempting git rebase --abort"
+      );
+      try {
+        const git = createSafeGit(repoPath);
+        await git.raw(["rebase", "--abort"]);
+      } catch (abortErr) {
+        console.warn("git rebase --abort notice:", abortErr);
+      }
+      if (fs$1.existsSync(rebaseMerge)) {
+        await fs__namespace.rm(rebaseMerge, { recursive: true, force: true }).catch(() => {
+        });
+      }
+      if (fs$1.existsSync(rebaseApply)) {
+        await fs__namespace.rm(rebaseApply, { recursive: true, force: true }).catch(() => {
+        });
+      }
+      if (fs$1.existsSync(rebaseHead)) {
+        await fs__namespace.rm(rebaseHead, { force: true }).catch(() => {
+        });
+      }
+    }
+    if (fs$1.existsSync(indexLock)) {
+      try {
+        const stats = await fs__namespace.stat(indexLock);
+        if (Date.now() - stats.mtimeMs > 5e3) {
+          console.warn("Stale index.lock detected at:", repoPath, "- removing lock");
+          await fs__namespace.unlink(indexLock).catch(() => {
+          });
+        }
+      } catch {
+      }
+    }
+  } catch (e) {
+    console.warn("checkAndHealZombieGitState error:", e);
   }
 }
 async function getStatus(sessionId) {
   const { git, repoPath } = getGitSession(sessionId);
-  return new Promise((resolve, reject) => {
-    const child = child_process.spawn("git", ["status", "--porcelain"], { cwd: repoPath });
-    let count = 0;
-    let isMassive = false;
-    child.stdout.on("data", (chunk) => {
-      for (let i = 0; i < chunk.length; ++i) {
-        if (chunk[i] === 10) {
-          count++;
-          if (count > 1e4) {
-            isMassive = true;
-            child.kill();
-            break;
+  if (repoPath) {
+    await checkAndHealZombieGitState(repoPath);
+  }
+  const status = await git.status();
+  const result = JSON.parse(JSON.stringify(status));
+  result.isMassive = false;
+  if (!result.staged) result.staged = [];
+  if (!result.tracking && result.current) {
+    try {
+      const remotes = await git.getRemotes();
+      if (remotes.length > 0) {
+        const remoteName = remotes[0].name || "origin";
+        const trackingRef = `refs/remotes/${remoteName}/${result.current}`;
+        const refExists = await git.raw(["rev-parse", "--verify", trackingRef]).catch(() => null);
+        if (refExists) {
+          await git.raw(["branch", `--set-upstream-to=${remoteName}/${result.current}`, result.current]).catch(() => {
+          });
+          result.tracking = `${remoteName}/${result.current}`;
+          try {
+            const revCount = await git.raw([
+              "rev-list",
+              "--left-right",
+              "--count",
+              `${result.current}...${remoteName}/${result.current}`
+            ]);
+            const parts = revCount.trim().split(/\s+/);
+            if (parts.length === 2) {
+              result.ahead = parseInt(parts[0], 10) || 0;
+              result.behind = parseInt(parts[1], 10) || 0;
+            }
+          } catch {
           }
         }
       }
-    });
-    child.on("close", async () => {
-      if (isMassive) {
-        resolve({
-          not_added: [],
-          created: [],
-          deleted: [],
-          modified: [],
-          conflicted: [],
-          renamed: [],
-          staged: [],
-          files: [],
-          current: "main",
-          ahead: 0,
-          behind: 0,
-          tracking: null,
-          isMassive: true,
-          totalChanges: count
-        });
-      } else {
-        try {
-          const status = await git.status();
-          const result = JSON.parse(JSON.stringify(status));
-          result.isMassive = false;
-          result.totalChanges = count;
-          if (!result.staged) result.staged = [];
-          resolve(result);
-        } catch (e) {
-          reject(e);
-        }
-      }
-    });
-    child.on("error", reject);
-  });
+    } catch {
+    }
+  }
+  result.totalChanges = result.files?.length || 0;
+  return result;
 }
 async function stageFiles(sessionId, files) {
   const { git, repoPath } = getGitSession(sessionId);
   const fileArray = Array.isArray(files) ? files : [files];
+  await ensureAiWeightsUseLfs(git);
   if (repoPath) {
     const LARGE_FILE_LIMIT = 50 * 1024 * 1024;
     const largeFiles = [];
@@ -853,7 +1064,7 @@ async function stageFiles(sessionId, files) {
         if (stats.isFile() && stats.size > LARGE_FILE_LIMIT) {
           largeFiles.push(file);
         }
-      } catch (e) {
+      } catch {
       }
     }
     if (largeFiles.length > 0) {
@@ -907,6 +1118,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");
@@ -936,7 +1148,7 @@ function injectAuthToken(sessionId, remoteUrl) {
       parsed.password = token;
       return parsed.toString();
     }
-  } catch (e) {
+  } catch {
     if (remoteUrl.includes("github.com")) {
       return remoteUrl.replace(
         /https:\/\/(?:[^@]+@)?github\.com\//,
@@ -947,10 +1159,11 @@ function injectAuthToken(sessionId, remoteUrl) {
   return remoteUrl;
 }
 async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3, onProgress, onDetailedProgress) {
-  const { repoPath } = getGitSession(sessionId);
+  const { git, repoPath } = getGitSession(sessionId);
+  await ensureAiWeightsUseLfs(git);
   if (onProgress) onProgress("Starting rapid file count to prepare massive chunking...");
   const totalFiles = await new Promise((resolve) => {
-    const child2 = child_process.spawn("git", ["status", "--porcelain"], { cwd: repoPath });
+    const child2 = child_process.spawn(getGitBinary(), ["status", "--porcelain"], { cwd: repoPath });
     let count = 0;
     child2.stdout.on("data", (chunk) => {
       for (let i = 0; i < chunk.length; ++i) {
@@ -965,7 +1178,6 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
     return true;
   }
   if (onProgress) onProgress(`Total files to push: ${totalFiles}. Starting chunked upload...`);
-  const { git } = getGitSession(sessionId);
   const remotes = await getRemotes(sessionId);
   const remoteObj = remotes.find((r) => r.name === remote);
   if (onProgress) onProgress("Starting massive repository push...");
@@ -976,7 +1188,7 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
   if (remoteObj && remoteObj.refs.push) {
     authUrl = injectAuthToken(sessionId, remoteObj.refs.push);
   }
-  const child = child_process.spawn("git", ["status", "--porcelain", "-z"], { cwd: repoPath });
+  const child = child_process.spawn(getGitBinary(), ["status", "--porcelain", "-z"], { cwd: repoPath });
   let buffer = "";
   let currentChunk = [];
   let chunkCount = 0;
@@ -1018,7 +1230,7 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
           if (stats.isFile() && stats.size > LARGE_FILE_LIMIT) {
             largeFiles.push(file);
           }
-        } catch (e) {
+        } catch {
         }
       })
     );
@@ -1055,7 +1267,7 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
     } finally {
       try {
         await fs__namespace.unlink(tempFile);
-      } catch (e) {
+      } catch {
       }
     }
   };
@@ -1083,7 +1295,7 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
   if (onProgress) onProgress("Committing all files...");
   try {
     await git.commit(`Auto-sync (Massive Push)`);
-  } catch (e) {
+  } catch {
   }
   if (onProgress) onProgress("Pushing to remote...");
   const pushArgs = [
@@ -1100,6 +1312,7 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
     "-c",
     "lfs.concurrenttransfers=8",
     "push",
+    "--set-upstream",
     "--progress",
     "--no-verify"
   ];
@@ -1108,7 +1321,7 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
   } catch (err) {
     if (err.message && (err.message.includes("non-fast-forward") || err.message.includes("fetch first") || err.message.includes("branch is behind"))) {
       if (onProgress) onProgress("Remote branch is ahead. Pulling changes...");
-      await git.pull(authUrl, branch, { "--rebase": null, "--autostash": null });
+      await git.pull(authUrl, branch, { "--rebase": "false", "--autostash": null, "-X": "ours" });
       if (onProgress) onProgress("Pushing to remote after pull...");
       await git.raw([...pushArgs, authUrl, branch]);
     } else {
@@ -1123,15 +1336,7 @@ 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({
-    ...process.env,
-    GCM_INTERACTIVE: "false",
-    GIT_TERMINAL_PROMPT: "0",
-    GIT_ASKPASS: "echo"
-  });
+  const tempGit = createSafeGit(getGitSession(sessionId).repoPath, sessionId);
   const doPush = async () => {
     const pushArgs = [
       "-c",
@@ -1147,6 +1352,7 @@ async function pushToRemote(sessionId, remote, branch) {
       "-c",
       "lfs.concurrenttransfers=8",
       "push",
+      "--set-upstream",
       "--progress",
       "--no-verify"
     ];
@@ -1162,7 +1368,7 @@ async function pushToRemote(sessionId, remote, branch) {
     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": null, "--autostash": null };
+      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);
@@ -1175,10 +1381,40 @@ async function pushToRemote(sessionId, remote, branch) {
   }
 }
 async function masterForcePush(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);
-  await git.raw(["add", "-A", "-f"]);
+  const remoteObj = (remote ? remotes.find((r) => r.name === remote) : null) || remotes[0];
+  try {
+    const branchSummary = await git.branchLocal();
+    let current = branchSummary.current || branch;
+    if (current && current.startsWith("__master_push_temp_")) {
+      const candidates = ["main", "master", branch].filter(
+        (b) => b && !b.startsWith("__master_push_temp_") && branchSummary.all.includes(b)
+      );
+      const fallbackBranch = candidates[0] || "main";
+      try {
+        await git.checkout(fallbackBranch);
+        current = fallbackBranch;
+        branch = fallbackBranch;
+      } catch {
+      }
+    }
+    for (const b of branchSummary.all) {
+      if (b.startsWith("__master_push_temp_") && b !== current) {
+        try {
+          await git.deleteLocalBranch(b, true);
+        } catch {
+        }
+      }
+    }
+  } catch {
+  }
+  await ensureAiWeightsUseLfs(git);
+  try {
+    await git.add(".");
+  } catch {
+    await git.raw(["add", "-A"]);
+  }
   try {
     const name = await git.getConfig("user.name");
     if (!name.value) await git.addConfig("user.name", "GitElectron User");
@@ -1188,34 +1424,31 @@ async function masterForcePush(sessionId, remote, branch) {
     console.warn("Failed to ensure git identity before master push:", e);
   }
   try {
-    await git.commit("Master Force Push - Including all files");
+    await git.commit("Master Force Push - Sync changes");
   } catch (e) {
     if (!e.message.includes("nothing to commit")) {
-      throw e;
+      console.warn("Commit note:", e.message);
     }
   }
-  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 tempGit = createSafeGit(repoPath, sessionId);
   const pushArgs = [
     "-c",
     "credential.helper=",
+    "-c",
+    "filter.lfs.required=false",
+    "-c",
+    "lfs.allowincompletepush=true",
     "push",
+    "--set-upstream",
     "--progress",
     "--no-verify",
     "-f"
   ];
-  if (remoteObj && remoteObj.refs.push) {
+  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]);
+  return await tempGit.raw([...pushArgs, remote || "origin", branch]);
 }
 async function pullFromRemote(sessionId, remote, branch) {
   const { git, repoPath } = getGitSession(sessionId);
@@ -1280,11 +1513,13 @@ async function pullFromRemote(sessionId, remote, branch) {
       "pull",
       "--no-rebase",
       "--allow-unrelated-histories",
+      "-X",
+      "ours",
       authUrl,
       targetBranch
     ];
     const pullOutput = await new Promise((resolve, reject) => {
-      const child = child_process.spawn("git", pullArgs, {
+      const child = child_process.spawn(getGitBinary(), pullArgs, {
         cwd: repoPath,
         env: {
           ...process.env,
@@ -1359,7 +1594,7 @@ async function checkRemoteUpdates(sessionId) {
     const authUrl = remoteObj.refs?.fetch ? injectAuthToken(sessionId, remoteObj.refs.fetch) : remoteObj.name;
     await new Promise((resolve) => {
       const child = child_process.spawn(
-        "git",
+        getGitBinary(),
         [
           "-c",
           "credential.helper=",
@@ -1417,19 +1652,7 @@ 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({
-        ...process.env,
-        GCM_INTERACTIVE: "false",
-        GIT_TERMINAL_PROMPT: "0",
-        GIT_ASKPASS: "echo"
-      });
+      const tempGit = createSafeGit(getGitSession(sessionId).repoPath, sessionId);
       const FETCH_TIMEOUT_MS = 15e3;
       const fetchPromise = remoteObj.refs.fetch ? tempGit.fetch(injectAuthToken(sessionId, remoteObj.refs.fetch), { "--prune": null }) : tempGit.fetch(remoteObj.name, { "--prune": null });
       await Promise.race([
@@ -1439,7 +1662,7 @@ async function getBranches(sessionId) {
         )
       ]);
     }
-  } catch (e) {
+  } catch {
   }
   let branches = await git.branch(["-a"]);
   if (branches.all.length === 0) {
@@ -1461,10 +1684,14 @@ async function getBranches(sessionId) {
   }
   const allBranches = /* @__PURE__ */ new Set();
   branches.all.forEach((b) => {
+    if (b.includes("__master_push_temp_")) return;
     if (b.startsWith("remotes/")) {
       const parts = b.split("/");
       if (parts.length > 2) {
-        allBranches.add(parts.slice(2).join("/"));
+        const branchName = parts.slice(2).join("/");
+        if (!branchName.includes("__master_push_temp_")) {
+          allBranches.add(branchName);
+        }
       }
     } else {
       allBranches.add(b);
@@ -1509,19 +1736,7 @@ 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({
-        ...process.env,
-        GCM_INTERACTIVE: "false",
-        GIT_TERMINAL_PROMPT: "0",
-        GIT_ASKPASS: "echo"
-      });
+      const tempGit = createSafeGit(getGitSession(sessionId).repoPath, sessionId);
       const remoteObj = remotes[0];
       if (remoteObj && remoteObj.refs.push) {
         const authUrl = injectAuthToken(sessionId, remoteObj.refs.push);
@@ -1537,29 +1752,31 @@ async function createBranch(sessionId, branch, baseBranch) {
 }
 async function addRemote(sessionId, name, url) {
   const { git } = getGitSession(sessionId);
+  try {
+    const remotes = await git.getRemotes(false);
+    if (remotes.some((r) => r.name === name)) {
+      return await git.remote(["set-url", name, url]);
+    }
+  } catch {
+  }
   return await git.addRemote(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({
-    ...process.env,
-    GCM_INTERACTIVE: "false",
-    GIT_TERMINAL_PROMPT: "0",
-    GIT_ASKPASS: "echo"
-  });
-  try {
-    if (remoteObj && remoteObj.refs.push) {
-      const authUrl = injectAuthToken(sessionId, remoteObj.refs.push);
-      return await tempGit.raw(["-c", "credential.helper=", "push", authUrl, "--all"]);
-    }
-    return await tempGit.raw(["-c", "credential.helper=", "push", remote, "--all"]);
-  } catch (err) {
-    throw err;
+  const tempGit = createSafeGit(getGitSession(sessionId).repoPath, sessionId);
+  if (remoteObj && remoteObj.refs.push) {
+    const authUrl = injectAuthToken(sessionId, remoteObj.refs.push);
+    return await tempGit.raw([
+      "-c",
+      "credential.helper=",
+      "push",
+      "--set-upstream",
+      authUrl,
+      "--all"
+    ]);
   }
+  return await tempGit.raw(["-c", "credential.helper=", "push", "--set-upstream", remote, "--all"]);
 }
 async function getCommitHistory(sessionId) {
   const { git } = getGitSession(sessionId);
@@ -1577,17 +1794,27 @@ async function getCommitHistory(sessionId) {
         `+refs/heads/*:refs/remotes/${remoteObj.name}/*`
       ]);
     }
-  } catch (e) {
+  } catch {
+  }
+  try {
+    const log = await git.log(["--all", "--stat", "--root", "--cc"]);
+    return JSON.parse(JSON.stringify(log));
+  } catch {
+    try {
+      const log = await git.log(["--all", "--stat", "--root"]);
+      return JSON.parse(JSON.stringify(log));
+    } catch {
+      const log = await git.log(["--all", "--name-status"]);
+      return JSON.parse(JSON.stringify(log));
+    }
   }
-  const log = await git.log(["--all", "--name-status"]);
-  return JSON.parse(JSON.stringify(log));
 }
 async function getDeletedHistory(sessionId) {
   const { git } = getGitSession(sessionId);
   try {
     const log = await git.log(["--all", "--diff-filter=D", "--name-status", "-n", "20"]);
     return JSON.parse(JSON.stringify(log));
-  } catch (e) {
+  } catch {
     return { all: [] };
   }
 }
@@ -1619,7 +1846,7 @@ async function setGitConfig(sessionId, key, value, global = false) {
     gitInstance = getGitSession(sessionId).git;
   } catch (e) {
     if (global) {
-      gitInstance = simpleGit.simpleGit();
+      gitInstance = createSafeGit();
     } else {
       throw e;
     }
@@ -1673,15 +1900,16 @@ 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 }
-  });
+  try {
+    await createSafeGit().raw(["config", "--global", "--add", "safe.directory", workspacePath]);
+  } catch {
+  }
+  const git = createSafeGit(workspacePath, sessionId);
   await git.init();
   await setupDefaultGitAttributes(workspacePath);
   let authUrl = remoteUrl;
   if (remoteUrl.includes("github.com")) {
-    let cleanUrl = remoteUrl.replace("git@github.com:", "https://github.com/");
+    const cleanUrl = remoteUrl.replace("git@github.com:", "https://github.com/");
     if (cleanUrl.startsWith("https://github.com/")) {
       authUrl = cleanUrl.replace(
         "https://github.com/",
@@ -1699,9 +1927,13 @@ async function setupUniversalWorkspace(sessionId, remoteUrl, branch, baseBranch,
     await git.addConfig("user.name", "gitelectron");
     await git.addConfig("user.email", "noreply@gitelectron.local");
   }
-  await git.raw(["sparse-checkout", "init", "--cone"]);
-  const sparsePath = destinationPath === "/" || destinationPath === "" ? "" : destinationPath;
-  await git.raw(["sparse-checkout", "set", sparsePath]);
+  try {
+    await git.raw(["sparse-checkout", "init", "--cone"]);
+    const sparsePath = destinationPath === "/" || destinationPath === "" ? "" : destinationPath;
+    await git.raw(["sparse-checkout", "set", sparsePath]);
+  } catch (sparseErr) {
+    console.warn("Sparse checkout setup notice:", sparseErr);
+  }
   const branchToFetch = baseBranch || branch;
   try {
     await git.fetch(["--depth", "1", "origin", branchToFetch]);
@@ -1729,7 +1961,7 @@ async function checkUniversalCollisions(workspacePath, sourceFiles, destinationP
       await fs__namespace.copyFile(source, path__namespace.join(destDirFull, path__namespace.basename(source)));
     }
   }
-  const git = simpleGit.simpleGit(workspacePath);
+  const git = createSafeGit(workspacePath);
   const status = await git.status();
   return {
     modified: status.modified,
@@ -1737,28 +1969,18 @@ 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 = createSafeGit(workspacePath);
   try {
     const diff = await git.raw(["diff", "--", filePath]);
     return diff;
-  } catch (e) {
+  } catch {
     return "";
   }
 }
 async function commitUniversalWorkspace(workspacePath, message, branch) {
-  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"
-  });
+  const git = createSafeGit(workspacePath);
   try {
+    await ensureAiWeightsUseLfs(git);
     await git.raw([
       "-c",
       "core.safecrlf=false",
@@ -1777,12 +1999,12 @@ async function commitUniversalWorkspace(workspacePath, message, branch) {
   }
   await git.commit(message);
   try {
-    await git.raw(["-c", "credential.helper=", "push", "origin", branch]);
+    await git.raw(["-c", "credential.helper=", "push", "--set-upstream", "origin", branch]);
   } catch (err) {
     if (err.message && (err.message.includes("non-fast-forward") || err.message.includes("fetch first") || err.message.includes("branch is behind"))) {
       console.log("Universal push rejected. Auto-pulling with rebase...");
-      await git.pull("origin", branch, { "--rebase": null, "--autostash": null });
-      await git.raw(["-c", "credential.helper=", "push", "origin", branch]);
+      await git.pull("origin", branch, { "--rebase": "false", "--autostash": null, "-X": "ours" });
+      await git.raw(["-c", "credential.helper=", "push", "--set-upstream", "origin", branch]);
       return;
     }
     throw err;
@@ -1843,7 +2065,7 @@ async function cloneRepository(sessionId, remoteUrl, destPath) {
         await existingGit.raw(["-c", "credential.helper=", "fetch", "--progress", "origin"]);
         await new Promise((resolve) => {
           const child = child_process.spawn(
-            "git",
+            getGitBinary(),
             [
               "-c",
               "core.longpaths=true",
@@ -1901,7 +2123,7 @@ async function cloneRepository(sessionId, remoteUrl, destPath) {
       cwd = path__namespace.dirname(destPath);
     }
     await new Promise((resolve, reject) => {
-      const child = child_process.spawn("git", cloneArgs, {
+      const child = child_process.spawn(getGitBinary(), cloneArgs, {
         cwd,
         env: {
           ...process.env,
@@ -1994,13 +2216,14 @@ async function removeGitMetadata(_sessionId, repoPath) {
 }
 async function getDirectoryGitInfo(dir) {
   try {
-    const isRepo = await isGitRepo(dir);
+    const rootPath = await findGitRoot(dir) || dir;
+    const isRepo = await isGitRepo(rootPath);
     if (!isRepo) return { isRepo: false, remotes: [] };
-    const tempGit = createSafeGit(dir);
-    let rootPath = void 0;
+    const tempGit = createSafeGit(rootPath);
+    let detectedRoot = void 0;
     try {
-      rootPath = (await tempGit.revparse(["--show-toplevel"])).trim();
-      if (rootPath) rootPath = path__namespace.normalize(rootPath);
+      detectedRoot = (await tempGit.revparse(["--show-toplevel"])).trim();
+      if (detectedRoot) detectedRoot = path__namespace.normalize(detectedRoot);
     } catch {
     }
     const remotes = await tempGit.getRemotes(true);
@@ -2016,7 +2239,7 @@ async function getDirectoryGitInfo(dir) {
     }
     return {
       isRepo: true,
-      rootPath: rootPath || dir,
+      rootPath: detectedRoot || rootPath,
       remotes: JSON.parse(JSON.stringify(remotes)),
       repoName,
       remoteUrl
@@ -2064,14 +2287,65 @@ async function scanForRepoFolder(repoName, candidateBaseDirs) {
 async function removeGitLock(sessionId) {
   const { repoPath } = getGitSession(sessionId);
   if (!repoPath) return false;
-  const lockPath = require("path").join(repoPath, ".git", "index.lock");
+  const lockPath = path__namespace.join(repoPath, ".git", "index.lock");
   try {
-    await require("fs/promises").unlink(lockPath);
+    await fs__namespace.unlink(lockPath);
     return true;
-  } catch (e) {
+  } catch {
     return false;
   }
 }
+async function ensureAiWeightsUseLfs(git) {
+  try {
+    const aiExtensions = [
+      "*.pt",
+      "*.pth",
+      "*.ckpt",
+      "*.safetensors",
+      "*.bin",
+      "*.onnx",
+      "*.h5",
+      "*.tflite",
+      "*.pb",
+      "*.gguf"
+    ];
+    await git.raw(["lfs", "install"]);
+    for (const ext of aiExtensions) {
+      await git.raw(["lfs", "track", ext]);
+    }
+  } catch (e) {
+    console.warn("Failed to configure LFS for AI weights:", e);
+  }
+}
+const GITHUB_MODELS_CONFIG = {
+  baseURL: "https://models.inference.ai.azure.com",
+  defaultModel: "gpt-4o-mini",
+  fallbackModel: "meta-llama-3.1-8b-instruct"
+};
+const CIPHER_ALGO = "aes-256-cbc";
+const CIPHER_SECRET = "GitElectron_AI_Core_Salt_2026_SecureKey";
+const CIPHER_SALT = "salt_gitelectron";
+const ENCRYPTED_BACKUP_PAYLOAD = "1aa43686251fc27545934564c92ebcd9:acac927d94c7479c0df45b9245f61f47bd4184fca2323e6ce971bc5c74dffaac925caa81788ce81374a05c7072301ee2eac10531be99a850453ff3fd23ea21cd11a8fa95d07d19fe1a8abcdd9a282b06d3e391a621137027c03765f65e977ed432c00e0e9627b2dad77ca708273eff14eac1bbfd01085d4b645a271167bae46edec2a09491b877fba73c3d29dc2e0e2120785347c9189db6bc9892a6018b6dea7ac064b991e9687e2df56e983743985f";
+function getBackupApiKeys() {
+  try {
+    const [ivHex, dataHex] = ENCRYPTED_BACKUP_PAYLOAD.split(":");
+    if (!ivHex || !dataHex) return [];
+    const key = crypto.scryptSync(CIPHER_SECRET, CIPHER_SALT, 32);
+    const iv = Buffer.from(ivHex, "hex");
+    const decipher = crypto.createDecipheriv(CIPHER_ALGO, key, iv);
+    let decrypted = decipher.update(dataHex, "hex", "utf8");
+    decrypted += decipher.final("utf8");
+    return decrypted.split(",").map((k) => k.trim()).filter((k) => k.length > 0);
+  } catch (err) {
+    console.warn("[AI Setup] Failed to decrypt backup keys in memory:", err);
+    return [];
+  }
+}
+function isValidGitHubToken(token) {
+  if (!token || typeof token !== "string") return false;
+  const trimmed = token.trim();
+  return trimmed.startsWith("gho_") || trimmed.startsWith("ghp_") || trimmed.startsWith("github_pat_") || trimmed.length >= 30;
+}
 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.
@@ -2089,15 +2363,23 @@ Return the response strictly as a JSON object with this shape, and absolutely no
   "explanation": "Internal status message...",
   "commandsToRun": ["git merge --abort", "git pull --no-edit -X ours"]
 }`;
-async function analyzeGitError(provider, apiKeyInput, errorMsg, gitStatus, repoPath, githubToken) {
-  if (!apiKeyInput) {
-    if (provider === "gemini") {
-      apiKeyInput = "AQ.Ab8RN6LFu9vxQBWCSzE72V4CG2ILxnreqAP4AZQzSmXZ_1vphw";
-    } else {
-      apiKeyInput = "deepseek-hardcoded-key-if-applicable";
+async function generateWithGemini(genAI, contents) {
+  const models = ["gemini-2.0-flash", "gemini-1.5-flash-latest", "gemini-1.5-flash"];
+  let lastErr = null;
+  for (const modelName of models) {
+    try {
+      const model = genAI.getGenerativeModel({ model: modelName });
+      const result = await model.generateContent(contents);
+      return result.response.text();
+    } catch (err) {
+      lastErr = err;
+      continue;
     }
   }
-  const keys = apiKeyInput.split(",").map((k) => k.trim()).filter((k) => k);
+  throw lastErr || new Error("All Gemini model fallbacks failed");
+}
+async function analyzeGitError(provider, apiKeyInput, errorMsg, gitStatus, repoPath, githubToken) {
+  const keys = apiKeyInput ? apiKeyInput.split(",").map((k) => k.trim()).filter((k) => k) : getBackupApiKeys();
   const prompt = `
 GIT STATUS:
 ${JSON.stringify(gitStatus, null, 2)}
@@ -2140,9 +2422,7 @@ ${errorMsg}
     try {
       if (provider === "gemini") {
         const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
-        const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
-        const result = await model.generateContent([{ text: SYSTEM_PROMPT }, { text: prompt }]);
-        responseText = result.response.text();
+        responseText = await generateWithGemini(genAI, [{ text: SYSTEM_PROMPT }, { text: prompt }]);
       } else if (provider === "deepseek") {
         const openai = new OpenAI({
           apiKey,
@@ -2245,10 +2525,7 @@ Guidelines:
 - If there are no conflicted files (e.g. just a standard rejection that a pull will fix), omit "resolvedCode".
 - Return ONLY valid JSON. No markdown code block wrappers.`;
 async function analyzePushErrorForAutoSync(provider, apiKeyInput, errorMsg, gitStatus, _repoPath, conflictedFilesContext, githubToken) {
-  if (!apiKeyInput && provider === "gemini") {
-    apiKeyInput = "AQ.Ab8RN6LFu9vxQBWCSzE72V4CG2ILxnreqAP4AZQzSmXZ_1vphw";
-  }
-  const keys = apiKeyInput.split(",").map((k) => k.trim()).filter((k) => k);
+  const keys = getBackupApiKeys();
   let prompt = `
 GIT STATUS:
 ${JSON.stringify(gitStatus, null, 2)}
@@ -2269,14 +2546,14 @@ ${content}
     }
   }
   let lastError = null;
-  if (githubToken) {
+  if (isValidGitHubToken(githubToken)) {
     try {
       const openai = new OpenAI({
         apiKey: githubToken,
-        baseURL: "https://models.inference.ai.azure.com"
+        baseURL: GITHUB_MODELS_CONFIG.baseURL
       });
       const response = await openai.chat.completions.create({
-        model: "gpt-4o-mini",
+        model: GITHUB_MODELS_CONFIG.defaultModel,
         messages: [
           { role: "system", content: AUTO_SYNC_SYSTEM_PROMPT },
           { role: "user", content: prompt }
@@ -2298,12 +2575,10 @@ ${content}
     try {
       if (provider === "gemini") {
         const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
-        const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
-        const result = await model.generateContent([
+        responseText = await generateWithGemini(genAI, [
           { text: AUTO_SYNC_SYSTEM_PROMPT },
           { text: prompt }
         ]);
-        responseText = result.response.text();
       }
       responseText = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
       const parsed = JSON.parse(responseText);
@@ -2330,17 +2605,17 @@ If the diff is empty or invalid, return "Auto-sync: update files".`;
   const prompt = `GIT DIFF:
 ${truncatedDiff}`;
   let keys = "".split(",").map((k) => k.trim()).filter((k) => k);
-  if (!keys.length && provider === "gemini") {
-    keys = ["AQ.Ab8RN6LFu9vxQBWCSzE72V4CG2ILxnreqAP4AZQzSmXZ_1vphw"];
+  if (!keys.length) {
+    keys = getBackupApiKeys();
   }
-  if (githubToken) {
+  if (isValidGitHubToken(githubToken)) {
     try {
       const openai = new OpenAI({
         apiKey: githubToken,
-        baseURL: "https://models.inference.ai.azure.com"
+        baseURL: GITHUB_MODELS_CONFIG.baseURL
       });
       const response = await openai.chat.completions.create({
-        model: "gpt-4o-mini",
+        model: GITHUB_MODELS_CONFIG.defaultModel,
         messages: [
           { role: "system", content: systemPrompt },
           { role: "user", content: prompt }
@@ -2356,9 +2631,8 @@ ${truncatedDiff}`;
     try {
       if (provider === "gemini") {
         const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
-        const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
-        const result = await model.generateContent([{ text: systemPrompt }, { text: prompt }]);
-        return result.response.text().trim();
+        const text = await generateWithGemini(genAI, [{ text: systemPrompt }, { text: prompt }]);
+        return text.trim();
       }
     } catch (e) {
       console.warn(`[AI Service] Provider ${provider} commit gen failed: ${e.message}`);
@@ -2403,6 +2677,22 @@ let globalOnResolveComplete = null;
 let globalOnMassiveProgress = null;
 const DEBOUNCE_MS = 3e3;
 const changedFiles = /* @__PURE__ */ new Set();
+function stopAutoSync() {
+  isAutoSyncEnabled = false;
+  if (currentWatcher) {
+    currentWatcher.close();
+    currentWatcher = null;
+  }
+  if (syncTimeout) {
+    clearTimeout(syncTimeout);
+    syncTimeout = null;
+  }
+  if (remotePollInterval) {
+    clearInterval(remotePollInterval);
+    remotePollInterval = null;
+  }
+  changedFiles.clear();
+}
 function toggleAutoSync(sessionId, repoPath, enabled, onLog, onErrorApproval, onResolveComplete, onMassiveProgress) {
   isAutoSyncEnabled = enabled;
   globalOnLog = onLog;
@@ -2446,9 +2736,9 @@ function toggleAutoSync(sessionId, repoPath, enabled, onLog, onErrorApproval, on
   }, 25e3);
   currentWatcher = chokidar.watch(repoPath, {
     ignored: [
-      /(^|[\/\\])\.git([\/\\]|$)/,
+      /(^|[/\\])\.git([/\\]|$)/,
       // strictly ignore .git directory
-      /(^|[\/\\])\.DS_Store$/,
+      /(^|[/\\])\.DS_Store$/,
       // strictly ignore .DS_Store files
       /node_modules/,
       /dist/,
@@ -2457,7 +2747,11 @@ function toggleAutoSync(sessionId, repoPath, enabled, onLog, onErrorApproval, on
       // ignore Office temp lock files (~$README.md, etc.)
     ],
     persistent: true,
-    ignoreInitial: true
+    ignoreInitial: true,
+    awaitWriteFinish: {
+      stabilityThreshold: 2e3,
+      pollInterval: 100
+    }
   });
   currentWatcher.on("all", (_event, filePath) => {
     if (!isAutoSyncEnabled || isResolving) return;
@@ -2514,7 +2808,7 @@ async function triggerSyncSequence(sessionId, _repoPath, onLog) {
       return;
     }
     const branch = finalStatus.current || "main";
-    onLog("Generating AI commit message...");
+    onLog("🤖 Generating commit summary via GitHub Models...");
     let commitMsg = `Auto-sync: update ${filesToSync.length > 1 ? filesToSync.length + " files" : filesToSync[0]}`;
     try {
       const diffStr = await getFileDiff(sessionId, "", true);
@@ -2532,7 +2826,7 @@ async function triggerSyncSequence(sessionId, _repoPath, onLog) {
     await commitChanges(sessionId, commitMsg);
     onLog(`Pushing to ${branch}...`);
     await pushToRemote(sessionId, "origin", branch);
-    onLog(`✅ Successfully pushed auto-sync commit!`);
+    onLog(`✅ Pushed to origin/${branch} [${(/* @__PURE__ */ new Date()).toLocaleTimeString()}]`);
   } catch (error) {
     onLog(`❌ Auto-sync failed: ${error.message}`);
     if (globalOnErrorApproval && !isResolving) {
@@ -2552,10 +2846,10 @@ async function handleAutoSyncError(sessionId, errorMsg, onLog) {
   }
   if (errorMsg.includes("index.lock")) {
     onLog("Git lock detected. Automatically clearing zombie lock file...");
-    const lockPath = require("path").join(repoPath, ".git", "index.lock");
+    const lockPath = path__namespace.join(repoPath, ".git", "index.lock");
     try {
-      await require("fs/promises").unlink(lockPath);
-    } catch (e) {
+      await fs__namespace.unlink(lockPath);
+    } catch {
     }
     isResolving = false;
     return;
@@ -2564,7 +2858,11 @@ async function handleAutoSyncError(sessionId, errorMsg, onLog) {
     onLog("Pulling remote changes with rebase...");
     const status2 = await getStatus(sessionId);
     const currentBranch = status2.current || "main";
-    await git.pull("origin", currentBranch, { "--rebase": "true", "--autostash": null });
+    await git.pull("origin", currentBranch, {
+      "--rebase": "false",
+      "--autostash": null,
+      "-X": "ours"
+    });
     onLog("Pull successful, attempting push again...");
     await pushToRemote(sessionId, "origin", currentBranch);
     onLog("✅ Error resolved and push resumed!");
@@ -2593,7 +2891,7 @@ async function handleAutoSyncError(sessionId, errorMsg, onLog) {
     try {
       const content = await fs__namespace.readFile(path__namespace.join(repoPath, f), "utf-8");
       conflictedFilesContext[f] = content;
-    } catch (e) {
+    } catch {
     }
   }
   try {
@@ -2657,7 +2955,7 @@ async function applyAiFixAndResume(sessionId, resolvedCode) {
     }
     try {
       await git.rebase({ "--continue": null });
-    } catch (e) {
+    } catch {
       await git.commit("Auto-resolved merge conflict by AI");
     }
     const status = await getStatus(sessionId);
@@ -2677,6 +2975,53 @@ function cancelAiFix() {
   isResolving = false;
 }
 const icon = path.join(__dirname, "../../resources/icon.png");
+if (process.platform === "darwin") {
+  const macPaths = [
+    "/opt/homebrew/bin",
+    "/opt/homebrew/sbin",
+    "/usr/local/bin",
+    "/usr/local/sbin",
+    "/usr/bin",
+    "/bin",
+    "/usr/sbin",
+    "/sbin"
+  ];
+  const pathParts = (process.env.PATH || "").split(":").filter(Boolean);
+  for (const p of macPaths) {
+    if (!pathParts.includes(p)) {
+      pathParts.unshift(p);
+    }
+  }
+  process.env.PATH = pathParts.join(":");
+} else if (process.platform === "win32") {
+  const localAppData = process.env.LOCALAPPDATA || "";
+  const programFiles = process.env.ProgramFiles || "C:\\Program Files";
+  const programFilesX86 = process.env["ProgramFiles(x86)"] || "C:\\Program Files (x86)";
+  const userProfile = process.env.USERPROFILE || "";
+  const programData = process.env.ProgramData || "C:\\ProgramData";
+  const winPaths = [
+    path__namespace.join(programFiles, "Git", "cmd"),
+    path__namespace.join(programFiles, "Git", "bin"),
+    path__namespace.join(programFiles, "Git", "mingw64", "bin"),
+    path__namespace.join(programFilesX86, "Git", "cmd"),
+    path__namespace.join(programFilesX86, "Git", "bin"),
+    path__namespace.join(localAppData, "Programs", "Git", "cmd"),
+    path__namespace.join(localAppData, "Programs", "Git", "bin"),
+    path__namespace.join(userProfile, "scoop", "shims"),
+    path__namespace.join(programData, "chocolatey", "bin")
+  ];
+  const pathParts = (process.env.PATH || "").split(";").filter(Boolean);
+  for (const p of winPaths) {
+    if (!pathParts.includes(p)) {
+      pathParts.unshift(p);
+    }
+  }
+  process.env.PATH = pathParts.join(";");
+}
+if (process.platform === "win32") {
+  electron.app.commandLine.appendSwitch("disable-features", "CalculateNativeWinOcclusion");
+  electron.app.commandLine.appendSwitch("disable-color-correct-rendering");
+}
 function createWindow(initialPath) {
   const mainWindow = new electron.BrowserWindow({
     width: 1100,
@@ -2700,6 +3045,7 @@ function createWindow(initialPath) {
   mainWindow.on("closed", () => {
     cleanupSession(sessionId);
     cleanupGitSession(sessionId);
+    stopAutoSync();
   });
   mainWindow.webContents.setWindowOpenHandler((details) => {
     electron.shell.openExternal(details.url);
@@ -2745,15 +3091,67 @@ electron.app.on("second-instance", (_event, commandLine, workingDirectory) => {
 });
 if (process.defaultApp) {
   if (process.argv.length >= 2) {
-    electron.app.setAsDefaultProtocolClient("gitelectron", process.execPath, [
-      require("path").resolve(process.argv[1])
-    ]);
+    electron.app.setAsDefaultProtocolClient("gitelectron", process.execPath, [path__namespace.resolve(process.argv[1])]);
   }
 } else {
   electron.app.setAsDefaultProtocolClient("gitelectron");
 }
 electron.app.whenReady().then(async () => {
   utils.electronApp.setAppUserModelId("com.electron");
+  try {
+    createSafeGit().raw(["config", "--global", "safe.directory", "*"]).catch(() => {
+    });
+  } catch {
+  }
+  if (process.platform === "darwin") {
+    const template = [
+      {
+        label: electron.app.name,
+        submenu: [
+          { role: "about" },
+          { type: "separator" },
+          { role: "services" },
+          { type: "separator" },
+          { role: "hide" },
+          { role: "hideOthers" },
+          { role: "unhide" },
+          { type: "separator" },
+          { role: "quit" }
+        ]
+      },
+      {
+        label: "Edit",
+        submenu: [
+          { role: "undo" },
+          { role: "redo" },
+          { type: "separator" },
+          { role: "cut" },
+          { role: "copy" },
+          { role: "paste" },
+          { role: "selectAll" }
+        ]
+      },
+      {
+        label: "View",
+        submenu: [
+          { role: "reload" },
+          { role: "forceReload" },
+          { role: "toggleDevTools" },
+          { type: "separator" },
+          { role: "resetZoom" },
+          { role: "zoomIn" },
+          { role: "zoomOut" },
+          { type: "separator" },
+          { role: "togglefullscreen" }
+        ]
+      },
+      {
+        label: "Window",
+        submenu: [{ role: "minimize" }, { role: "zoom" }, { type: "separator" }, { role: "front" }]
+      }
+    ];
+    electron.Menu.setApplicationMenu(electron.Menu.buildFromTemplate(template));
+  }
   await loadAccounts();
   electron.app.on("browser-window-created", (_, window) => {
     utils.optimizer.watchWindowShortcuts(window);
@@ -2786,25 +3184,33 @@ electron.app.whenReady().then(async () => {
     if (result.canceled || result.filePaths.length === 0) {
       return null;
     }
-    const path2 = result.filePaths[0];
-    const isRepo = await isGitRepo(path2);
+    const chosenPath = result.filePaths[0];
+    const rootPath = await findGitRoot(chosenPath) || chosenPath;
+    const isRepo = await isGitRepo(rootPath);
+    recordSessionPath(sessionId, rootPath);
     if (isRepo) {
-      initGit(sessionId, path2);
+      initGit(sessionId, rootPath);
     }
-    await saveLastWorkspace(path2);
-    return { path: path2, isRepo };
+    await saveLastWorkspace(rootPath);
+    return { path: rootPath, isRepo };
   });
-  electron.ipcMain.handle("set-repo-path", async (event, path2) => {
+  electron.ipcMain.handle("set-repo-path", async (event, inputPath) => {
     const sessionId = event.sender.id;
-    const isRepo = await isGitRepo(path2);
+    if (!inputPath) return { path: "", isRepo: false };
+    const rootPath = await findGitRoot(inputPath) || inputPath;
+    const isRepo = await isGitRepo(rootPath);
+    recordSessionPath(sessionId, rootPath);
     if (isRepo) {
-      initGit(sessionId, path2);
+      initGit(sessionId, rootPath);
     }
-    await saveLastWorkspace(path2);
-    return { path: path2, isRepo };
+    await saveLastWorkspace(rootPath);
+    return { path: rootPath, isRepo };
   });
   electron.ipcMain.handle("init-repo", async (event, path2) => {
-    return await initializeRepo(event.sender.id, path2);
+    recordSessionPath(event.sender.id, path2);
+    const result = await initializeRepo(event.sender.id, path2);
+    await saveLastWorkspace(path2);
+    return result;
   });
   electron.ipcMain.handle("get-status", async (event) => {
     return await getStatus(event.sender.id);
@@ -3031,6 +3437,20 @@ electron.app.whenReady().then(async () => {
   electron.ipcMain.handle("remove-git-lock", async (event) => {
     return await removeGitLock(event.sender.id);
   });
+  electron.ipcMain.handle("clear-app-cache", async (event) => {
+    try {
+      if (electron.session.defaultSession) {
+        await electron.session.defaultSession.clearCache();
+      }
+      try {
+        await removeGitLock(event.sender.id);
+      } catch {
+      }
+      return { success: true };
+    } catch (e) {
+      return { success: false, error: e.message };
+    }
+  });
   electron.ipcMain.handle("check-path-exists", async (_event, targetPath) => {
     if (!targetPath) return false;
     try {
@@ -3092,9 +3512,8 @@ electron.app.whenReady().then(async () => {
   });
   electron.ipcMain.handle("check-updates", async () => {
     try {
-      const https = require("https");
       return new Promise((resolve) => {
-        https.get("https://registry.npmjs.org/gitelectron/latest", (res) => {
+        https__namespace.get("https://registry.npmjs.org/gitelectron/latest", (res) => {
           let data = "";
           res.on("data", (chunk) => {
             data += chunk;
@@ -3103,31 +3522,39 @@ electron.app.whenReady().then(async () => {
             try {
               const json = JSON.parse(data);
               resolve(json.version || null);
-            } catch (e) {
+            } catch {
               resolve(null);
             }
           });
         }).on("error", () => resolve(null));
       });
-    } catch (e) {
+    } catch {
       return null;
     }
   });
   electron.ipcMain.handle("install-update", async () => {
     return new Promise((resolve) => {
-      const { spawn } = require("child_process");
-      const cmdArgs = [
-        "/c",
-        "start",
-        "cmd.exe",
-        "/c",
-        "echo Waiting for Git Electron to close so it can be safely updated... & timeout /t 3 /nobreak > nul & echo Installing Update... & npm i -g gitelectron@latest gitquickpush-cli@latest & echo Update Complete! Starting application... & gitelectron open & exit"
-      ];
-      const child = spawn("cmd.exe", cmdArgs, {
-        detached: true,
-        stdio: "ignore"
-      });
-      child.unref();
+      if (process.platform === "win32") {
+        const cmdArgs = [
+          "/c",
+          "start",
+          "cmd.exe",
+          "/c",
+          "echo Waiting for Git Electron to close so it can be safely updated... & timeout /t 3 /nobreak > nul & echo Installing Update... & npm i -g gitelectron@latest gitquickpush-cli@latest & echo Update Complete! Starting application... & gitelectron open & exit"
+        ];
+        const child = child_process.spawn("cmd.exe", cmdArgs, {
+          detached: true,
+          stdio: "ignore"
+        });
+        child.unref();
+      } else {
+        const shScript = "sleep 3; npm i -g gitelectron@latest gitquickpush-cli@latest; gitelectron open";
+        const child = child_process.spawn("sh", ["-c", shScript], {
+          detached: true,
+          stdio: "ignore"
+        });
+        child.unref();
+      }
       resolve(true);
       setTimeout(() => {
         electron.app.exit(0);