gitxelectron 1.1.6 → 1.1.8

package/out/main/index.js

@@ -1,8 +1,8 @@
 "use strict";
 const electron = require("electron");
 const path = require("path");
-const simpleGit = require("simple-git");
 const fs = require("fs/promises");
+const simpleGit = require("simple-git");
 const crypto = require("crypto");
 const generativeAi = require("@google/generative-ai");
 const OpenAI = require("openai");
@@ -176,9 +176,37 @@ async function pollDeviceFlow(sessionId, deviceCode, intervalMs) {
             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);
+              let email = userData.email;
+              try {
+                const emailsRes = await fetch("https://api.github.com/user/emails", {
+                  headers: {
+                    Authorization: `Bearer ${data.access_token}`,
+                    Accept: "application/vnd.github.v3+json",
+                    "User-Agent": "gitelectron-App"
+                  }
+                });
+                if (emailsRes.ok) {
+                  const emails = await emailsRes.json();
+                  const primary = emails.find((e) => e.primary);
+                  if (primary) email = primary.email;
+                  if (!email) {
+                    const noreply = emails.find((e) => e.email.includes("noreply.github.com"));
+                    if (noreply) email = noreply.email;
+                  }
+                }
+              } catch (e) {
+              }
+              if (!email) {
+                email = `${userData.id}+${username}@users.noreply.github.com`;
+              }
+              await setGitConfig2(sessionId, "user.name", username, true).catch(() => {
+              });
+              await setGitConfig2(sessionId, "user.email", email, true).catch(() => {
+              });
+              await setGitConfig2(sessionId, "user.name", username).catch(() => {
+              });
+              await setGitConfig2(sessionId, "user.email", email).catch(() => {
+              });
             } catch (e) {
               console.error("Failed to configure git user", e);
             }
@@ -260,6 +288,68 @@ async function getUserRepositories(sessionId) {
   }
   return await res.json();
 }
+async function getCollaboratedRepos(sessionId) {
+  const token = getToken(sessionId);
+  if (!token) throw new Error("Not authenticated in this session");
+  const headers = {
+    Authorization: `Bearer ${token}`,
+    Accept: "application/vnd.github.v3+json",
+    "User-Agent": "gitelectron-App"
+  };
+  const res = await fetch(
+    "https://api.github.com/user/repos?affiliation=owner,collaborator,organization_member&per_page=100&sort=updated",
+    { headers }
+  );
+  if (!res.ok) {
+    const errorData = await res.json().catch(() => ({}));
+    throw new Error(errorData.message || "Failed to fetch collaborated repositories");
+  }
+  const allRepos = await res.json();
+  const account = getActiveAccount(sessionId);
+  const currentUsername = account?.username?.toLowerCase() || "";
+  const externalCollabRepos = [];
+  const ownedRepos = [];
+  for (const repo of allRepos) {
+    const ownerLogin = repo.owner?.login?.toLowerCase() || "";
+    if (ownerLogin !== currentUsername) {
+      externalCollabRepos.push(repo);
+    } else {
+      ownedRepos.push(repo);
+    }
+  }
+  const ownedCollabChecks = await Promise.allSettled(
+    ownedRepos.map(async (repo) => {
+      try {
+        const [collabRes, invRes] = await Promise.all([
+          fetch(`https://api.github.com/repos/${repo.owner.login}/${repo.name}/collaborators`, { headers }),
+          fetch(`https://api.github.com/repos/${repo.owner.login}/${repo.name}/invitations`, { headers })
+        ]);
+        const collabs = collabRes.ok ? await collabRes.json() : [];
+        const invs = invRes.ok ? await invRes.json() : [];
+        const hasOtherCollabs = Array.isArray(collabs) && collabs.some(
+          (c) => c.login && c.login.toLowerCase() !== currentUsername
+        );
+        const hasPendingInvs = Array.isArray(invs) && invs.length > 0;
+        if (hasOtherCollabs || hasPendingInvs) {
+          return {
+            ...repo,
+            collaboratorsList: collabs,
+            hasPendingInvitations: hasPendingInvs
+          };
+        }
+      } catch (err) {
+      }
+      return null;
+    })
+  );
+  const ownedCollabRepos = [];
+  for (const result of ownedCollabChecks) {
+    if (result.status === "fulfilled" && result.value) {
+      ownedCollabRepos.push(result.value);
+    }
+  }
+  return [...externalCollabRepos, ...ownedCollabRepos];
+}
 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");
@@ -301,9 +391,10 @@ async function getCollaborators(sessionId, remoteUrl) {
     Accept: "application/vnd.github.v3+json",
     "User-Agent": "gitelectron-App"
   };
-  const [collabRes, invRes] = await Promise.all([
+  const [collabRes, invRes, contribRes] = await Promise.all([
     fetch(`https://api.github.com/repos/${owner}/${repo}/collaborators`, { headers }),
-    fetch(`https://api.github.com/repos/${owner}/${repo}/invitations`, { headers })
+    fetch(`https://api.github.com/repos/${owner}/${repo}/invitations`, { headers }),
+    fetch(`https://api.github.com/repos/${owner}/${repo}/contributors`, { headers })
   ]);
   if (!collabRes.ok) {
     const errorData = await collabRes.json().catch(() => ({}));
@@ -313,7 +404,8 @@ async function getCollaborators(sessionId, remoteUrl) {
   }
   const collaborators = await collabRes.json();
   const invitations = invRes.ok ? await invRes.json() : [];
-  return { collaborators, invitations };
+  const contributors = contribRes.ok ? await contribRes.json() : [];
+  return { collaborators, invitations, contributors };
 }
 async function addCollaborator(sessionId, remoteUrl, username) {
   const token = getToken(sessionId);
@@ -360,7 +452,9 @@ async function removeCollaborator(sessionId, remoteUrl, usernameOrId, isInvitati
 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}`, {
+  const trimmed = username.trim();
+  if (!trimmed) return null;
+  const res = await fetch(`https://api.github.com/users/${encodeURIComponent(trimmed)}`, {
     headers: {
       Authorization: `Bearer ${token}`,
       Accept: "application/vnd.github.v3+json",
@@ -374,6 +468,36 @@ async function searchGitHubUser(sessionId, username) {
   }
   return await res.json();
 }
+async function searchGitHubUsers(sessionId, query) {
+  const token = getToken(sessionId);
+  if (!token) throw new Error("Not authenticated");
+  const trimmed = query.trim();
+  if (!trimmed) return [];
+  const searchPromise = fetch(
+    `https://api.github.com/search/users?q=${encodeURIComponent(trimmed)}+type:user&per_page=15`,
+    {
+      headers: {
+        Authorization: `Bearer ${token}`,
+        Accept: "application/vnd.github.v3+json",
+        "User-Agent": "gitelectron-App"
+      }
+    }
+  ).then((r) => r.ok ? r.json() : { items: [] }).catch(() => ({ items: [] }));
+  const exactPromise = /^[a-zA-Z0-9-]+$/.test(trimmed) ? fetch(`https://api.github.com/users/${encodeURIComponent(trimmed)}`, {
+    headers: {
+      Authorization: `Bearer ${token}`,
+      Accept: "application/vnd.github.v3+json",
+      "User-Agent": "gitelectron-App"
+    }
+  }).then((r) => r.ok ? r.json() : null).catch(() => null) : Promise.resolve(null);
+  const [searchData, exactUser] = await Promise.all([searchPromise, exactPromise]);
+  let items = searchData.items || [];
+  if (exactUser && exactUser.login) {
+    items = items.filter((u) => u.login.toLowerCase() !== exactUser.login.toLowerCase());
+    items.unshift(exactUser);
+  }
+  return items;
+}
 async function getRepositoryBranches(sessionId, owner, repo) {
   const token = getToken(sessionId);
   if (!token) throw new Error("Not authenticated");
@@ -463,6 +587,13 @@ function getGitSession(sessionId) {
   return session;
 }
 async function isGitRepo(dir) {
+  let hasGitFolder = false;
+  try {
+    await fs__namespace.access(path__namespace.join(dir, ".git"));
+    hasGitFolder = true;
+  } catch {
+    hasGitFolder = false;
+  }
   try {
     const tempGit = simpleGit.simpleGit(dir).env({
       ...process.env,
@@ -470,8 +601,28 @@ async function isGitRepo(dir) {
       GIT_TERMINAL_PROMPT: "0",
       GIT_ASKPASS: "echo"
     });
-    return await tempGit.checkIsRepo();
+    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();
+    }
+    return false;
   } catch {
+    if (hasGitFolder) {
+      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();
+      } catch {
+        return true;
+      }
+    }
     return false;
   }
 }
@@ -778,11 +929,20 @@ async function getGitConfig(sessionId, key, global = false) {
   }
 }
 async function setGitConfig(sessionId, key, value, global = false) {
-  const { git } = getGitSession(sessionId);
+  let gitInstance;
+  try {
+    gitInstance = getGitSession(sessionId).git;
+  } catch (e) {
+    if (global) {
+      gitInstance = simpleGit.simpleGit();
+    } else {
+      throw e;
+    }
+  }
   const args = ["config"];
   if (global) args.push("--global");
   args.push(key, value);
-  await git.raw(args);
+  await gitInstance.raw(args);
 }
 async function readFile(sessionId, file) {
   const { repoPath } = getGitSession(sessionId);
@@ -928,6 +1088,22 @@ async function executeRawCommand(sessionId, args) {
   const { git } = getGitSession(sessionId);
   return await git.raw(args);
 }
+async function cloneRepository(sessionId, remoteUrl, destPath) {
+  const authUrl = injectAuthToken(sessionId, remoteUrl);
+  await fs__namespace.mkdir(path__namespace.dirname(destPath), { recursive: true });
+  const git = simpleGit.simpleGit().env({
+    ...process.env,
+    GCM_INTERACTIVE: "false",
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_ASKPASS: "echo"
+  });
+  await git.clone(authUrl, destPath);
+  try {
+    await simpleGit.simpleGit().raw(["config", "--global", "--add", "safe.directory", destPath]);
+  } catch (e) {
+  }
+  return destPath;
+}
 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.
@@ -1097,7 +1273,7 @@ async function triggerSyncSequence(sessionId, _repoPath, onLog) {
   }
 }
 const icon = path.join(__dirname, "../../resources/icon.png");
-function createWindow() {
+function createWindow(initialPath) {
   const mainWindow = new electron.BrowserWindow({
     width: 1100,
     height: 800,
@@ -1130,6 +1306,11 @@ function createWindow() {
   } else {
     mainWindow.loadFile(path.join(__dirname, "../renderer/index.html"));
   }
+  mainWindow.webContents.on("did-finish-load", () => {
+    if (initialPath) {
+      mainWindow.webContents.send("set-cli-repo", initialPath);
+    }
+  });
 }
 const gotTheLock = electron.app.requestSingleInstanceLock();
 if (!gotTheLock) {
@@ -1174,8 +1355,8 @@ electron.app.whenReady().then(async () => {
     utils.optimizer.watchWindowShortcuts(window);
   });
   electron.ipcMain.on("ping", () => console.log("pong"));
-  electron.ipcMain.handle("new-window", () => {
-    createWindow();
+  electron.ipcMain.handle("new-window", (_, repoPath) => {
+    createWindow(repoPath);
   });
   electron.ipcMain.handle("get-accounts", async (event) => {
     return await getAccounts(event.sender.id);
@@ -1292,6 +1473,9 @@ electron.app.whenReady().then(async () => {
   electron.ipcMain.handle("get-user-repositories", async (event) => {
     return await getUserRepositories(event.sender.id);
   });
+  electron.ipcMain.handle("get-collaborated-repos", async (event) => {
+    return await getCollaboratedRepos(event.sender.id);
+  });
   electron.ipcMain.handle(
     "create-github-repository",
     async (event, name, description, isPrivate, autoInit, gitignoreTemplate, licenseTemplate) => {
@@ -1344,6 +1528,9 @@ electron.app.whenReady().then(async () => {
   electron.ipcMain.handle("search-github-user", async (event, username) => {
     return await searchGitHubUser(event.sender.id, username);
   });
+  electron.ipcMain.handle("search-github-users", async (event, query) => {
+    return await searchGitHubUsers(event.sender.id, query);
+  });
   electron.ipcMain.handle("get-user-invitations", async (event) => {
     return await getUserInvitations(event.sender.id);
   });
@@ -1408,6 +1595,37 @@ electron.app.whenReady().then(async () => {
   electron.ipcMain.handle("execute-raw-git", async (event, args) => {
     return await executeRawCommand(event.sender.id, args);
   });
+  electron.ipcMain.handle("clone-repository", async (event, remoteUrl, destPath) => {
+    return await cloneRepository(event.sender.id, remoteUrl, destPath);
+  });
+  electron.ipcMain.handle("check-path-exists", async (_event, targetPath) => {
+    if (!targetPath) return false;
+    try {
+      const stats = await fs__namespace.stat(targetPath);
+      return stats.isDirectory();
+    } catch {
+      return false;
+    }
+  });
+  electron.ipcMain.handle("upload-files-to-repo", async (event, repoPath) => {
+    const window = electron.BrowserWindow.fromWebContents(event.sender);
+    if (!repoPath) throw new Error("No repository path specified");
+    const result = await electron.dialog.showOpenDialog(window || void 0, {
+      title: "Select Files to Upload to Repository",
+      properties: ["openFile", "multiSelections"]
+    });
+    if (result.canceled || !result.filePaths.length) {
+      return { success: false, count: 0, files: [] };
+    }
+    const copiedFiles = [];
+    for (const filePath of result.filePaths) {
+      const fileName = path__namespace.basename(filePath);
+      const destPath = path__namespace.join(repoPath, fileName);
+      await fs__namespace.copyFile(filePath, destPath);
+      copiedFiles.push(fileName);
+    }
+    return { success: true, count: copiedFiles.length, files: copiedFiles };
+  });
   electron.ipcMain.on("toggle-auto-sync", (event, repoPath, enabled) => {
     toggleAutoSync(event.sender.id, repoPath, enabled, (msg) => {
       event.sender.send("auto-sync-log", msg);

package/out/preload/index.js

@@ -35,11 +35,12 @@ const api = {
   writeFile: (file, content) => electron.ipcRenderer.invoke("write-file", file, content),
   executeRawGit: (args) => electron.ipcRenderer.invoke("execute-raw-git", args),
   // NEW: Multi-Account & Window
-  newWindow: () => electron.ipcRenderer.invoke("new-window"),
+  newWindow: (repoPath) => electron.ipcRenderer.invoke("new-window", repoPath),
   getAccounts: () => electron.ipcRenderer.invoke("get-accounts"),
   switchAccount: (accountId) => electron.ipcRenderer.invoke("switch-account", accountId),
   removeAccount: (accountId) => electron.ipcRenderer.invoke("remove-account", accountId),
   getUserRepositories: () => electron.ipcRenderer.invoke("get-user-repositories"),
+  getCollaboratedRepos: () => electron.ipcRenderer.invoke("get-collaborated-repos"),
   createGitHubRepository: (name, description, isPrivate, autoInit = false, gitignoreTemplate = "", licenseTemplate = "") => electron.ipcRenderer.invoke(
     "create-github-repository",
     name,
@@ -58,6 +59,7 @@ const api = {
   addCollaborator: (remoteUrl, username) => electron.ipcRenderer.invoke("add-collaborator", remoteUrl, username),
   removeCollaborator: (remoteUrl, usernameOrId, isInvitation) => electron.ipcRenderer.invoke("remove-collaborator", remoteUrl, usernameOrId, isInvitation),
   searchGitHubUser: (username) => electron.ipcRenderer.invoke("search-github-user", username),
+  searchGitHubUsers: (query) => electron.ipcRenderer.invoke("search-github-users", query),
   getUserInvitations: () => electron.ipcRenderer.invoke("get-user-invitations"),
   acceptInvitation: (invitationId) => electron.ipcRenderer.invoke("accept-invitation", invitationId),
   declineInvitation: (invitationId) => electron.ipcRenderer.invoke("decline-invitation", invitationId),
@@ -67,6 +69,9 @@ const api = {
   setupUniversalWorkspace: (remoteUrl, branch, baseBranch, dest) => electron.ipcRenderer.invoke("setup-universal-workspace", remoteUrl, branch, baseBranch, dest),
   checkUniversalCollisions: (workspacePath, sourceFiles, dest) => electron.ipcRenderer.invoke("check-universal-collisions", workspacePath, sourceFiles, dest),
   getUniversalDiff: (workspacePath, file) => electron.ipcRenderer.invoke("get-universal-diff", workspacePath, file),
+  cloneRepository: (remoteUrl, destPath) => electron.ipcRenderer.invoke("clone-repository", remoteUrl, destPath),
+  checkPathExists: (targetPath) => electron.ipcRenderer.invoke("check-path-exists", targetPath),
+  uploadFilesToRepo: (repoPath) => electron.ipcRenderer.invoke("upload-files-to-repo", repoPath),
   commitUniversalWorkspace: (workspacePath, msg, branch) => electron.ipcRenderer.invoke("commit-universal-workspace", workspacePath, msg, branch),
   cleanupUniversalWorkspace: (workspacePath) => electron.ipcRenderer.invoke("cleanup-universal-workspace", workspacePath),
   toggleAutoSync: (repoPath, enabled) => electron.ipcRenderer.send("toggle-auto-sync", repoPath, enabled),