gitxelectron 1.1.0

package/out/main/index.js

@@ -0,0 +1,1450 @@
+"use strict";
+const electron = require("electron");
+const path = require("path");
+const simpleGit = require("simple-git");
+const fs = require("fs/promises");
+const crypto = require("crypto");
+const generativeAi = require("@google/generative-ai");
+const OpenAI = require("openai");
+const chokidar = require("chokidar");
+const utils = require("@electron-toolkit/utils");
+function _interopNamespaceDefault(e) {
+  const n = Object.create(null, { [Symbol.toStringTag]: { value: "Module" } });
+  if (e) {
+    for (const k in e) {
+      if (k !== "default") {
+        const d = Object.getOwnPropertyDescriptor(e, k);
+        Object.defineProperty(n, k, d.get ? d : {
+          enumerable: true,
+          get: () => e[k]
+        });
+      }
+    }
+  }
+  n.default = e;
+  return Object.freeze(n);
+}
+const path__namespace = /* @__PURE__ */ _interopNamespaceDefault(path);
+const fs__namespace = /* @__PURE__ */ _interopNamespaceDefault(fs);
+const GITHUB_CLIENT_ID = "Ov23livWfiaPADGiwSXq";
+let accounts = [];
+const activeSessions = /* @__PURE__ */ new Map();
+const ACCOUNTS_PATH = path__namespace.join(electron.app.getPath("userData"), "github_accounts.enc");
+async function loadAccounts() {
+  try {
+    const encrypted = await fs__namespace.readFile(ACCOUNTS_PATH);
+    if (electron.safeStorage.isEncryptionAvailable()) {
+      const decrypted = electron.safeStorage.decryptString(encrypted);
+      accounts = JSON.parse(decrypted);
+    }
+  } catch (e) {
+    accounts = [];
+  }
+}
+async function saveAccounts() {
+  if (electron.safeStorage.isEncryptionAvailable()) {
+    const encrypted = electron.safeStorage.encryptString(JSON.stringify(accounts));
+    await fs__namespace.writeFile(ACCOUNTS_PATH, encrypted);
+  }
+}
+function initSession(sessionId, accountId) {
+  if (accounts.length > 0) {
+    activeSessions.set(sessionId, accounts[0].id);
+  } else {
+    activeSessions.delete(sessionId);
+  }
+}
+function cleanupSession(sessionId) {
+  activeSessions.delete(sessionId);
+}
+function getToken(sessionId) {
+  const accountId = activeSessions.get(sessionId);
+  if (!accountId) return null;
+  const acc = accounts.find((a) => a.id === accountId);
+  return acc ? acc.token : null;
+}
+function getActiveAccount(sessionId) {
+  const accountId = activeSessions.get(sessionId);
+  if (!accountId) return null;
+  return accounts.find((a) => a.id === accountId) || null;
+}
+async function getAccounts(sessionId) {
+  return {
+    accounts: accounts.map((a) => ({ id: a.id, username: a.username, avatar_url: a.avatar_url })),
+    activeAccountId: activeSessions.get(sessionId) || null
+  };
+}
+async function switchAccount(sessionId, accountId) {
+  if (accounts.find((a) => a.id === accountId)) {
+    activeSessions.set(sessionId, accountId);
+    return true;
+  }
+  return false;
+}
+async function removeAccount(accountId) {
+  accounts = accounts.filter((a) => a.id !== accountId);
+  await saveAccounts();
+  for (const [sId, aId] of activeSessions.entries()) {
+    if (aId === accountId) {
+      if (accounts.length > 0) {
+        activeSessions.set(sId, accounts[0].id);
+      } else {
+        activeSessions.delete(sId);
+      }
+    }
+  }
+}
+async function logout(sessionId) {
+  const accountId = activeSessions.get(sessionId);
+  if (accountId) {
+    await removeAccount(accountId);
+  }
+}
+async function getAuthStatus(sessionId) {
+  const activeAccount = getActiveAccount(sessionId);
+  if (!activeAccount) return { status: "Not Authenticated", username: null };
+  return { status: "Verified", username: activeAccount.username };
+}
+async function startDeviceFlow(_sessionId) {
+  const response = await fetch("https://github.com/login/device/code", {
+    method: "POST",
+    headers: {
+      Accept: "application/json",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify({
+      client_id: GITHUB_CLIENT_ID,
+      scope: "repo user"
+    })
+  });
+  const data = await response.json();
+  if (data.error) throw new Error(data.error_description || data.error);
+  return {
+    ...data,
+    verification_uri_complete: data.verification_uri_complete || `${data.verification_uri}?user_code=${data.user_code}`
+  };
+}
+async function pollDeviceFlow(sessionId, deviceCode, intervalMs) {
+  const TIMEOUT_MS = 15 * 60 * 1e3;
+  const startTime = Date.now();
+  let currentInterval = Math.max(intervalMs, 5e3);
+  return new Promise((resolve, reject) => {
+    const poll = async () => {
+      if (Date.now() - startTime > TIMEOUT_MS) {
+        reject(new Error("Authentication timed out."));
+        return;
+      }
+      try {
+        const response = await fetch("https://github.com/login/oauth/access_token", {
+          method: "POST",
+          headers: {
+            Accept: "application/json",
+            "Content-Type": "application/json"
+          },
+          body: JSON.stringify({
+            client_id: GITHUB_CLIENT_ID,
+            device_code: deviceCode,
+            grant_type: "urn:ietf:params:oauth:grant-type:device_code"
+          })
+        });
+        const data = await response.json();
+        if (data.access_token) {
+          const userRes = await fetch("https://api.github.com/user", {
+            headers: {
+              Authorization: `Bearer ${data.access_token}`,
+              Accept: "application/vnd.github.v3+json",
+              "User-Agent": "gitelectron-App"
+            }
+          });
+          if (userRes.ok) {
+            const userData = await userRes.json();
+            const username = userData.login;
+            const existingIndex = accounts.findIndex((a) => a.username === username);
+            const accountId = existingIndex >= 0 ? accounts[existingIndex].id : crypto.randomUUID();
+            const newAccount = {
+              id: accountId,
+              username,
+              token: data.access_token,
+              avatar_url: userData.avatar_url
+            };
+            if (existingIndex >= 0) {
+              accounts[existingIndex] = newAccount;
+            } else {
+              accounts.push(newAccount);
+            }
+            await saveAccounts();
+            activeSessions.set(sessionId, accountId);
+            try {
+              const { setGitConfig: setGitConfig2 } = require("./gitService");
+              const email = `${userData.id}+${username}@users.noreply.github.com`;
+              await setGitConfig2(sessionId, "user.name", username);
+              await setGitConfig2(sessionId, "user.email", email);
+            } catch (e) {
+              console.error("Failed to configure git user", e);
+            }
+            resolve(true);
+            return;
+          } else {
+            reject(new Error("Failed to fetch user profile after auth."));
+            return;
+          }
+        } else if (data.error === "authorization_pending") {
+          setTimeout(poll, currentInterval);
+        } else if (data.error === "slow_down") {
+          currentInterval += 5e3;
+          setTimeout(poll, currentInterval);
+        } else if (data.error === "expired_token") {
+          reject(new Error("The device code has expired."));
+        } else if (data.error === "access_denied") {
+          reject(new Error("Access was denied."));
+        } else if (data.error) {
+          reject(new Error(data.error_description || data.error));
+        } else {
+          setTimeout(poll, currentInterval);
+        }
+      } catch (e) {
+        reject(e);
+      }
+    };
+    poll();
+  });
+}
+async function verifyRepositoryPermission(sessionId, remoteUrl) {
+  if (!remoteUrl.includes("github.com")) return true;
+  const activeAccount = getActiveAccount(sessionId);
+  if (!activeAccount) return true;
+  let owner = "";
+  let repo = "";
+  let parts = remoteUrl.split("github.com");
+  let pathPart = parts[1].replace(/^[:\/]/, "").replace(/\.git$/, "");
+  const pathSplits = pathPart.split("/");
+  if (pathSplits.length >= 2) {
+    owner = pathSplits[0];
+    repo = pathSplits[1];
+  }
+  if (!owner || !repo) return true;
+  try {
+    const res = await fetch(
+      `https://api.github.com/repos/${owner}/${repo}/collaborators/${activeAccount.username}/permission`,
+      {
+        headers: {
+          Authorization: `Bearer ${activeAccount.token}`,
+          Accept: "application/vnd.github.v3+json",
+          "User-Agent": "gitelectron-App"
+        }
+      }
+    );
+    if (res.ok) {
+      const data = await res.json();
+      return ["admin", "write"].includes(data.permission);
+    }
+    if (res.status === 403 || res.status === 404) return false;
+    return true;
+  } catch (e) {
+    return true;
+  }
+}
+async function getUserRepositories(sessionId) {
+  const token = getToken(sessionId);
+  if (!token) throw new Error("Not authenticated in this session");
+  const res = await fetch("https://api.github.com/user/repos?sort=updated&per_page=100", {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "gitelectron-App"
+    }
+  });
+  if (!res.ok) {
+    const errorData = await res.json().catch(() => ({}));
+    throw new Error(errorData.message || "Failed to fetch repositories");
+  }
+  return await res.json();
+}
+async function createGitHubRepository(sessionId, name, description, isPrivate, autoInit = false, gitignoreTemplate = "", licenseTemplate = "") {
+  const token = getToken(sessionId);
+  if (!token) throw new Error("Not authenticated in this session");
+  const bodyData = { name, description, private: isPrivate, auto_init: autoInit };
+  if (gitignoreTemplate) bodyData.gitignore_template = gitignoreTemplate;
+  if (licenseTemplate) bodyData.license_template = licenseTemplate;
+  const res = await fetch("https://api.github.com/user/repos", {
+    method: "POST",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "gitelectron-App",
+      "Content-Type": "application/json"
+    },
+    body: JSON.stringify(bodyData)
+  });
+  if (!res.ok) {
+    const errorData = await res.json().catch(() => ({}));
+    throw new Error(errorData.message || "Failed to create repository");
+  }
+  return await res.json();
+}
+function parseGithubUrl(remoteUrl) {
+  if (!remoteUrl.includes("github.com")) throw new Error("Not a GitHub repository");
+  let parts = remoteUrl.split("github.com");
+  let pathPart = parts[1].replace(/^[:\/]/, "").replace(/\.git$/, "");
+  const pathSplits = pathPart.split("/");
+  if (pathSplits.length >= 2) {
+    return { owner: pathSplits[0], repo: pathSplits[1] };
+  }
+  throw new Error("Invalid GitHub repository URL");
+}
+async function getCollaborators(sessionId, remoteUrl) {
+  const token = getToken(sessionId);
+  if (!token) throw new Error("Not authenticated");
+  const { owner, repo } = parseGithubUrl(remoteUrl);
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "gitelectron-App"
+  };
+  const [collabRes, invRes] = await Promise.all([
+    fetch(`https://api.github.com/repos/${owner}/${repo}/collaborators`, { headers }),
+    fetch(`https://api.github.com/repos/${owner}/${repo}/invitations`, { headers })
+  ]);
+  if (!collabRes.ok) {
+    const errorData = await collabRes.json().catch(() => ({}));
+    throw new Error(
+      errorData.message || "Failed to fetch collaborators (Requires Admin permissions)"
+    );
+  }
+  const collaborators = await collabRes.json();
+  const invitations = invRes.ok ? await invRes.json() : [];
+  return { collaborators, invitations };
+}
+async function addCollaborator(sessionId, remoteUrl, username) {
+  const token = getToken(sessionId);
+  if (!token) throw new Error("Not authenticated");
+  const { owner, repo } = parseGithubUrl(remoteUrl);
+  const res = await fetch(
+    `https://api.github.com/repos/${owner}/${repo}/collaborators/${username}`,
+    {
+      method: "PUT",
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": "gitelectron-App",
+        "Content-Type": "application/json"
+      },
+      body: JSON.stringify({ permission: "push" })
+    }
+  );
+  if (!res.ok) {
+    const errorData = await res.json().catch(() => ({}));
+    throw new Error(errorData.message || "Failed to add collaborator");
+  }
+  if (res.status === 204) return { status: "already_collaborator" };
+  return await res.json();
+}
+async function removeCollaborator(sessionId, remoteUrl, usernameOrId, isInvitation = false) {
+  const token = getToken(sessionId);
+  if (!token) throw new Error("Not authenticated");
+  const { owner, repo } = parseGithubUrl(remoteUrl);
+  const url = isInvitation ? `https://api.github.com/repos/${owner}/${repo}/invitations/${usernameOrId}` : `https://api.github.com/repos/${owner}/${repo}/collaborators/${usernameOrId}`;
+  const res = await fetch(url, {
+    method: "DELETE",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "gitelectron-App"
+    }
+  });
+  if (!res.ok) {
+    const errorData = await res.json().catch(() => ({}));
+    throw new Error(errorData.message || "Failed to remove collaborator");
+  }
+}
+async function searchGitHubUser(sessionId, username) {
+  const token = getToken(sessionId);
+  if (!token) throw new Error("Not authenticated");
+  const res = await fetch(`https://api.github.com/users/${username}`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "gitelectron-App"
+    }
+  });
+  if (!res.ok) {
+    if (res.status === 404) return null;
+    const errorData = await res.json().catch(() => ({}));
+    throw new Error(errorData.message || "Failed to search user");
+  }
+  return await res.json();
+}
+async function getRepositoryBranches(sessionId, owner, repo) {
+  const token = getToken(sessionId);
+  if (!token) throw new Error("Not authenticated");
+  const res = await fetch(`https://api.github.com/repos/${owner}/${repo}/branches`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "gitelectron-App"
+    }
+  });
+  if (!res.ok) {
+    const errorData = await res.json().catch(() => ({}));
+    throw new Error(errorData.message || "Failed to fetch branches");
+  }
+  return await res.json();
+}
+async function getUserInvitations(sessionId) {
+  const token = getToken(sessionId);
+  if (!token) throw new Error("Not authenticated");
+  const res = await fetch("https://api.github.com/user/repository_invitations", {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "gitelectron-App"
+    }
+  });
+  if (!res.ok) {
+    const errorData = await res.json().catch(() => ({}));
+    throw new Error(errorData.message || "Failed to fetch invitations");
+  }
+  return await res.json();
+}
+async function acceptInvitation(sessionId, invitationId) {
+  const token = getToken(sessionId);
+  if (!token) throw new Error("Not authenticated");
+  const res = await fetch(`https://api.github.com/user/repository_invitations/${invitationId}`, {
+    method: "PATCH",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "gitelectron-App"
+    }
+  });
+  if (!res.ok) {
+    const errorData = await res.json().catch(() => ({}));
+    throw new Error(errorData.message || "Failed to accept invitation");
+  }
+}
+async function declineInvitation(sessionId, invitationId) {
+  const token = getToken(sessionId);
+  if (!token) throw new Error("Not authenticated");
+  const res = await fetch(`https://api.github.com/user/repository_invitations/${invitationId}`, {
+    method: "DELETE",
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "gitelectron-App"
+    }
+  });
+  if (!res.ok) {
+    const errorData = await res.json().catch(() => ({}));
+    throw new Error(errorData.message || "Failed to decline invitation");
+  }
+}
+const gitSessions = /* @__PURE__ */ new Map();
+function initGit(sessionId, baseDir) {
+  const options = {
+    baseDir,
+    binary: "git",
+    maxConcurrentProcesses: 6
+  };
+  const git = simpleGit.simpleGit(options);
+  gitSessions.set(sessionId, { git, repoPath: baseDir });
+}
+function cleanupGitSession(sessionId) {
+  gitSessions.delete(sessionId);
+}
+function getGitSession(sessionId) {
+  const session = gitSessions.get(sessionId);
+  if (!session) throw new Error("Git not initialized for this window");
+  return session;
+}
+async function isGitRepo(dir) {
+  try {
+    const tempGit = simpleGit.simpleGit(dir);
+    return await tempGit.checkIsRepo();
+  } catch {
+    return false;
+  }
+}
+async function initializeRepo(sessionId, dir) {
+  try {
+    const tempGit = simpleGit.simpleGit(dir);
+    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"
+      ]);
+    }
+    initGit(sessionId, dir);
+    return true;
+  } catch (e) {
+    console.error("Failed to init repo", e);
+    return false;
+  }
+}
+async function getStatus(sessionId) {
+  const { git } = getGitSession(sessionId);
+  const status = await git.status();
+  return JSON.parse(JSON.stringify(status));
+}
+async function stageFiles(sessionId, files) {
+  const { git, repoPath } = getGitSession(sessionId);
+  const fileArray = Array.isArray(files) ? files : [files];
+  if (repoPath) {
+    const LARGE_FILE_LIMIT = 50 * 1024 * 1024;
+    const largeFiles = [];
+    for (const file of fileArray) {
+      try {
+        const fullPath = path__namespace.join(repoPath, file);
+        const stats = await fs__namespace.stat(fullPath);
+        if (stats.isFile() && stats.size > LARGE_FILE_LIMIT) {
+          largeFiles.push(file);
+        }
+      } catch (e) {
+      }
+    }
+    if (largeFiles.length > 0) {
+      try {
+        await git.raw(["lfs", "install"]);
+        for (const file of largeFiles) {
+          await git.raw(["lfs", "track", file]);
+        }
+        if (!fileArray.includes(".gitattributes")) {
+          fileArray.push(".gitattributes");
+        }
+      } catch (e) {
+        console.warn("Git LFS not available or failed to track large files:", e);
+      }
+    }
+  }
+  const chunkSize = 50;
+  for (let i = 0; i < fileArray.length; i += chunkSize) {
+    const chunk = fileArray.slice(i, i + chunkSize);
+    await git.add(chunk);
+  }
+  return true;
+}
+async function unstageFiles(sessionId, files) {
+  const { git } = getGitSession(sessionId);
+  const fileArray = Array.isArray(files) ? files : [files];
+  const chunkSize = 50;
+  for (let i = 0; i < fileArray.length; i += chunkSize) {
+    const chunk = fileArray.slice(i, i + chunkSize);
+    await git.reset(["--", ...chunk]);
+  }
+  return true;
+}
+async function commitChanges(sessionId, message) {
+  const { git } = getGitSession(sessionId);
+  return await git.commit(message);
+}
+function injectAuthToken(sessionId, remoteUrl) {
+  const token = getToken(sessionId);
+  if (!token) return remoteUrl;
+  if (remoteUrl.includes("github.com")) {
+    let cleanUrl = remoteUrl.replace("git@github.com:", "https://github.com/");
+    if (cleanUrl.startsWith("https://github.com/")) {
+      return cleanUrl.replace("https://github.com/", `https://x-access-token:${token}@github.com/`);
+    }
+  }
+  return remoteUrl;
+}
+async function pushToRemote(sessionId, remote, branch) {
+  const { git } = getGitSession(sessionId);
+  const remotes = await getRemotes(sessionId);
+  const remoteObj = remotes.find((r) => r.name === remote);
+  const tempGit = git.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, branch]);
+    }
+    return await tempGit.raw(["-c", "credential.helper=", "push", remote, branch]);
+  } catch (err) {
+    const status = await git.status();
+    if (status.ahead === 0) {
+      console.warn("Git push threw an error but status is ahead 0. Push actually succeeded!", err);
+      return { success: true, warning: err.message };
+    }
+    throw err;
+  }
+}
+async function pullFromRemote(sessionId, remote, branch) {
+  const { git } = getGitSession(sessionId);
+  const remotes = await getRemotes(sessionId);
+  const remoteObj = remotes.find((r) => r.name === remote);
+  const options = { "--allow-unrelated-histories": null };
+  if (remoteObj && remoteObj.refs.fetch) {
+    const authUrl = injectAuthToken(sessionId, remoteObj.refs.fetch);
+    return await git.pull(authUrl, branch, options);
+  }
+  return await git.pull(remote, branch, options);
+}
+async function resetToRemote(sessionId, remote, branch) {
+  const { git } = getGitSession(sessionId);
+  const remotes = await getRemotes(sessionId);
+  const remoteObj = remotes.find((r) => r.name === remote);
+  if (remoteObj && remoteObj.refs.fetch) {
+    const authUrl = injectAuthToken(sessionId, remoteObj.refs.fetch);
+    await git.fetch(authUrl, branch);
+    return await git.reset(["--hard", "FETCH_HEAD"]);
+  } else {
+    await git.fetch(remote, branch);
+    return await git.reset(["--hard", `${remote}/${branch}`]);
+  }
+}
+async function fetchRemote(sessionId) {
+  const { git } = getGitSession(sessionId);
+  return await git.fetch();
+}
+async function getBranches(sessionId) {
+  const { git } = getGitSession(sessionId);
+  try {
+    const remotes = await git.getRemotes(true);
+    if (remotes.length > 0) {
+      const remoteObj = remotes[0];
+      const tempGit = simpleGit.simpleGit(getGitSession(sessionId).repoPath).env({
+        GCM_INTERACTIVE: "false",
+        GIT_TERMINAL_PROMPT: "0",
+        GIT_ASKPASS: "echo"
+      });
+      if (remoteObj.refs.fetch) {
+        const authUrl = injectAuthToken(sessionId, remoteObj.refs.fetch);
+        await tempGit.fetch(authUrl, { "--prune": null });
+      } else {
+        await tempGit.fetch(remoteObj.name, { "--prune": null });
+      }
+    }
+  } catch (e) {
+  }
+  let branches = await git.branch(["-a"]);
+  if (branches.all.length === 0) {
+    try {
+      await git.raw([
+        "-c",
+        "user.name=gitelectron",
+        "-c",
+        "user.email=noreply@gitelectron.local",
+        "commit",
+        "--allow-empty",
+        "-m",
+        "Initial repository setup"
+      ]);
+      branches = await git.branch(["-a"]);
+    } catch (e) {
+      console.error("Failed to create initial empty commit on getBranches", e);
+    }
+  }
+  const allBranches = /* @__PURE__ */ new Set();
+  branches.all.forEach((b) => {
+    if (b.startsWith("remotes/")) {
+      const parts = b.split("/");
+      if (parts.length > 2) {
+        allBranches.add(parts.slice(2).join("/"));
+      }
+    } else {
+      allBranches.add(b);
+    }
+  });
+  branches.all = Array.from(allBranches);
+  return JSON.parse(JSON.stringify(branches));
+}
+async function checkoutBranch(sessionId, branch) {
+  const { git } = getGitSession(sessionId);
+  return await git.checkout(branch);
+}
+async function createBranch(sessionId, branch, baseBranch) {
+  const { git } = getGitSession(sessionId);
+  let res;
+  if (baseBranch) {
+    res = await git.checkoutBranch(branch, baseBranch);
+  } else {
+    res = await git.checkoutLocalBranch(branch);
+  }
+  try {
+    const remotes = await git.getRemotes(true);
+    if (remotes && remotes.length > 0) {
+      const remoteName = remotes[0].name;
+      await git.addConfig(`branch.${branch}.remote`, remoteName);
+      await git.addConfig(`branch.${branch}.merge`, `refs/heads/${branch}`);
+      const remoteObj = remotes[0];
+      if (remoteObj && remoteObj.refs.push) {
+        const authUrl = injectAuthToken(sessionId, remoteObj.refs.push);
+        await git.push(authUrl, branch);
+      } else {
+        await git.push(remoteName, branch);
+      }
+    }
+  } catch (e) {
+    console.error("Failed to push and track new branch", e);
+  }
+  return res;
+}
+async function addRemote(sessionId, name, url) {
+  const { git } = getGitSession(sessionId);
+  return await git.addRemote(name, url);
+}
+async function pushAllBranches(sessionId, remote) {
+  const { git } = getGitSession(sessionId);
+  const remotes = await getRemotes(sessionId);
+  const remoteObj = remotes.find((r) => r.name === remote);
+  const tempGit = git.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) {
+    const status = await git.status();
+    if (status.ahead === 0) {
+      console.warn("Git push --all threw an error but current branch is pushed.", err);
+      return { success: true, warning: err.message };
+    }
+    throw err;
+  }
+}
+async function getCommitHistory(sessionId) {
+  const { git } = getGitSession(sessionId);
+  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) {
+    return { all: [] };
+  }
+}
+async function getRemotes(sessionId) {
+  const { git } = getGitSession(sessionId);
+  const remotes = await git.getRemotes(true);
+  return JSON.parse(JSON.stringify(remotes));
+}
+async function getFileDiff(sessionId, file, staged = false) {
+  const { git } = getGitSession(sessionId);
+  const args = staged ? ["diff", "--cached", "--", file] : ["diff", "--", file];
+  return await git.raw(args);
+}
+async function getGitConfig(sessionId, key, global = false) {
+  const { git } = getGitSession(sessionId);
+  try {
+    const args = ["config"];
+    if (global) args.push("--global");
+    args.push("--get", key);
+    const value = await git.raw(args);
+    return value.trim();
+  } catch {
+    return "";
+  }
+}
+async function setGitConfig(sessionId, key, value, global = false) {
+  const { git } = getGitSession(sessionId);
+  const args = ["config"];
+  if (global) args.push("--global");
+  args.push(key, value);
+  await git.raw(args);
+}
+async function readFile(sessionId, file) {
+  const { repoPath } = getGitSession(sessionId);
+  const fullPath = path__namespace.join(repoPath, file);
+  return await fs__namespace.readFile(fullPath, "utf8");
+}
+async function writeFile(sessionId, file, content) {
+  const { repoPath } = getGitSession(sessionId);
+  const fullPath = path__namespace.join(repoPath, file);
+  await fs__namespace.writeFile(fullPath, content, "utf8");
+}
+async function compareExternalFile(sessionId, sourcePath, repoRelativePath) {
+  const { repoPath } = getGitSession(sessionId);
+  const fullRepoPath = path__namespace.join(repoPath, repoRelativePath);
+  const sourceContent = await fs__namespace.readFile(sourcePath, "utf8");
+  let repoContent = null;
+  try {
+    repoContent = await fs__namespace.readFile(fullRepoPath, "utf8");
+  } catch {
+  }
+  return { sourceContent, repoContent };
+}
+async function copyExternalFiles(sessionId, files, destinationDir) {
+  const { repoPath } = getGitSession(sessionId);
+  const destDirFull = path__namespace.join(repoPath, destinationDir);
+  try {
+    await fs__namespace.mkdir(destDirFull, { recursive: true });
+  } catch (e) {
+    console.error("Failed to create destination dir", e);
+  }
+  const copiedFiles = [];
+  for (const file of files) {
+    const filename = path__namespace.basename(file);
+    const destFileFull = path__namespace.join(destDirFull, filename);
+    await fs__namespace.copyFile(file, destFileFull);
+    copiedFiles.push(path__namespace.join(destinationDir, filename).replace(/\\/g, "/"));
+  }
+  return copiedFiles;
+}
+async function setupUniversalWorkspace(sessionId, remoteUrl, branch, baseBranch, destinationPath) {
+  const token = getToken(sessionId);
+  if (!token) throw new Error("Not authenticated");
+  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(workspacePath);
+  await git.init();
+  let authUrl = remoteUrl;
+  if (remoteUrl.includes("github.com")) {
+    let cleanUrl = remoteUrl.replace("git@github.com:", "https://github.com/");
+    if (cleanUrl.startsWith("https://github.com/")) {
+      authUrl = cleanUrl.replace(
+        "https://github.com/",
+        `https://x-access-token:${token}@github.com/`
+      );
+    }
+  }
+  await git.addRemote("origin", authUrl);
+  const activeAccount = getActiveAccount(sessionId);
+  if (activeAccount) {
+    const email = `${activeAccount.id}+${activeAccount.username}@users.noreply.github.com`;
+    await git.addConfig("user.name", activeAccount.username);
+    await git.addConfig("user.email", email);
+  } else {
+    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]);
+  const branchToFetch = baseBranch || branch;
+  try {
+    await git.fetch(["--depth", "1", "origin", branchToFetch]);
+    await git.raw(["checkout", "-b", branchToFetch, `origin/${branchToFetch}`]);
+    if (baseBranch && branch !== baseBranch) {
+      await git.checkoutLocalBranch(branch);
+    }
+  } catch (e) {
+    if (baseBranch) {
+      throw new Error(`Failed to fetch or checkout branch ${branchToFetch}: ` + e.message);
+    } else {
+      await git.checkout(["--orphan", branch]);
+    }
+  }
+  return workspacePath;
+}
+async function checkUniversalCollisions(workspacePath, sourceFiles, destinationPath) {
+  const destDirFull = path__namespace.join(workspacePath, destinationPath === "/" ? "" : destinationPath);
+  await fs__namespace.mkdir(destDirFull, { recursive: true });
+  for (const source of sourceFiles) {
+    const stats = await fs__namespace.stat(source);
+    if (stats.isDirectory()) {
+      await fs__namespace.cp(source, path__namespace.join(destDirFull, path__namespace.basename(source)), { recursive: true });
+    } else {
+      await fs__namespace.copyFile(source, path__namespace.join(destDirFull, path__namespace.basename(source)));
+    }
+  }
+  const git = simpleGit.simpleGit(workspacePath);
+  const status = await git.status();
+  return {
+    modified: status.modified,
+    newFiles: [...status.not_added, ...status.created]
+  };
+}
+async function getUniversalDiff(workspacePath, filePath) {
+  const git = simpleGit.simpleGit(workspacePath);
+  try {
+    const diff = await git.raw(["diff", "--", filePath]);
+    return diff;
+  } catch (e) {
+    return "";
+  }
+}
+async function commitUniversalWorkspace(workspacePath, message, branch) {
+  const git = simpleGit.simpleGit(workspacePath).env({
+    ...process.env,
+    GCM_INTERACTIVE: "false",
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_ASKPASS: "echo"
+  });
+  await git.add(["--sparse", "."]);
+  await git.commit(message);
+  try {
+    await git.raw(["-c", "credential.helper=", "push", "origin", branch]);
+  } catch (err) {
+    const status = await git.status();
+    if (status.ahead === 0) {
+      console.warn("Universal Git push threw an error but branch is pushed.", err);
+      return;
+    }
+    throw err;
+  }
+}
+async function cleanupUniversalWorkspace(workspacePath) {
+  try {
+    await fs__namespace.rm(workspacePath, { recursive: true, force: true });
+  } catch (e) {
+    console.error("Failed to cleanup universal workspace", e);
+  }
+}
+async function executeRawCommand(sessionId, args) {
+  const { git } = getGitSession(sessionId);
+  return await git.raw(args);
+}
+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.
+
+Your job is to:
+1. Provide a short internal status message in 'explanation' (e.g. "Aborting chaotic merge and pulling with strategy ours...").
+2. Provide the EXACT terminal git commands required to automatically resolve this issue.
+3. You must use standard git commands to force the issue to resolve so the user can successfully push.
+   - If there is a merge conflict, resolve it aggressively (e.g., 'git merge --abort', 'git config pull.rebase false', 'git pull --no-edit -X ours', 'git add .', 'git commit -m "Auto-resolve conflict"').
+   - If a push is rejected due to a diverged branch, pull the changes, merge them, and commit.
+   - DO NOT use interactive commands (like 'git rebase -i' or 'nano' or 'vim').
+   - DO NOT suggest editing files manually. You must use terminal commands to manipulate the git state directly.
+Return the response strictly as a JSON object with this shape, and absolutely no markdown formatting outside of the JSON:
+{
+  "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";
+    }
+  }
+  const keys = apiKeyInput.split(",").map((k) => k.trim()).filter((k) => k);
+  const prompt = `
+GIT STATUS:
+${JSON.stringify(gitStatus, null, 2)}
+
+REPOSITORY PATH:
+${repoPath}
+
+RAW ERROR MESSAGE:
+${errorMsg}
+  `;
+  let lastError = null;
+  if (githubToken) {
+    try {
+      const openai = new OpenAI({
+        apiKey: githubToken,
+        baseURL: "https://models.inference.ai.azure.com"
+      });
+      const response = await openai.chat.completions.create({
+        model: "gpt-4o-mini",
+        messages: [
+          { role: "system", content: SYSTEM_PROMPT },
+          { role: "user", content: prompt }
+        ],
+        response_format: { type: "json_object" }
+      });
+      let responseText = response.choices[0].message.content || "{}";
+      responseText = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
+      const parsed = JSON.parse(responseText);
+      if (parsed.explanation && Array.isArray(parsed.commandsToRun)) {
+        console.log("[AI Service] Successfully used GitHub Copilot Models API!");
+        return parsed;
+      }
+    } catch (e) {
+      console.warn(`[AI Service] GitHub Copilot Models fallback failed: ${e.message}`);
+      lastError = e;
+    }
+  }
+  for (const apiKey of keys) {
+    let responseText = "";
+    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();
+      } else if (provider === "deepseek") {
+        const openai = new OpenAI({
+          apiKey,
+          baseURL: "https://router.huggingface.co/v1"
+        });
+        const response = await openai.chat.completions.create({
+          model: "deepseek-ai/DeepSeek-V4-Flash:novita",
+          messages: [
+            { role: "system", content: SYSTEM_PROMPT },
+            { role: "user", content: prompt }
+          ],
+          response_format: { type: "json_object" }
+        });
+        responseText = response.choices[0].message.content || "{}";
+      } else {
+        throw new Error(`Unsupported AI Provider: ${provider}`);
+      }
+      responseText = responseText.replace(/```json/g, "").replace(/```/g, "").trim();
+      const parsed = JSON.parse(responseText);
+      if (!parsed.explanation || !Array.isArray(parsed.commandsToRun)) {
+        throw new Error("AI returned an invalid response format.");
+      }
+      return parsed;
+    } catch (e) {
+      console.warn(
+        `[AI Service] Provider ${provider} failed with key ${apiKey.substring(0, 5)}...: ${e.message}. Trying next if available.`
+      );
+      lastError = e;
+    }
+  }
+  throw new Error(
+    `AI Analysis failed after trying all provided keys. Last error: ${lastError?.message}`
+  );
+}
+let currentWatcher = null;
+let syncTimeout = null;
+let isAutoSyncEnabled = false;
+const DEBOUNCE_MS = 3e3;
+const changedFiles = /* @__PURE__ */ new Set();
+function toggleAutoSync(sessionId, repoPath, enabled, onLog) {
+  isAutoSyncEnabled = enabled;
+  if (currentWatcher) {
+    currentWatcher.close();
+    currentWatcher = null;
+  }
+  if (syncTimeout) {
+    clearTimeout(syncTimeout);
+  }
+  changedFiles.clear();
+  if (!enabled) {
+    onLog("Auto-Sync disabled.");
+    return;
+  }
+  onLog("⚡ Auto-Sync enabled. Watching for changes...");
+  currentWatcher = chokidar.watch(repoPath, {
+    ignored: [
+      /(^|[\/\\])\../,
+      // ignore dotfiles (.git, .DS_Store)
+      /node_modules/,
+      /dist/,
+      /build/
+    ],
+    persistent: true,
+    ignoreInitial: true
+  });
+  currentWatcher.on("all", (_event, filePath) => {
+    if (!isAutoSyncEnabled) return;
+    const relativePath = path__namespace.relative(repoPath, filePath).replace(/\\/g, "/");
+    changedFiles.add(relativePath);
+    if (syncTimeout) {
+      clearTimeout(syncTimeout);
+    }
+    onLog(`Detected change in ${relativePath}. Waiting for 3 seconds...`);
+    syncTimeout = setTimeout(() => {
+      triggerSyncSequence(sessionId, repoPath, onLog);
+    }, DEBOUNCE_MS);
+  });
+}
+async function triggerSyncSequence(sessionId, _repoPath, onLog) {
+  if (changedFiles.size === 0) return;
+  const filesToSync = Array.from(changedFiles);
+  changedFiles.clear();
+  try {
+    onLog(`Staging ${filesToSync.length} file(s)...`);
+    await stageFiles(sessionId, filesToSync);
+    const status = await getStatus(sessionId);
+    const branch = status.current || "main";
+    const commitMsg = `Auto-sync: update ${filesToSync.length > 1 ? filesToSync.length + " files" : filesToSync[0]}`;
+    onLog(`Committing: "${commitMsg}"...`);
+    await commitChanges(sessionId, commitMsg);
+    onLog(`Pushing to ${branch}...`);
+    await pushToRemote(sessionId, "origin", branch);
+    onLog(`✅ Successfully pushed auto-sync commit!`);
+  } catch (error) {
+    onLog(`❌ Auto-sync failed: ${error.message}`);
+  }
+}
+const icon = path.join(__dirname, "../../resources/icon.png");
+function createWindow() {
+  const mainWindow = new electron.BrowserWindow({
+    width: 1100,
+    height: 800,
+    minWidth: 850,
+    minHeight: 600,
+    show: false,
+    autoHideMenuBar: true,
+    title: "GIT ELECTRON",
+    ...process.platform === "linux" ? { icon } : {},
+    webPreferences: {
+      preload: path.join(__dirname, "../preload/index.js"),
+      sandbox: false
+    }
+  });
+  const sessionId = mainWindow.webContents.id;
+  initSession(sessionId);
+  mainWindow.on("ready-to-show", () => {
+    mainWindow.show();
+  });
+  mainWindow.on("closed", () => {
+    cleanupSession(sessionId);
+    cleanupGitSession(sessionId);
+  });
+  mainWindow.webContents.setWindowOpenHandler((details) => {
+    electron.shell.openExternal(details.url);
+    return { action: "deny" };
+  });
+  if (utils.is.dev && process.env["ELECTRON_RENDERER_URL"]) {
+    mainWindow.loadURL(process.env["ELECTRON_RENDERER_URL"]);
+  } else {
+    mainWindow.loadFile(path.join(__dirname, "../renderer/index.html"));
+  }
+}
+const gotTheLock = electron.app.requestSingleInstanceLock();
+if (!gotTheLock) {
+  electron.app.quit();
+  process.exit(0);
+}
+let initialRepo = null;
+const cwdIndex = process.argv.indexOf("--cwd");
+if (cwdIndex !== -1 && process.argv.length > cwdIndex + 1) {
+  initialRepo = process.argv[cwdIndex + 1];
+}
+electron.app.on("second-instance", (_event, commandLine, workingDirectory) => {
+  const windows = electron.BrowserWindow.getAllWindows();
+  if (windows.length > 0) {
+    if (windows[0].isMinimized()) windows[0].restore();
+    windows[0].focus();
+    const idx = commandLine.indexOf("--cwd");
+    let repoPath = null;
+    if (idx !== -1 && commandLine.length > idx + 1) {
+      repoPath = commandLine[idx + 1];
+    } else if (workingDirectory) {
+      repoPath = workingDirectory;
+    }
+    if (repoPath) {
+      windows[0].webContents.send("set-cli-repo", repoPath);
+    }
+  }
+});
+if (process.defaultApp) {
+  if (process.argv.length >= 2) {
+    electron.app.setAsDefaultProtocolClient("gitelectron", process.execPath, [
+      require("path").resolve(process.argv[1])
+    ]);
+  }
+} else {
+  electron.app.setAsDefaultProtocolClient("gitelectron");
+}
+electron.app.whenReady().then(async () => {
+  utils.electronApp.setAppUserModelId("com.electron");
+  await loadAccounts();
+  electron.app.on("browser-window-created", (_, window) => {
+    utils.optimizer.watchWindowShortcuts(window);
+  });
+  electron.ipcMain.on("ping", () => console.log("pong"));
+  electron.ipcMain.handle("new-window", () => {
+    createWindow();
+  });
+  electron.ipcMain.handle("get-accounts", async (event) => {
+    return await getAccounts(event.sender.id);
+  });
+  electron.ipcMain.handle("switch-account", async (event, accountId) => {
+    return await switchAccount(event.sender.id, accountId);
+  });
+  electron.ipcMain.handle("remove-account", async (_, accountId) => {
+    return await removeAccount(accountId);
+  });
+  electron.ipcMain.handle("get-cli-repo", () => {
+    return initialRepo;
+  });
+  electron.ipcMain.handle("select-directory", async (event) => {
+    const sessionId = event.sender.id;
+    const result = await electron.dialog.showOpenDialog({
+      properties: ["openDirectory"]
+    });
+    if (result.canceled || result.filePaths.length === 0) {
+      return null;
+    }
+    const path2 = result.filePaths[0];
+    const isRepo = await isGitRepo(path2);
+    if (isRepo) {
+      initGit(sessionId, path2);
+    }
+    return { path: path2, isRepo };
+  });
+  electron.ipcMain.handle("set-repo-path", async (event, path2) => {
+    const sessionId = event.sender.id;
+    const isRepo = await isGitRepo(path2);
+    if (isRepo) {
+      initGit(sessionId, path2);
+    }
+    return { path: path2, isRepo };
+  });
+  electron.ipcMain.handle("init-repo", async (event, path2) => {
+    return await initializeRepo(event.sender.id, path2);
+  });
+  electron.ipcMain.handle("get-status", async (event) => {
+    return await getStatus(event.sender.id);
+  });
+  electron.ipcMain.handle("stage-files", async (event, files) => {
+    return await stageFiles(event.sender.id, files);
+  });
+  electron.ipcMain.handle("unstage-files", async (event, files) => {
+    return await unstageFiles(event.sender.id, files);
+  });
+  electron.ipcMain.handle("commit-changes", async (event, message) => {
+    return await commitChanges(event.sender.id, message);
+  });
+  electron.ipcMain.handle("push-to-remote", async (event, remote, branch) => {
+    return await pushToRemote(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("reset-to-remote", async (event, remote, branch) => {
+    return await resetToRemote(event.sender.id, remote, branch);
+  });
+  electron.ipcMain.handle("fetch-remote", async (event) => {
+    return await fetchRemote(event.sender.id);
+  });
+  electron.ipcMain.handle("get-branches", async (event) => {
+    return await getBranches(event.sender.id);
+  });
+  electron.ipcMain.handle("checkout-branch", async (event, branch) => {
+    return await checkoutBranch(event.sender.id, branch);
+  });
+  electron.ipcMain.handle("create-branch", async (event, branch, baseBranch) => {
+    return await createBranch(event.sender.id, branch, baseBranch);
+  });
+  electron.ipcMain.handle("get-commit-history", async (event) => {
+    return await getCommitHistory(event.sender.id);
+  });
+  electron.ipcMain.handle("get-deleted-history", async (event) => {
+    return await getDeletedHistory(event.sender.id);
+  });
+  electron.ipcMain.handle("get-auth-status", async (event) => {
+    return await getAuthStatus(event.sender.id);
+  });
+  electron.ipcMain.handle("start-device-flow", async (event) => {
+    const data = await startDeviceFlow(event.sender.id);
+    electron.shell.openExternal(data.verification_uri_complete);
+    return data;
+  });
+  electron.ipcMain.handle("poll-device-flow", async (event, deviceCode, interval) => {
+    return await pollDeviceFlow(event.sender.id, deviceCode, interval);
+  });
+  electron.ipcMain.handle("logout-github", async (event) => {
+    return await logout(event.sender.id);
+  });
+  electron.ipcMain.handle("verify-push-permission", async (event, remoteUrl) => {
+    return await verifyRepositoryPermission(event.sender.id, remoteUrl);
+  });
+  electron.ipcMain.handle("get-remotes", async (event) => {
+    return await getRemotes(event.sender.id);
+  });
+  electron.ipcMain.handle("get-file-diff", async (event, file, staged) => {
+    return await getFileDiff(event.sender.id, file, staged);
+  });
+  electron.ipcMain.handle("get-git-config", async (event, key, global) => {
+    return await getGitConfig(event.sender.id, key, global);
+  });
+  electron.ipcMain.handle("set-git-config", async (event, key, value, global) => {
+    return await setGitConfig(event.sender.id, key, value, global);
+  });
+  electron.ipcMain.handle("read-file", async (event, file) => {
+    return await readFile(event.sender.id, file);
+  });
+  electron.ipcMain.handle("write-file", async (event, file, content) => {
+    return await writeFile(event.sender.id, file, content);
+  });
+  electron.ipcMain.handle("get-user-repositories", async (event) => {
+    return await getUserRepositories(event.sender.id);
+  });
+  electron.ipcMain.handle(
+    "create-github-repository",
+    async (event, name, description, isPrivate, autoInit, gitignoreTemplate, licenseTemplate) => {
+      return await createGitHubRepository(
+        event.sender.id,
+        name,
+        description,
+        isPrivate,
+        autoInit,
+        gitignoreTemplate,
+        licenseTemplate
+      );
+    }
+  );
+  electron.ipcMain.handle("add-remote", async (event, name, url) => {
+    return await addRemote(event.sender.id, name, url);
+  });
+  electron.ipcMain.handle("push-all-branches", async (event, remote) => {
+    return await pushAllBranches(event.sender.id, remote);
+  });
+  electron.ipcMain.handle("open-external", async (_, url) => {
+    await electron.shell.openExternal(url);
+  });
+  electron.ipcMain.handle(
+    "compare-external-file",
+    async (event, sourcePath, repoRelativePath) => {
+      return await compareExternalFile(event.sender.id, sourcePath, repoRelativePath);
+    }
+  );
+  electron.ipcMain.handle("copy-external-files", async (event, files, destinationDir) => {
+    return await copyExternalFiles(event.sender.id, files, destinationDir);
+  });
+  electron.ipcMain.handle("get-collaborators", async (event, remoteUrl) => {
+    return await getCollaborators(event.sender.id, remoteUrl);
+  });
+  electron.ipcMain.handle("add-collaborator", async (event, remoteUrl, username) => {
+    return await addCollaborator(event.sender.id, remoteUrl, username);
+  });
+  electron.ipcMain.handle(
+    "remove-collaborator",
+    async (event, remoteUrl, usernameOrId, isInvitation) => {
+      return await removeCollaborator(
+        event.sender.id,
+        remoteUrl,
+        usernameOrId,
+        isInvitation
+      );
+    }
+  );
+  electron.ipcMain.handle("search-github-user", async (event, username) => {
+    return await searchGitHubUser(event.sender.id, username);
+  });
+  electron.ipcMain.handle("get-user-invitations", async (event) => {
+    return await getUserInvitations(event.sender.id);
+  });
+  electron.ipcMain.handle("accept-invitation", async (event, invitationId) => {
+    return await acceptInvitation(event.sender.id, invitationId);
+  });
+  electron.ipcMain.handle("decline-invitation", async (event, invitationId) => {
+    return await declineInvitation(event.sender.id, invitationId);
+  });
+  electron.ipcMain.handle("select-universal-files", async (_event, isDirectory) => {
+    const properties = isDirectory ? ["openDirectory", "multiSelections"] : ["openFile", "multiSelections"];
+    const result = await electron.dialog.showOpenDialog({ properties });
+    return result.canceled ? null : result.filePaths;
+  });
+  electron.ipcMain.handle("get-repository-branches", async (event, owner, repo) => {
+    return await getRepositoryBranches(event.sender.id, owner, repo);
+  });
+  electron.ipcMain.handle(
+    "setup-universal-workspace",
+    async (event, remoteUrl, branch, baseBranch, dest) => {
+      return await setupUniversalWorkspace(
+        event.sender.id,
+        remoteUrl,
+        branch,
+        baseBranch,
+        dest
+      );
+    }
+  );
+  electron.ipcMain.handle(
+    "check-universal-collisions",
+    async (_event, workspacePath, sourceFiles, dest) => {
+      return await checkUniversalCollisions(workspacePath, sourceFiles, dest);
+    }
+  );
+  electron.ipcMain.handle("get-universal-diff", async (_event, workspacePath, file) => {
+    return await getUniversalDiff(workspacePath, file);
+  });
+  electron.ipcMain.handle(
+    "commit-universal-workspace",
+    async (_event, workspacePath, msg, branch) => {
+      return await commitUniversalWorkspace(workspacePath, msg, branch);
+    }
+  );
+  electron.ipcMain.handle("cleanup-universal-workspace", async (_event, workspacePath) => {
+    return await cleanupUniversalWorkspace(workspacePath);
+  });
+  electron.ipcMain.handle(
+    "ask-ai",
+    async (event, provider, apiKey, errorMsg, gitStatus, repoPath) => {
+      const githubToken = getToken(event.sender.id) || void 0;
+      return await analyzeGitError(
+        provider,
+        apiKey,
+        errorMsg,
+        gitStatus,
+        repoPath,
+        githubToken
+      );
+    }
+  );
+  electron.ipcMain.handle("execute-raw-git", async (event, args) => {
+    return await executeRawCommand(event.sender.id, args);
+  });
+  electron.ipcMain.on("toggle-auto-sync", (event, repoPath, enabled) => {
+    toggleAutoSync(event.sender.id, repoPath, enabled, (msg) => {
+      event.sender.send("auto-sync-log", msg);
+    });
+  });
+  electron.ipcMain.handle("get-app-version", () => {
+    return electron.app.getVersion();
+  });
+  electron.ipcMain.handle("check-updates", async () => {
+    try {
+      const https = require("https");
+      return new Promise((resolve) => {
+        https.get("https://registry.npmjs.org/gitelectron/latest", (res) => {
+          let data = "";
+          res.on("data", (chunk) => {
+            data += chunk;
+          });
+          res.on("end", () => {
+            try {
+              const json = JSON.parse(data);
+              resolve(json.version || null);
+            } catch (e) {
+              resolve(null);
+            }
+          });
+        }).on("error", () => resolve(null));
+      });
+    } catch (e) {
+      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();
+      resolve(true);
+      setTimeout(() => {
+        electron.app.exit(0);
+      }, 500);
+    });
+  });
+  createWindow();
+  electron.app.on("activate", function() {
+    if (electron.BrowserWindow.getAllWindows().length === 0) createWindow();
+  });
+});
+electron.app.on("window-all-closed", () => {
+  if (process.platform !== "darwin") {
+    electron.app.quit();
+  }
+});