gitxelectron 1.1.7 → 1.1.9

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");
@@ -58,15 +58,23 @@ function cleanupSession(sessionId) {
   activeSessions.delete(sessionId);
 }
 function getToken(sessionId) {
-  const accountId = activeSessions.get(sessionId);
+  let accountId = activeSessions.get(sessionId);
+  if (!accountId && accounts.length > 0) {
+    accountId = accounts[0].id;
+    activeSessions.set(sessionId, accountId);
+  }
   if (!accountId) return null;
   const acc = accounts.find((a) => a.id === accountId);
-  return acc ? acc.token : null;
+  return acc ? acc.token : accounts.length > 0 ? accounts[0].token : null;
 }
 function getActiveAccount(sessionId) {
-  const accountId = activeSessions.get(sessionId);
+  let accountId = activeSessions.get(sessionId);
+  if (!accountId && accounts.length > 0) {
+    accountId = accounts[0].id;
+    activeSessions.set(sessionId, accountId);
+  }
   if (!accountId) return null;
-  return accounts.find((a) => a.id === accountId) || null;
+  return accounts.find((a) => a.id === accountId) || (accounts.length > 0 ? accounts[0] : null);
 }
 async function getAccounts(sessionId) {
   return {
@@ -288,6 +296,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 +460,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 +479,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);
@@ -499,6 +586,22 @@ function initGit(sessionId, baseDir) {
   });
   gitSessions.set(sessionId, { git, repoPath: baseDir });
 }
+function createSafeGit(baseDir) {
+  const options = {
+    binary: "git",
+    maxConcurrentProcesses: 6,
+    unsafe: { allowUnsafeEditor: true, allowUnsafeAskPass: true, allowUnsafeCredentialHelper: true }
+  };
+  if (baseDir) {
+    options.baseDir = baseDir;
+  }
+  return simpleGit.simpleGit(options).env({
+    ...process.env,
+    GCM_INTERACTIVE: "false",
+    GIT_TERMINAL_PROMPT: "0",
+    GIT_ASKPASS: "echo"
+  });
+}
 function cleanupGitSession(sessionId) {
   gitSessions.delete(sessionId);
 }
@@ -630,10 +733,20 @@ async function commitChanges(sessionId, 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/`);
+  try {
+    let cleanUrl = remoteUrl.trim();
+    if (cleanUrl.startsWith("git@github.com:")) {
+      cleanUrl = cleanUrl.replace("git@github.com:", "https://github.com/");
+    }
+    if (cleanUrl.includes("github.com")) {
+      const parsed = new URL(cleanUrl);
+      parsed.username = "x-access-token";
+      parsed.password = token;
+      return parsed.toString();
+    }
+  } catch (e) {
+    if (remoteUrl.includes("github.com")) {
+      return remoteUrl.replace(/https:\/\/(?:[^@]+@)?github\.com\//, `https://x-access-token:${token}@github.com/`);
     }
   }
   return remoteUrl;
@@ -1009,6 +1122,97 @@ async function executeRawCommand(sessionId, args) {
   const { git } = getGitSession(sessionId);
   return await git.raw(args);
 }
+async function cloneRepository(sessionId, remoteUrl, destPath) {
+  let normalizedUrl = remoteUrl.trim();
+  if (!normalizedUrl.startsWith("http://") && !normalizedUrl.startsWith("https://") && !normalizedUrl.startsWith("git@")) {
+    normalizedUrl = "https://github.com/" + normalizedUrl;
+  }
+  if (normalizedUrl.startsWith("git@github.com:")) {
+    normalizedUrl = normalizedUrl.replace("git@github.com:", "https://github.com/");
+  }
+  if (!normalizedUrl.endsWith(".git") && normalizedUrl.startsWith("http")) {
+    normalizedUrl += ".git";
+  }
+  const authUrl = injectAuthToken(sessionId, normalizedUrl);
+  await fs__namespace.mkdir(path__namespace.dirname(destPath), { recursive: true });
+  let destExists = false;
+  let destIsEmpty = false;
+  let destHasGit = false;
+  try {
+    const stats = await fs__namespace.stat(destPath);
+    if (stats.isDirectory()) {
+      destExists = true;
+      const files = await fs__namespace.readdir(destPath);
+      const realFiles = files.filter(
+        (f) => ![".ds_store", "desktop.ini", "thumbs.db"].includes(f.toLowerCase())
+      );
+      destIsEmpty = realFiles.length === 0;
+      destHasGit = files.includes(".git");
+    }
+  } catch {
+    destExists = false;
+  }
+  try {
+    if (destExists && destHasGit) {
+      const existingGit = createSafeGit(destPath);
+      try {
+        await existingGit.raw(["config", "--global", "--add", "safe.directory", destPath]);
+        const remotes = await existingGit.getRemotes();
+        if (remotes.some((r) => r.name === "origin")) {
+          await existingGit.raw(["remote", "set-url", "origin", authUrl]);
+        } else {
+          await existingGit.raw(["remote", "add", "origin", authUrl]);
+        }
+        await existingGit.raw(["-c", "credential.helper=", "fetch", "origin"]);
+        const st = await existingGit.status();
+        const branch = st.current || "main";
+        try {
+          await existingGit.raw(["-c", "credential.helper=", "pull", "origin", branch]);
+        } catch (e) {
+        }
+        return destPath;
+      } catch (err) {
+        console.warn("Re-using existing repo failed, falling through to clone attempt:", err);
+      }
+    }
+    if (destExists && destIsEmpty) {
+      const emptyDirGit = createSafeGit(destPath);
+      await emptyDirGit.raw(["-c", "credential.helper=", "clone", authUrl, "."]);
+      try {
+        await createSafeGit().raw(["config", "--global", "--add", "safe.directory", destPath]);
+      } catch (e) {
+      }
+      return destPath;
+    }
+    if (destExists && !destIsEmpty && !destHasGit) {
+      throw new Error(
+        `The folder '${path__namespace.basename(destPath)}' already contains files. Please select an empty folder or a different location to clone.`
+      );
+    }
+    const baseDir = path__namespace.dirname(destPath);
+    const targetDirName = path__namespace.basename(destPath);
+    const parentGit = createSafeGit(baseDir);
+    await parentGit.raw(["-c", "credential.helper=", "clone", authUrl, targetDirName]);
+    try {
+      await createSafeGit().raw(["config", "--global", "--add", "safe.directory", destPath]);
+    } catch (e) {
+    }
+    return destPath;
+  } catch (err) {
+    const token = getToken(sessionId);
+    let cleanMsg = err?.message || String(err);
+    if (token) {
+      cleanMsg = cleanMsg.split(token).join("***");
+    }
+    cleanMsg = cleanMsg.replace(/https:\/\/[^@]+@github\.com/g, "https://github.com");
+    if (cleanMsg.includes("terminal prompts disabled") || cleanMsg.includes("Authentication failed") || cleanMsg.includes("could not read Username")) {
+      throw new Error(
+        `Authentication failed for GitHub repository. Please verify your account is logged in and has access to this repository.`
+      );
+    }
+    throw new Error(cleanMsg);
+  }
+}
 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.
@@ -1114,6 +1318,32 @@ ${errorMsg}
     `AI Analysis failed after trying all provided keys. Last error: ${lastError?.message}`
   );
 }
+const getConfigPath = () => path__namespace.join(electron.app.getPath("userData"), "gitx-config.json");
+const saveLastWorkspace = async (workspacePath) => {
+  try {
+    const configPath = getConfigPath();
+    let config = {};
+    try {
+      const data = await fs__namespace.readFile(configPath, "utf8");
+      config = JSON.parse(data);
+    } catch (e) {
+    }
+    config.lastWorkspace = workspacePath;
+    await fs__namespace.writeFile(configPath, JSON.stringify(config, null, 2));
+  } catch (e) {
+    console.error("Failed to save workspace", e);
+  }
+};
+const getLastWorkspace = async () => {
+  try {
+    const configPath = getConfigPath();
+    const data = await fs__namespace.readFile(configPath, "utf8");
+    const config = JSON.parse(data);
+    return config.lastWorkspace || null;
+  } catch (e) {
+    return null;
+  }
+};
 let currentWatcher = null;
 let syncTimeout = null;
 let isAutoSyncEnabled = false;
@@ -1288,6 +1518,7 @@ electron.app.whenReady().then(async () => {
     if (isRepo) {
       initGit(sessionId, path2);
     }
+    await saveLastWorkspace(path2);
     return { path: path2, isRepo };
   });
   electron.ipcMain.handle("set-repo-path", async (event, path2) => {
@@ -1296,6 +1527,7 @@ electron.app.whenReady().then(async () => {
     if (isRepo) {
       initGit(sessionId, path2);
     }
+    await saveLastWorkspace(path2);
     return { path: path2, isRepo };
   });
   electron.ipcMain.handle("init-repo", async (event, path2) => {
@@ -1378,6 +1610,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 +1732,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);
@@ -1549,7 +1815,10 @@ electron.app.whenReady().then(async () => {
       }, 500);
     });
   });
-  createWindow();
+  if (!initialRepo) {
+    initialRepo = await getLastWorkspace();
+  }
+  createWindow(initialRepo || void 0);
   electron.app.on("activate", function() {
     if (electron.BrowserWindow.getAllWindows().length === 0) createWindow();
   });

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),