gitxelectron 1.1.8 → 1.2.0

package/out/main/index.js

@@ -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 {
@@ -578,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);
 }
@@ -709,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;
@@ -1089,20 +1123,95 @@ async function executeRawCommand(sessionId, args) {
   return await git.raw(args);
 }
 async function cloneRepository(sessionId, remoteUrl, destPath) {
-  const authUrl = injectAuthToken(sessionId, remoteUrl);
+  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 });
-  const git = simpleGit.simpleGit().env({
-    ...process.env,
-    GCM_INTERACTIVE: "false",
-    GIT_TERMINAL_PROMPT: "0",
-    GIT_ASKPASS: "echo"
-  });
-  await git.clone(authUrl, destPath);
+  let destExists = false;
+  let destIsEmpty = false;
+  let destHasGit = false;
   try {
-    await simpleGit.simpleGit().raw(["config", "--global", "--add", "safe.directory", destPath]);
-  } catch (e) {
+    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);
   }
-  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.
@@ -1209,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;
@@ -1235,7 +1370,9 @@ function toggleAutoSync(sessionId, repoPath, enabled, onLog) {
       // ignore dotfiles (.git, .DS_Store)
       /node_modules/,
       /dist/,
-      /build/
+      /build/,
+      /~\$/
+      // ignore Office temp lock files (~$README.md, etc.)
     ],
     persistent: true,
     ignoreInitial: true
@@ -1259,7 +1396,12 @@ async function triggerSyncSequence(sessionId, _repoPath, onLog) {
   changedFiles.clear();
   try {
     onLog(`Staging ${filesToSync.length} file(s)...`);
-    await stageFiles(sessionId, filesToSync);
+    const existingFiles = filesToSync.filter((f) => !f.startsWith("~$") && !f.includes("/~$"));
+    if (existingFiles.length === 0) {
+      onLog("No valid files to sync (temp files filtered).");
+      return;
+    }
+    await stageFiles(sessionId, existingFiles);
     const status = await getStatus(sessionId);
     const branch = status.current || "main";
     const commitMsg = `Auto-sync: update ${filesToSync.length > 1 ? filesToSync.length + " files" : filesToSync[0]}`;
@@ -1383,6 +1525,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) => {
@@ -1391,6 +1534,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) => {
@@ -1678,7 +1822,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();
   });