gitxelectron 1.4.1 → 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();
@@ -395,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();
@@ -602,16 +624,72 @@ 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 {
@@ -628,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");
@@ -645,13 +725,14 @@ 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;
@@ -674,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;
 }
@@ -732,129 +835,220 @@ async function setupDefaultGitAttributes(repoPath) {
   } 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;
     }
-    return false;
   } catch {
-    if (hasGitFolder) {
+  }
+  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;
+        }
+      }
+    }
+  } catch {
+  }
+  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);
@@ -969,7 +1163,7 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
   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) {
@@ -994,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;
@@ -1118,6 +1312,7 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
     "-c",
     "lfs.concurrenttransfers=8",
     "push",
+    "--set-upstream",
     "--progress",
     "--no-verify"
   ];
@@ -1141,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",
@@ -1165,6 +1352,7 @@ async function pushToRemote(sessionId, remote, branch) {
       "-c",
       "lfs.concurrenttransfers=8",
       "push",
+      "--set-upstream",
       "--progress",
       "--no-verify"
     ];
@@ -1242,17 +1430,7 @@ async function masterForcePush(sessionId, remote, branch) {
       console.warn("Commit note:", e.message);
     }
   }
-  const tempGit = simpleGit.simpleGit({
-    baseDir: repoPath,
-    unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true }
-  }).env({
-    ...process.env,
-    GCM_INTERACTIVE: "false",
-    GIT_TERMINAL_PROMPT: "0",
-    GIT_ASKPASS: "echo",
-    GIT_LFS_SKIP_SMUDGE: "1",
-    GIT_LFS_SKIP_PUSH: "1"
-  });
+  const tempGit = createSafeGit(repoPath, sessionId);
   const pushArgs = [
     "-c",
     "credential.helper=",
@@ -1261,6 +1439,7 @@ async function masterForcePush(sessionId, remote, branch) {
     "-c",
     "lfs.allowincompletepush=true",
     "push",
+    "--set-upstream",
     "--progress",
     "--no-verify",
     "-f"
@@ -1340,7 +1519,7 @@ async function pullFromRemote(sessionId, remote, branch) {
       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,
@@ -1415,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=",
@@ -1473,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([
@@ -1569,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);
@@ -1597,25 +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"
-  });
+  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", authUrl, "--all"]);
+    return await tempGit.raw([
+      "-c",
+      "credential.helper=",
+      "push",
+      "--set-upstream",
+      authUrl,
+      "--all"
+    ]);
   }
-  return await tempGit.raw(["-c", "credential.helper=", "push", remote, "--all"]);
+  return await tempGit.raw(["-c", "credential.helper=", "push", "--set-upstream", remote, "--all"]);
 }
 async function getCommitHistory(sessionId) {
   const { git } = getGitSession(sessionId);
@@ -1685,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;
     }
@@ -1739,10 +1900,11 @@ 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;
@@ -1765,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]);
@@ -1795,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,
@@ -1803,10 +1969,7 @@ 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;
@@ -1815,15 +1978,7 @@ 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({
-    ...process.env,
-    GCM_INTERACTIVE: "false",
-    GIT_TERMINAL_PROMPT: "0",
-    GIT_ASKPASS: "echo"
-  });
+  const git = createSafeGit(workspacePath);
   try {
     await ensureAiWeightsUseLfs(git);
     await git.raw([
@@ -1844,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": "false", "--autostash": null, "-X": "ours" });
-      await git.raw(["-c", "credential.helper=", "push", "origin", branch]);
+      await git.raw(["-c", "credential.helper=", "push", "--set-upstream", "origin", branch]);
       return;
     }
     throw err;
@@ -1910,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",
@@ -1968,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,
@@ -2061,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);
@@ -2083,7 +2239,7 @@ async function getDirectoryGitInfo(dir) {
     }
     return {
       isRepo: true,
-      rootPath: rootPath || dir,
+      rootPath: detectedRoot || rootPath,
       remotes: JSON.parse(JSON.stringify(remotes)),
       repoName,
       remoteUrl
@@ -2207,6 +2363,21 @@ 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 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;
+    }
+  }
+  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 = `
@@ -2251,9 +2422,7 @@ ${errorMsg}
     try {
       if (provider === "gemini") {
         const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
-        const model = genAI.getGenerativeModel({ model: "gemini-1.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,
@@ -2406,12 +2575,10 @@ ${content}
     try {
       if (provider === "gemini") {
         const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
-        const model = genAI.getGenerativeModel({ model: "gemini-1.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);
@@ -2464,9 +2631,8 @@ ${truncatedDiff}`;
     try {
       if (provider === "gemini") {
         const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
-        const model = genAI.getGenerativeModel({ model: "gemini-1.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}`);
@@ -2511,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;
@@ -2554,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/,
@@ -2664,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;
@@ -2676,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": "false", "--autostash": null, "-X": "ours" });
+    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!");
@@ -2705,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 {
@@ -2769,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);
@@ -2800,11 +2986,37 @@ if (process.platform === "darwin") {
     "/usr/sbin",
     "/sbin"
   ];
-  const currentPath = process.env.PATH || "";
-  const missingPaths = macPaths.filter((p) => !currentPath.includes(p));
-  if (missingPaths.length > 0) {
-    process.env.PATH = `${missingPaths.join(":")}:${currentPath}`;
+  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");
@@ -2833,6 +3045,7 @@ function createWindow(initialPath) {
   mainWindow.on("closed", () => {
     cleanupSession(sessionId);
     cleanupGitSession(sessionId);
+    stopAutoSync();
   });
   mainWindow.webContents.setWindowOpenHandler((details) => {
     electron.shell.openExternal(details.url);
@@ -2878,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);
@@ -2919,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);
@@ -3239,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;
@@ -3250,19 +3522,18 @@ 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");
       if (process.platform === "win32") {
         const cmdArgs = [
           "/c",
@@ -3271,14 +3542,14 @@ electron.app.whenReady().then(async () => {
           "/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, {
+        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 = spawn("sh", ["-c", shScript], {
+        const child = child_process.spawn("sh", ["-c", shScript], {
           detached: true,
           stdio: "ignore"
         });