federaide-dev-nightly 2.0.1__tar.gz → 2.0.2__tar.gz

{federaide_dev_nightly-2.0.1/src/federaide_dev_nightly.egg-info → federaide_dev_nightly-2.0.2}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: federaide-dev-nightly
-Version: 2.0.1
+Version: 2.0.2
 Summary: A cross-platform terminal based p2p agent orchestration harness and universal automation system
 Author-email: ROCK-LAB-PRIVATE-LIMITED <arkadeep_ghosh@rocklab.in>
 License: GNU Affero General Public License v3

{federaide_dev_nightly-2.0.1 → federaide_dev_nightly-2.0.2}/pyproject.toml

@@ -4,7 +4,7 @@ build-backend = "setuptools.build_meta"
 
 [project]
 name = "federaide-dev-nightly"
-version = "2.0.1"
+version = "2.0.2"
 description = "A cross-platform terminal based p2p agent orchestration harness and universal automation system"
 readme = "README.md"
 license = {text = "GNU Affero General Public License v3"}

{federaide_dev_nightly-2.0.1 → federaide_dev_nightly-2.0.2/src/federaide_dev_nightly.egg-info}/PKG-INFO

@@ -1,6 +1,6 @@
 Metadata-Version: 2.4
 Name: federaide-dev-nightly
-Version: 2.0.1
+Version: 2.0.2
 Summary: A cross-platform terminal based p2p agent orchestration harness and universal automation system
 Author-email: ROCK-LAB-PRIVATE-LIMITED <arkadeep_ghosh@rocklab.in>
 License: GNU Affero General Public License v3

{federaide_dev_nightly-2.0.1 → federaide_dev_nightly-2.0.2}/src/federate/agent.py

@@ -294,6 +294,45 @@ class ClarificationModal(ModalScreen[str]):
     def on_cancel(self):
         self.dismiss("")
 
+def get_git_commit_times(team_dir: str = None) -> dict:
+    times = {}
+    t_dir = team_dir or toolbox.get_team_dir()
+    try:
+        res = subprocess.run(
+            ["git", "log", "--format=COMMIT:%ct", "--name-only", "--", "sessions", "nomem_sessions"],
+            cwd=t_dir,
+            capture_output=True,
+            text=True,
+            timeout=3
+        )
+        if res.returncode == 0:
+            cur_time = 0.0
+            for line in res.stdout.splitlines():
+                line = line.strip()
+                if line.startswith("COMMIT:"):
+                    try: cur_time = float(line.split(":")[1])
+                    except Exception: cur_time = 0.0
+                elif line and cur_time:
+                    abs_p = os.path.normpath(os.path.join(t_dir, line))
+                    if abs_p not in times:
+                        times[abs_p] = cur_time
+    except Exception:
+        pass
+    return times
+
+def get_session_file_time(fpath: str, git_times: dict = None) -> float:
+    norm = os.path.normpath(fpath)
+    if git_times and norm in git_times:
+        return git_times[norm]
+    parts = os.path.basename(fpath).replace(".json", "").split("_")
+    for p in parts:
+        if p.isdigit() and len(p) >= 9:
+            return float(p)
+    try:
+        return os.path.getmtime(fpath)
+    except Exception:
+        return 0.0
+
 class ChatLoadModal(ModalScreen[str]):
     DEFAULT_CSS = """
     ChatLoadModal { align: center middle; background: $background 60%; }
@@ -310,7 +349,9 @@ class ChatLoadModal(ModalScreen[str]):
     def compose(self) -> ComposeResult:
         files_normal = glob.glob(toolbox.get_storage_path("sessions", "*.json"))
         files_nomem = glob.glob(toolbox.get_storage_path("nomem_sessions", "*.json"))
-        files = sorted(files_normal + files_nomem, key=os.path.getmtime, reverse=True)
+        raw_files = sorted(files_normal + files_nomem)
+        git_times = get_git_commit_times()
+        files = sorted(raw_files, key=lambda f: get_session_file_time(f, git_times), reverse=True)
         name_map = agent_core.get_session_name_map()
 
         def _extract_info(fpath):
@@ -1631,10 +1672,42 @@ class TeamDeleteModal(ModalScreen[str]):
         else:
             self.dismiss("cancel")
 
+class GitConflictModal(ModalScreen[str]):
+    DEFAULT_CSS = """
+    GitConflictModal { align: center middle; background: $background 60%; }
+    #conflict_dialog { width: 70; height: auto; border: thick $error; background: $surface; padding: 1 2; }
+    .conflict_msg { margin: 1 0; text-wrap: wrap; height: auto; }
+    .conflict_buttons { layout: horizontal; height: auto; align: right middle; margin-top: 1; }
+    .conflict_buttons Button { margin-left: 1; }
+    """
+    def compose(self) -> ComposeResult:
+        with Vertical(id="conflict_dialog"):
+            yield Label(" Git History Conflict Detected!", classes="pane_title")
+            yield Label(
+                "The local and remote repository histories have diverged and cannot be automatically merged.\n\n"
+                "Which branch would you like to keep?\n"
+                "• Keep Local: Overwrites remote with your local files (Force Push).\n"
+                "• Keep Remote: Overwrites local files with the remote repository.",
+                classes="conflict_msg"
+            )
+            with Horizontal(classes="conflict_buttons"):
+                yield Button("Keep Local (Force Push)", id="btn_keep_local", variant="success")
+                yield Button("Keep Remote (Reset)", id="btn_keep_remote", variant="warning")
+                yield Button("Cancel", id="btn_abort", variant="error")
+
+    @on(Button.Pressed)
+    def handle_press(self, event: Button.Pressed):
+        if event.button.id == "btn_keep_local":
+            self.dismiss("local")
+        elif event.button.id == "btn_keep_remote":
+            self.dismiss("remote")
+        else:
+            self.dismiss("abort")
+
 class TeamsModal(ModalScreen[None]):
     DEFAULT_CSS = """
     TeamsModal { align: center middle; background: $background 60%; }
-    #teams_dialog { width: 80; height: 85%; border: thick $primary; background: $surface; padding: 1 2; }
+    #teams_dialog { width: 88; height: 85%; border: thick $primary; background: $surface; padding: 1 2; }
     #teams_main_scroll { height: 1fr; border: round $accent; padding: 1; background: $boost; margin-bottom: 1; }
     #team_form { height: auto; margin-bottom: 1; }
     #team_list { height: auto; }
@@ -1647,8 +1720,8 @@ class TeamsModal(ModalScreen[None]):
     #team_folder_input { width: 1fr; }
     #team_git_user_input { width: 1fr; margin-right: 1; }
     #team_git_pat_input { width: 1fr; }
-    .team_form_btns { layout: horizontal; height: auto; margin-top: 1; align: right middle; }
-    .team_form_btns Button { margin-left: 1; }
+    .team_form_row { layout: horizontal; height: auto; margin-top: 1; width: 100%; }
+    .team_form_row Button { width: 1fr; margin: 0 1; }
     #teams_bottom_buttons { height: auto; align: right middle; margin-top: 0; }
     #teams_bottom_buttons Button { margin-left: 1; }
     """
@@ -1674,11 +1747,15 @@ class TeamsModal(ModalScreen[None]):
                         yield Input(placeholder="Git Username", id="team_git_user_input")
                         yield Input(placeholder="Personal Access Token (PAT)", id="team_git_pat_input", password=True)
                     
-                    with Horizontal(classes="team_form_btns"):
+                    with Horizontal(classes="team_form_row"):
                         yield Button("Save Team", id="save_team_btn", variant="success")
                         yield Button("Restore", id="restore_btn", variant="primary")
-                        yield Button("Sync Now", id="sync_now_btn", variant="warning")
                         yield Button("Clear Form", id="clear_form_btn", variant="default")
+
+                    with Horizontal(classes="team_form_row"):
+                        yield Button("Pull", id="pull_btn", variant="warning")
+                        yield Button("Push", id="push_btn", variant="warning")
+                        yield Button("Sync", id="sync_now_btn", variant="warning")
                 
                 yield Label("Registered Teams:", classes="section_label")
                 yield Vertical(id="team_list")
@@ -1715,7 +1792,58 @@ class TeamsModal(ModalScreen[None]):
         self.query_one("#team_remote_url_input", Input).value = ""
         self.query_one("#team_git_user_input", Input).value = ""
         self.query_one("#team_git_pat_input", Input).value = ""
-        self.query_one("#save_team_btn", Button).label = "Create"
+        self.query_one("#save_team_btn", Button).label = "Save Team"
+
+    def _handle_git_action(self, action_name: str, target_team_dir: str):
+        def _run_action():
+            try:
+
+                ok, msg = toolbox.sync_team_remote(action=action_name, team_dir=target_team_dir)
+                if ok:
+                    self.app.call_from_thread(self.notify, f"Git {action_name} completed successfully!", severity="information")
+                    if action_name in ["pull", "sync", "hard-reset-remote"]:
+                        self.agent_view.agent_manager.load_agents()
+                        self.agent_view.session_manager.sync_all_sessions()
+                        self.agent_view.update_status_bar()
+                    self.app.call_from_thread(self.refresh_list)
+                elif msg == "CONFLICT":
+                    def _on_conflict():
+                        def _resolve(choice):
+                            if choice == "local":
+                                self.notify("Overwriting remote with local state (force push)...", severity="warning")
+                                self._handle_git_action("force-push", target_team_dir)
+                            elif choice == "remote":
+                                self.notify("Overwriting local state with remote...", severity="warning")
+                                self._handle_git_action("hard-reset-remote", target_team_dir)
+                            else:
+                                self.notify("Git operation cancelled by user.", severity="information")
+                                _reenable()
+                        self.app.push_screen(GitConflictModal(), _resolve)
+                    self.app.call_from_thread(_on_conflict)
+                    return
+                else:
+                    self.app.call_from_thread(self.notify, f"Git {action_name} Failed: {msg}", severity="error", timeout=10.0)
+            except Exception as e:
+                self.app.call_from_thread(self.notify, f"Git Error: {e}", severity="error", timeout=10.0)
+            finally:
+                if msg != "CONFLICT":
+                    self.app.call_from_thread(_reenable)
+
+        def _reenable():
+            try:
+                self.query_one("#sync_now_btn", Button).disabled = False
+                self.query_one("#pull_btn", Button).disabled = False
+                self.query_one("#push_btn", Button).disabled = False
+            except Exception: pass
+            
+        try:
+            self.query_one("#sync_now_btn", Button).disabled = True
+            self.query_one("#pull_btn", Button).disabled = True
+            self.query_one("#push_btn", Button).disabled = True
+        except Exception: pass
+
+        import threading
+        threading.Thread(target=_run_action, daemon=True).start()
 
     def refresh_list(self):
         container = self.query_one("#team_list")
@@ -1786,42 +1914,53 @@ class TeamsModal(ModalScreen[None]):
             def _run_restore():
                 try:
                     from urllib.parse import urlparse, urlunparse, quote
-                    import subprocess
+                    import subprocess, tempfile, stat, contextlib, os
                     
+                    @contextlib.contextmanager
+                    def git_askpass_context(pat_str: str):
+                        askpass_ext = ".bat" if os.name == "nt" else ".sh"
+                        fd, askpass_path = tempfile.mkstemp(suffix=askpass_ext, text=True)
+                        with os.fdopen(fd, "w") as f:
+                            if os.name == "nt":
+                                f.write("@echo off\nif \"%~1\"==\"\" exit /b 0\necho %FEDERAIDE_GIT_PASSWORD%\n")
+                            else:
+                                f.write("#!/bin/sh\necho \"$FEDERAIDE_GIT_PASSWORD\"\n")
+                        if os.name != "nt":
+                            os.chmod(askpass_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
+                        
+                        env = os.environ.copy()
+                        env["GIT_ASKPASS"] = askpass_path
+                        env["FEDERAIDE_GIT_PASSWORD"] = pat_str
+                        env["GIT_TERMINAL_PROMPT"] = "0"
+                        try:
+                            yield env
+                        finally:
+                            try: os.remove(askpass_path)
+                            except Exception: pass
+
                     parsed = urlparse(url)
                     user_part = quote(user, safe='') if user else "git"
-                    pat_part = quote(pat, safe='')
-                    auth_netloc = f"{user_part}:{pat_part}@{parsed.netloc}"
-                    authed_url = urlunparse((parsed.scheme, auth_netloc, parsed.path, parsed.params, parsed.query, parsed.fragment))
+                    auth_netloc = f"{user_part}@{parsed.netloc}"
+                    safe_url = urlunparse((parsed.scheme, auth_netloc, parsed.path, parsed.params, parsed.query, parsed.fragment))
 
-                    res = subprocess.run(["git", "clone", authed_url, target_path], capture_output=True, text=True)
+                    with git_askpass_context(pat) as env:
+                        res = subprocess.run(["git", "clone", safe_url, target_path], capture_output=True, text=True, env=env)
                     
                     if res.returncode == 0:
-                        # SECURITY FIX: Remove PAT from .git/config immediately after cloning
                         subprocess.run(["git", "remote", "set-url", "origin", url], cwd=target_path, capture_output=True)
                         def _on_success():
                             self.notify("Restore completed successfully!", severity="information")
                             t_name = self.query_one("#team_name_input", Input).value.strip() or os.path.basename(target_path)
                             self.dismiss()
                             
-                            # Switch to the newly cloned workspace
                             self.agent_view.switch_team(target_path, display_name=t_name)
-                            
-                            # Save credentials securely into the keyring
-                            import toolbox
                             toolbox.save_team_git_credentials(url, user, pat, team_dir=target_path)
                             
-                            # Rebuild episodic and tool results databases in the background
-                            import threading
                             threading.Thread(target=self.agent_view.session_manager.sync_all_sessions, daemon=True).start()
                             
                         self.app.call_from_thread(_on_success)
                     else:
-                        def _sanitize(txt: str) -> str:
-                            if not txt: return ""
-                            clean = txt.replace(pat, "******") if pat else txt
-                            return clean.strip()
-                        err = _sanitize(res.stderr) or _sanitize(res.stdout) or "Clone failed."
+                        err = res.stderr.strip() or res.stdout.strip() or "Clone failed."
                         self.app.call_from_thread(self.notify, f"Restore Failed: {err}", severity="error", timeout=10.0)
                 except Exception as e:
                     self.app.call_from_thread(self.notify, f"Restore Error: {e}", severity="error", timeout=10.0)
@@ -1836,39 +1975,18 @@ class TeamsModal(ModalScreen[None]):
             import threading
             threading.Thread(target=_run_restore, daemon=True).start()
 
-        elif btn_id == "sync_now_btn":
+        elif btn_id in ("sync_now_btn", "pull_btn", "push_btn"):
             url = self.query_one("#team_remote_url_input", Input).value.strip()
             user = self.query_one("#team_git_user_input", Input).value.strip()
             pat = self.query_one("#team_git_pat_input", Input).value.strip()
             target_team_dir = self.editing_path or toolbox.get_team_dir()
             
             toolbox.save_team_git_credentials(url, user, pat, team_dir=target_team_dir)
-            self.notify(f"Syncing with Git remote for '{os.path.basename(target_team_dir)}'...", severity="information")
             
-            sync_btn = self.query_one("#sync_now_btn", Button)
-            sync_btn.disabled = True
-
-            def _run_sync():
-                try:
-                    ok, msg = toolbox.sync_team_remote(action="sync", team_dir=target_team_dir)
-                    if ok:
-                        self.app.call_from_thread(self.notify, "Git remote sync completed successfully!", severity="information")
-                        self.agent_view.agent_manager.load_agents()
-                        self.agent_view.session_manager.sync_all_sessions()
-                        self.agent_view.update_status_bar()
-                    else:
-                        self.app.call_from_thread(self.notify, f"Sync Failed: {msg}", severity="error", timeout=10.0)
-                except Exception as e:
-                    self.app.call_from_thread(self.notify, f"Sync Error: {e}", severity="error", timeout=10.0)
-                finally:
-                    def _reenable():
-                        try:
-                            self.query_one("#sync_now_btn", Button).disabled = False
-                        except Exception:
-                            pass
-                    self.app.call_from_thread(_reenable)
-
-            threading.Thread(target=_run_sync, daemon=True).start()
+            action_map = {"sync_now_btn": "sync", "pull_btn": "pull", "push_btn": "push"}
+            action = action_map[btn_id]
+            self.notify(f"{action.title()}ing with Git remote for '{os.path.basename(target_team_dir)}'...", severity="information")
+            self._handle_git_action(action, target_team_dir)
             
         elif btn_id == "save_team_btn":
             t_name = self.query_one("#team_name_input", Input).value.strip()
@@ -3457,9 +3575,10 @@ class AIAgentView(Vertical):
             self.log_to_ui("[bold red]No past chat sessions found to resume.[/bold red]")
             return
 
+        git_times = get_git_commit_times()
         sorted_sessions = sorted(
             sessions_map.items(),
-            key=lambda item: max(os.path.getmtime(f) for f in item[1]),
+            key=lambda item: max(get_session_file_time(f, git_times) for f in item[1]),
             reverse=True
         )
 

{federaide_dev_nightly-2.0.1 → federaide_dev_nightly-2.0.2}/src/federate/toolbox.py

@@ -548,7 +548,7 @@ def save_team_git_credentials(remote_url: str, username: str, pat: str, team_dir
 
 def sync_team_remote(action: str = "push", team_dir: str = None) -> tuple[bool, str]:
     """
-    Executes an in-memory authenticated Git remote operation (push, pull, force-push, sync).
+    Executes an authenticated Git remote operation.
     The PAT is dynamically read from Keyring and never written to disk or git configs.
     Returns (success, message).
     """
@@ -564,82 +564,141 @@ def sync_team_remote(action: str = "push", team_dir: str = None) -> tuple[bool,
         
     try:
         from urllib.parse import urlparse, urlunparse, quote
+        import tempfile, stat, contextlib
+
+        # 1. Commit any uncommitted changes first so git operations don't fail with "unstaged changes"
+        try:
+            flush_sqlite_databases()
+            subprocess.run(["git", "add", "."], cwd=t_dir, capture_output=True)
+            status = subprocess.run(["git", "status", "--porcelain"], cwd=t_dir, capture_output=True, text=True)
+            if status.stdout.strip():
+                subprocess.run(
+                    ["git", "-c", "user.name=FEDERaiDE", "-c", "user.email=harness@local", "commit", "-m", "Auto-commit before remote sync"],
+                    cwd=t_dir, capture_output=True
+                )
+        except Exception:
+            pass
+
         parsed = urlparse(remote_url)
         if not parsed.scheme or not parsed.netloc:
             return False, f"Invalid remote URL format: {remote_url}"
             
         user_part = quote(username.strip(), safe='') if username else "git"
-        pat_part = quote(pat.strip(), safe='')
-        auth_netloc = f"{user_part}:{pat_part}@{parsed.netloc}"
-        authed_url = urlunparse((parsed.scheme, auth_netloc, parsed.path, parsed.params, parsed.query, parsed.fragment))
-        
-        env = os.environ.copy()
-        env["GIT_TERMINAL_PROMPT"] = "0"
-
-        # Define _sanitize immediately so it is in scope everywhere below
-        def _sanitize(txt: str) -> str:
-            if not txt: return ""
-            clean = txt.replace(pat, "******")
-            if pat_part != pat:
-                clean = clean.replace(pat_part, "******")
-            return clean.strip()
+        auth_netloc = f"{user_part}@{parsed.netloc}"
+        safe_url = urlunparse((parsed.scheme, auth_netloc, parsed.path, parsed.params, parsed.query, parsed.fragment))
         
         branch_res = subprocess.run(["git", "rev-parse", "--abbrev-ref", "HEAD"], cwd=t_dir, capture_output=True, text=True)
         branch = branch_res.stdout.strip() if branch_res.returncode == 0 and branch_res.stdout.strip() else "main"
         user_args = ["-c", "user.name=FEDERaiDE", "-c", "user.email=harness@local"]
 
-        if action == "pull":
-            cmd = ["git"] + user_args + ["pull", "--rebase", authed_url, branch]
-            res = subprocess.run(cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
-            if res.returncode == 0:
-                return True, "Synchronized successfully."
-            return False, _sanitize(res.stderr) or _sanitize(res.stdout) or f"Git exited with code {res.returncode}"
+        @contextlib.contextmanager
+        def git_askpass_context(pat_str: str):
+            askpass_ext = ".bat" if os.name == "nt" else ".sh"
+            fd, askpass_path = tempfile.mkstemp(suffix=askpass_ext, text=True)
+            with os.fdopen(fd, "w") as f:
+                if os.name == "nt":
+                    f.write("@echo off\nif \"%~1\"==\"\" exit /b 0\necho %FEDERAIDE_GIT_PASSWORD%\n")
+                else:
+                    f.write("#!/bin/sh\necho \"$FEDERAIDE_GIT_PASSWORD\"\n")
+            if os.name != "nt":
+                os.chmod(askpass_path, stat.S_IRUSR | stat.S_IWUSR | stat.S_IXUSR)
+            
+            env = os.environ.copy()
+            env["GIT_ASKPASS"] = askpass_path
+            env["FEDERAIDE_GIT_PASSWORD"] = pat_str
+            env["GIT_TERMINAL_PROMPT"] = "0"
+            try:
+                yield env
+            finally:
+                try: os.remove(askpass_path)
+                except Exception: pass
 
-        elif action == "force-push":
-            cmd = ["git", "push", "--force", authed_url, f"HEAD:{branch}"]
-            res = subprocess.run(cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
-            if res.returncode == 0:
-                return True, "Synchronized successfully."
-            return False, _sanitize(res.stderr) or _sanitize(res.stdout) or f"Git exited with code {res.returncode}"
+        with git_askpass_context(pat) as env:
+            if action == "pull":
+                cmd = ["git"] + user_args + ["pull", "--rebase", "--autostash", safe_url, branch]
+                res = subprocess.run(cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
+                if res.returncode == 0:
+                    return True, "Synchronized successfully."
+                
+                err_check = (res.stderr + res.stdout).lower()
+                subprocess.run(["git", "rebase", "--abort"], cwd=t_dir, capture_output=True, env=env)
+                subprocess.run(["git", "merge", "--abort"], cwd=t_dir, capture_output=True, env=env)
+                
+                conflict_indicators = [
+                    "conflict", "divergent", "unstaged changes", "cannot pull with rebase",
+                    "unrelated histories", "failed to merge", "could not apply", "patch failed",
+                    "non-fast-forward"
+                ]
+                if any(ind in err_check for ind in conflict_indicators):
+                    return False, "CONFLICT"
+
+                return False, res.stderr.strip() or res.stdout.strip() or f"Git exited with code {res.returncode}"
+
+            elif action == "push":
+                cmd = ["git", "push", safe_url, f"HEAD:{branch}"]
+                res = subprocess.run(cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
+                if res.returncode == 0:
+                    return True, "Pushed successfully."
+                    
+                err_check = (res.stderr + res.stdout).lower()
+                conflict_indicators = [
+                    "non-fast-forward", "fetch first", "rejected", "behind", "conflict"
+                ]
+                if any(ind in err_check for ind in conflict_indicators):
+                    return False, "CONFLICT"
+
+                return False, res.stderr.strip() or res.stdout.strip() or f"Git exited with code {res.returncode}"
+
+            elif action == "force-push":
+                cmd = ["git", "push", "--force", safe_url, f"HEAD:{branch}"]
+                res = subprocess.run(cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
+                if res.returncode == 0:
+                    return True, "Force pushed successfully."
+                return False, res.stderr.strip() or res.stdout.strip() or f"Git exited with code {res.returncode}"
+
+            elif action == "hard-reset-remote":
+                fetch_cmd = ["git", "fetch", safe_url, branch]
+                fetch_res = subprocess.run(fetch_cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
+                if fetch_res.returncode != 0:
+                    return False, fetch_res.stderr.strip() or fetch_res.stdout.strip() or "Fetch failed."
+                    
+                reset_cmd = ["git", "reset", "--hard", "FETCH_HEAD"]
+                res = subprocess.run(reset_cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
+                if res.returncode == 0:
+                    return True, "Reset to remote state successfully."
+                return False, res.stderr.strip() or res.stdout.strip() or f"Git exited with code {res.returncode}"
+
+            elif action == "sync":
+                # 1. Try pushing first. If remote is brand new/empty, or local is up-to-date, this succeeds immediately!
+                push_cmd = ["git", "push", safe_url, f"HEAD:{branch}"]
+                res = subprocess.run(push_cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
+                if res.returncode == 0:
+                    return True, "Synchronized successfully."
 
-        elif action == "sync":
-            # 1. Try pushing first. If remote is brand new/empty, or local is up-to-date, this succeeds immediately!
-            push_cmd = ["git", "push", authed_url, f"HEAD:{branch}"]
-            res = subprocess.run(push_cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
-            if res.returncode == 0:
-                return True, "Synchronized successfully."
-
-            err_check = (res.stderr + res.stdout).lower()
-            # If rejected because remote has existing commits (non-fast-forward / fetch first)
-            if "fetch first" in err_check or "rejected" in err_check or "non-fast-forward" in err_check:
-                # 2. Pull remote commits with rebase
-                pull_cmd = ["git"] + user_args + ["pull", "--rebase", "--autostash", authed_url, branch]
-                pull_res = subprocess.run(pull_cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
-                if pull_res.returncode != 0:
-                    subprocess.run(["git", "rebase", "--abort"], cwd=t_dir, capture_output=True, env=env)
-                    # Fallback for unrelated histories (e.g. GitHub repo created with an initial README)
-                    pull_merge_cmd = ["git"] + user_args + [
-                        "pull", "--no-rebase", "--allow-unrelated-histories", "-X", "theirs", authed_url, branch
-                    ]
-                    pull_res = subprocess.run(pull_merge_cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
+                err_check = (res.stderr + res.stdout).lower()
+                if any(ind in err_check for ind in ["fetch first", "rejected", "non-fast-forward", "behind"]):
+                    # 2. Pull remote commits with rebase
+                    pull_cmd = ["git"] + user_args + ["pull", "--rebase", "--autostash", safe_url, branch]
+                    pull_res = subprocess.run(pull_cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
                     if pull_res.returncode != 0:
-                        return False, _sanitize(pull_res.stderr) or _sanitize(pull_res.stdout) or "Git pull failed."
+                        subprocess.run(["git", "rebase", "--abort"], cwd=t_dir, capture_output=True, env=env)
+                        return False, "CONFLICT"
 
-                # 3. Re-push now that remote is integrated
-                final_push = subprocess.run(push_cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
-                if final_push.returncode == 0:
-                    return True, "Synchronized successfully."
-                return False, _sanitize(final_push.stderr) or _sanitize(final_push.stdout) or f"Git push failed with code {final_push.returncode}"
+                    # 3. Re-push now that remote is integrated
+                    final_push = subprocess.run(push_cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
+                    if final_push.returncode == 0:
+                        return True, "Synchronized successfully."
+                        
+                    final_err = (final_push.stderr + final_push.stdout).lower()
+                    if any(ind in final_err for ind in ["fetch first", "rejected", "non-fast-forward", "behind"]):
+                        return False, "CONFLICT"
+                        
+                    return False, final_push.stderr.strip() or final_push.stdout.strip() or f"Git push failed with code {final_push.returncode}"
 
-            # Any other error (e.g. authentication failed, bad URL)
-            return False, _sanitize(res.stderr) or _sanitize(res.stdout) or f"Git exited with code {res.returncode}"
+                return False, res.stderr.strip() or res.stdout.strip() or f"Git exited with code {res.returncode}"
 
-        else:
-            cmd = ["git", "push", authed_url, f"HEAD:{branch}"]
-            res = subprocess.run(cmd, cwd=t_dir, capture_output=True, text=True, env=env, timeout=120)
-            if res.returncode == 0:
-                return True, "Synchronized successfully."
-            return False, _sanitize(res.stderr) or _sanitize(res.stdout) or f"Git exited with code {res.returncode}"
+            else:
+                return False, f"Unknown action: {action}"
 
     except subprocess.TimeoutExpired:
         return False, "Connection timed out after 120s."