gitxelectron 1.1.7 → 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");
@@ -288,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");
@@ -390,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",
@@ -407,17 +471,32 @@ async function searchGitHubUser(sessionId, username) {
 async function searchGitHubUsers(sessionId, query) {
   const token = getToken(sessionId);
   if (!token) throw new Error("Not authenticated");
-  if (!query) return [];
-  const res = await fetch(`https://api.github.com/search/users?q=${encodeURIComponent(query)}&per_page=5`, {
+  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"
     }
-  });
-  if (!res.ok) throw new Error("Failed to search users");
-  const data = await res.json();
-  return data.items || [];
+  }).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);
@@ -1009,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.
@@ -1378,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) => {
@@ -1497,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

@@ -40,6 +40,7 @@ const api = {
   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,
@@ -68,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),