gitxelectron 1.3.8 → 1.4.1

package/out/main/index.js

@@ -111,8 +111,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", {
@@ -601,7 +617,7 @@ function initGit(sessionId, baseDir) {
       try {
         const wc = electron.webContents.fromId(sessionId);
         if (wc) wc.send("git-progress", { method, stage, progress });
-      } catch (e) {
+      } catch {
       }
     }
   };
@@ -612,6 +628,20 @@ function initGit(sessionId, baseDir) {
     GIT_ASKPASS: "echo"
   });
   gitSessions.set(sessionId, { git, repoPath: baseDir });
+  (async () => {
+    try {
+      const name = await git.getConfig("user.name");
+      if (!name.value) {
+        await git.addConfig("user.name", "GitElectron User");
+      }
+      const email = await git.getConfig("user.email");
+      if (!email.value) {
+        await git.addConfig("user.email", "auto@gitelectron.local");
+      }
+    } catch (e) {
+      console.warn("Failed to ensure git identity:", e);
+    }
+  })();
 }
 function createSafeGit(baseDir, sessionId) {
   const options = {
@@ -628,7 +658,7 @@ function createSafeGit(baseDir, sessionId) {
       try {
         const wc = electron.webContents.fromId(sessionId);
         if (wc) wc.send("git-progress", { method, stage, progress });
-      } catch (e) {
+      } catch {
       }
     }
   };
@@ -687,9 +717,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`);
@@ -699,7 +729,7 @@ 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) {
@@ -829,6 +859,7 @@ async function getStatus(sessionId) {
 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 = [];
@@ -839,7 +870,7 @@ async function stageFiles(sessionId, files) {
         if (stats.isFile() && stats.size > LARGE_FILE_LIMIT) {
           largeFiles.push(file);
         }
-      } catch (e) {
+      } catch {
       }
     }
     if (largeFiles.length > 0) {
@@ -893,6 +924,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");
@@ -922,7 +954,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\//,
@@ -933,7 +965,8 @@ 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 });
@@ -951,7 +984,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...");
@@ -1004,7 +1036,7 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
           if (stats.isFile() && stats.size > LARGE_FILE_LIMIT) {
             largeFiles.push(file);
           }
-        } catch (e) {
+        } catch {
         }
       })
     );
@@ -1041,7 +1073,7 @@ async function pushMassiveRepository(sessionId, remote, branch, chunkSize = 5e3,
     } finally {
       try {
         await fs__namespace.unlink(tempFile);
-      } catch (e) {
+      } catch {
       }
     }
   };
@@ -1069,7 +1101,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 = [
@@ -1094,7 +1126,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 {
@@ -1148,7 +1180,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);
@@ -1160,6 +1192,85 @@ async function pushToRemote(sessionId, remote, branch) {
     throw err;
   }
 }
+async function masterForcePush(sessionId, remote, branch) {
+  const { git, repoPath } = getGitSession(sessionId);
+  const remotes = await getRemotes(sessionId);
+  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");
+    const email = await git.getConfig("user.email");
+    if (!email.value) await git.addConfig("user.email", "auto@gitelectron.local");
+  } catch (e) {
+    console.warn("Failed to ensure git identity before master push:", e);
+  }
+  try {
+    await git.commit("Master Force Push - Sync changes");
+  } catch (e) {
+    if (!e.message.includes("nothing to commit")) {
+      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 pushArgs = [
+    "-c",
+    "credential.helper=",
+    "-c",
+    "filter.lfs.required=false",
+    "-c",
+    "lfs.allowincompletepush=true",
+    "push",
+    "--progress",
+    "--no-verify",
+    "-f"
+  ];
+  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 || "origin", branch]);
+}
 async function pullFromRemote(sessionId, remote, branch) {
   const { git, repoPath } = getGitSession(sessionId);
   const remotes = await getRemotes(sessionId);
@@ -1168,6 +1279,14 @@ async function pullFromRemote(sessionId, remote, branch) {
   }
   const remoteObj = (remote ? remotes.find((r) => r.name === remote) : null) || remotes[0];
   const targetRemote = remoteObj.name;
+  try {
+    const name = await git.getConfig("user.name");
+    if (!name.value) await git.addConfig("user.name", "GitElectron User");
+    const email = await git.getConfig("user.email");
+    if (!email.value) await git.addConfig("user.email", "auto@gitelectron.local");
+  } catch (e) {
+    console.warn("Failed to ensure git identity before pull:", e);
+  }
   let targetBranch = branch;
   if (!targetBranch) {
     const status = await git.status();
@@ -1185,11 +1304,19 @@ async function pullFromRemote(sessionId, remote, branch) {
   let didStash = false;
   try {
     const status = await git.status();
+    if (status.conflicted && status.conflicted.length > 0) {
+      throw new Error(
+        `Pulling is not possible because you have unmerged files (${status.conflicted.join(", ")}). Please resolve conflicts or abort the merge.`
+      );
+    }
     if (!status.isClean()) {
       await git.raw(["stash", "push", "-u", "-m", "gitquickpush-autostash-before-pull"]);
       didStash = true;
     }
   } catch (err) {
+    if (err.message && err.message.includes("unmerged files")) {
+      throw err;
+    }
     console.warn("Stash check before pull warning:", err);
   }
   try {
@@ -1207,6 +1334,8 @@ async function pullFromRemote(sessionId, remote, branch) {
       "pull",
       "--no-rebase",
       "--allow-unrelated-histories",
+      "-X",
+      "ours",
       authUrl,
       targetBranch
     ];
@@ -1366,7 +1495,7 @@ async function getBranches(sessionId) {
         )
       ]);
     }
-  } catch (e) {
+  } catch {
   }
   let branches = await git.branch(["-a"]);
   if (branches.all.length === 0) {
@@ -1388,10 +1517,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);
@@ -1478,15 +1611,11 @@ async function pushAllBranches(sessionId, remote) {
     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;
+  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"]);
 }
 async function getCommitHistory(sessionId) {
   const { git } = getGitSession(sessionId);
@@ -1504,17 +1633,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: [] };
   }
 }
@@ -1608,7 +1747,7 @@ async function setupUniversalWorkspace(sessionId, remoteUrl, branch, baseBranch,
   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/",
@@ -1671,7 +1810,7 @@ async function getUniversalDiff(workspacePath, filePath) {
   try {
     const diff = await git.raw(["diff", "--", filePath]);
     return diff;
-  } catch (e) {
+  } catch {
     return "";
   }
 }
@@ -1686,6 +1825,7 @@ async function commitUniversalWorkspace(workspacePath, message, branch) {
     GIT_ASKPASS: "echo"
   });
   try {
+    await ensureAiWeightsUseLfs(git);
     await git.raw([
       "-c",
       "core.safecrlf=false",
@@ -1708,7 +1848,7 @@ async function commitUniversalWorkspace(workspacePath, message, 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.pull("origin", branch, { "--rebase": "false", "--autostash": null, "-X": "ours" });
       await git.raw(["-c", "credential.helper=", "push", "origin", branch]);
       return;
     }
@@ -1991,191 +2131,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 masterPush(sessionId, remote, branch) {
-  const { git, repoPath } = getGitSession(sessionId);
-  const remotes = await getRemotes(sessionId);
-  const remoteObj = (remote ? remotes.find((r) => r.name === remote) : null) || remotes[0];
-  if (!remoteObj) throw new Error("No remote repository configured.");
-  const targetRemote = remoteObj.name;
-  const authUrl = remoteObj.refs?.push ? injectAuthToken(sessionId, remoteObj.refs.push) : targetRemote;
-  let originalBranch = branch;
+async function ensureAiWeightsUseLfs(git) {
   try {
-    const branchSummary = await git.branchLocal();
-    originalBranch = branchSummary.current || branch;
-  } catch (e) {
-  }
-  const tempBranch = `__master_push_temp_${Date.now()}`;
-  const hiddenPointers = [];
-  const cleanedAttrsFiles = [];
-  const lfsOffFlags = [
-    "-c",
-    "filter.lfs.clean=cat",
-    "-c",
-    "filter.lfs.smudge=cat",
-    "-c",
-    "filter.lfs.process=",
-    "-c",
-    "filter.lfs.required=false",
-    "-c",
-    "lfs.allowincompletepush=true",
-    "-c",
-    "http.postBuffer=524288000",
-    "-c",
-    "credential.helper="
-  ];
-  function runGit(args, allowFail = false) {
-    return new Promise((resolve, reject) => {
-      const child = child_process.spawn("git", [...lfsOffFlags, ...args], {
-        cwd: repoPath,
-        env: {
-          ...process.env,
-          GIT_LFS_SKIP_SMUDGE: "1",
-          GIT_LFS_SKIP_PUSH: "1",
-          GCM_INTERACTIVE: "false",
-          GIT_TERMINAL_PROMPT: "0",
-          GIT_ASKPASS: "echo"
-        }
-      });
-      const stdout = [];
-      const stderr = [];
-      child.stdout?.on("data", (d) => stdout.push(d.toString()));
-      child.stderr?.on("data", (d) => stderr.push(d.toString()));
-      child.on("error", (err) => allowFail ? resolve("") : reject(err));
-      child.on("close", (code) => {
-        if (code === 0 || allowFail) {
-          resolve(stdout.join(""));
-        } else {
-          reject(new Error(stderr.join("") || `git exited with code ${code}`));
-        }
-      });
-    });
-  }
-  async function processRepo(dir) {
-    let entries;
-    try {
-      entries = await fs__namespace.readdir(dir, { withFileTypes: true });
-    } catch (e) {
-      return;
-    }
-    for (const entry of entries) {
-      if (entry.name === ".git" || entry.name === "node_modules" || entry.name.endsWith(".__lfs_ptr_bak__"))
-        continue;
-      const fullPath = path__namespace.join(dir, entry.name);
-      if (entry.isDirectory()) {
-        await processRepo(fullPath);
-        continue;
-      }
-      if (!entry.isFile()) continue;
-      try {
-        if (entry.name === ".gitattributes") {
-          const content = await fs__namespace.readFile(fullPath, "utf8");
-          if (content.includes("filter=lfs") || content.includes("lfs")) {
-            cleanedAttrsFiles.push({ filePath: fullPath, original: content });
-            const cleaned = content.split("\n").filter((line) => !line.toLowerCase().includes("lfs")).join("\n");
-            await fs__namespace.writeFile(fullPath, cleaned);
-          }
-          continue;
-        }
-        const stat = await fs__namespace.stat(fullPath);
-        if (stat.size < 4096 && stat.size > 20) {
-          const buf = await fs__namespace.readFile(fullPath);
-          const text = buf.toString("utf8");
-          if (text.includes("version https://git-lfs.github.com/spec/v1") && text.includes("oid sha256:")) {
-            const backupPath = fullPath + ".__lfs_ptr_bak__";
-            await fs__namespace.rename(fullPath, backupPath);
-            hiddenPointers.push({ original: fullPath, backup: backupPath });
-          }
-        }
-      } catch (e) {
-      }
+    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 {
-    try {
-      await git.raw(["lfs", "uninstall", "--local"]);
-    } catch (e) {
-    }
-    try {
-      await git.addConfig("filter.lfs.clean", "cat");
-      await git.addConfig("filter.lfs.smudge", "cat");
-      await git.addConfig("filter.lfs.process", "");
-      await git.addConfig("filter.lfs.required", "false");
-    } catch (e) {
-    }
-    await processRepo(repoPath);
-    await runGit(["checkout", "--orphan", tempBranch]);
-    await runGit(["add", "."]);
-    try {
-      const grepResult = await runGit(
-        ["grep", "--cached", "-l", "version https://git-lfs.github.com/spec/v1"],
-        true
-      );
-      if (grepResult.trim()) {
-        const lfsFiles = grepResult.trim().split("\n").filter(Boolean);
-        for (const f of lfsFiles) {
-          await runGit(["rm", "--cached", "--force", f.trim()], true);
-        }
-      }
-    } catch (e) {
-    }
-    try {
-      await runGit(["commit", "-m", "Master Override Push", "--no-verify"]);
-    } catch (e) {
-    }
-    await runGit(["push", "--force", "--no-verify", authUrl, `${tempBranch}:${branch}`]);
-  } finally {
-    try {
-      await runGit(["checkout", "-f", originalBranch], true);
-    } catch (e) {
-      try {
-        await runGit(["checkout", "-f", branch], true);
-      } catch (e2) {
-        try {
-          await runGit(["checkout", "-b", branch], true);
-        } catch (e3) {
-        }
-      }
-    }
-    try {
-      const branchList = await runGit(["branch", "--list", "__master_push_temp_*"], true);
-      if (branchList.trim()) {
-        const branches = branchList.trim().split("\n").map((b) => b.trim().replace(/^\*\s*/, "")).filter(Boolean);
-        for (const b of branches) {
-          await runGit(["branch", "-D", b], true);
-        }
-      }
-    } catch (e) {
-    }
-    try {
-      await runGit(["branch", "-D", tempBranch], true);
-    } catch (e) {
-    }
-    for (const { original, backup } of hiddenPointers) {
-      try {
-        await fs__namespace.rename(backup, original);
-      } catch (e) {
-      }
-    }
-    for (const { filePath, original } of cleanedAttrsFiles) {
-      try {
-        await fs__namespace.writeFile(filePath, original);
-      } catch (e) {
-      }
-    }
-    try {
-      await git.raw(["lfs", "install", "--local"]);
-    } catch (e) {
-    }
+    const [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.
@@ -2194,14 +2208,7 @@ Return the response strictly as a JSON object with this shape, and absolutely no
   "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";
-    }
-  }
-  const keys = apiKeyInput.split(",").map((k) => k.trim()).filter((k) => k);
+  const keys = apiKeyInput ? apiKeyInput.split(",").map((k) => k.trim()).filter((k) => k) : getBackupApiKeys();
   const prompt = `
 GIT STATUS:
 ${JSON.stringify(gitStatus, null, 2)}
@@ -2244,7 +2251,7 @@ ${errorMsg}
     try {
       if (provider === "gemini") {
         const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
-        const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
+        const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
         const result = await model.generateContent([{ text: SYSTEM_PROMPT }, { text: prompt }]);
         responseText = result.response.text();
       } else if (provider === "deepseek") {
@@ -2296,10 +2303,14 @@ ${errorMsg}
       ]
     };
   }
-  if (lowerError.includes("unmerged files") || lowerError.includes("you have unmerged paths")) {
+  if (lowerError.includes("unmerged files") || lowerError.includes("you have unmerged paths") || lowerError.includes("unresolved conflict")) {
     return {
-      explanation: "Unmerged paths detected. Committing current state to proceed...",
-      commandsToRun: ["git add .", 'git commit -m "Auto-resolve unmerged paths"']
+      explanation: "Unmerged files detected. Resolving conflicts by keeping local changes...",
+      commandsToRun: [
+        "git checkout --ours .",
+        "git add .",
+        'git commit -m "Auto-resolved unmerged conflicts (kept local changes)"'
+      ]
     };
   }
   if (lowerError.includes("please tell me who you are")) {
@@ -2345,10 +2356,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)}
@@ -2369,14 +2377,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 }
@@ -2398,7 +2406,7 @@ ${content}
     try {
       if (provider === "gemini") {
         const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
-        const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
+        const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
         const result = await model.generateContent([
           { text: AUTO_SYNC_SYSTEM_PROMPT },
           { text: prompt }
@@ -2430,17 +2438,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 }
@@ -2456,7 +2464,7 @@ ${truncatedDiff}`;
     try {
       if (provider === "gemini") {
         const genAI = new generativeAi.GoogleGenerativeAI(apiKey);
-        const model = genAI.getGenerativeModel({ model: "gemini-2.5-flash" });
+        const model = genAI.getGenerativeModel({ model: "gemini-1.5-flash" });
         const result = await model.generateContent([{ text: systemPrompt }, { text: prompt }]);
         return result.response.text().trim();
       }
@@ -2557,7 +2565,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;
@@ -2614,7 +2626,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);
@@ -2632,7 +2644,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) {
@@ -2664,7 +2676,7 @@ 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!");
@@ -2777,6 +2789,27 @@ 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 currentPath = process.env.PATH || "";
+  const missingPaths = macPaths.filter((p) => !currentPath.includes(p));
+  if (missingPaths.length > 0) {
+    process.env.PATH = `${missingPaths.join(":")}:${currentPath}`;
+  }
+}
+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,
@@ -2932,15 +2965,15 @@ electron.app.whenReady().then(async () => {
     }
     return await pushToRemote(event.sender.id, remote, branch);
   });
+  electron.ipcMain.handle("master-push", async (event, remote, branch) => {
+    return await masterForcePush(event.sender.id, remote, branch);
+  });
   electron.ipcMain.handle("pull-from-remote", async (event, remote, branch) => {
     return await pullFromRemote(event.sender.id, remote, branch);
   });
   electron.ipcMain.handle("check-remote-updates", async (event) => {
     return await checkRemoteUpdates(event.sender.id);
   });
-  electron.ipcMain.handle("master-push", async (event, remote, branch) => {
-    return await masterPush(event.sender.id, remote, branch);
-  });
   electron.ipcMain.handle("reset-to-remote", async (event, remote, branch) => {
     return await resetToRemote(event.sender.id, remote, branch);
   });
@@ -3131,6 +3164,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 {
@@ -3216,18 +3263,27 @@ electron.app.whenReady().then(async () => {
   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 = 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], {
+          detached: true,
+          stdio: "ignore"
+        });
+        child.unref();
+      }
       resolve(true);
       setTimeout(() => {
         electron.app.exit(0);