feat: improve PR button UX with push support and conditional visibility (#89)

Co-authored-by: Claude Sonnet 4.5 <noreply@anthropic.com>

Author: matt2e

staged/src-tauri/Cargo.lock

@@ -47,7 +47,7 @@ tauri-plugin-clipboard-manager = "2.3.2"
 tauri-plugin-window-state = "2.4.1"
 reqwest = { version = "0.13.1", features = ["json"] }
 tokio = { version = "1.49.0", features = ["sync", "process", "io-util", "macros", "rt-multi-thread"] }
-open = "5"
+tauri-plugin-opener = "2"
 
 # Agent Client Protocol (ACP) for AI integration
 agent-client-protocol = "0.9"

staged/src-tauri/Cargo.toml

@@ -454,7 +454,7 @@ fn get_github_token() -> Result<String, GitError> {
 }
 
 /// Get the GitHub owner/repo from the repo's origin remote.
-fn get_github_repo(repo: &Path) -> Result<(String, String), GitError> {
+pub fn get_github_repo(repo: &Path) -> Result<(String, String), GitError> {
     use super::cli;
 
     let url = cli::run(repo, &["remote", "get-url", "origin"])?;

staged/src-tauri/src/git/github.rs

@@ -24,7 +24,7 @@ pub use refs::{
 pub use types::*;
 pub use worktree::{
     branch_exists, create_worktree, create_worktree_for_existing_branch, create_worktree_from_pr,
-    get_commits_since_base, get_full_commit_log, get_head_sha, get_parent_commit, list_worktrees,
-    remove_worktree, reset_to_commit, switch_branch, update_branch_from_pr, worktree_path_for,
-    CommitInfo, UpdateFromPrResult,
+    get_commits_since_base, get_full_commit_log, get_head_sha, get_parent_commit,
+    has_unpushed_commits, list_worktrees, remove_worktree, reset_to_commit, switch_branch,
+    update_branch_from_pr, worktree_path_for, CommitInfo, UpdateFromPrResult,
 };

staged/src-tauri/src/git/mod.rs

@@ -499,6 +499,23 @@ pub fn switch_branch(worktree: &Path, branch_name: &str) -> Result<(), GitError>
     Ok(())
 }
 
+/// Check if the local branch has commits not yet pushed to the remote.
+///
+/// Compares the local HEAD with `origin/<branch>`. Returns `true` if there
+/// are commits in the local branch that are not in the remote tracking branch.
+/// Returns `false` if the remote tracking branch doesn't exist (e.g., never pushed).
+pub fn has_unpushed_commits(worktree: &Path, branch: &str) -> Result<bool, GitError> {
+    let remote_ref = format!("origin/{branch}");
+    // Check that the remote ref exists first
+    if cli::run(worktree, &["rev-parse", "--verify", &remote_ref]).is_err() {
+        // Remote tracking branch doesn't exist — treat as "all commits are unpushed"
+        // but only if there are local commits at all
+        return Ok(false);
+    }
+    let output = cli::run(worktree, &["rev-list", &format!("{remote_ref}..HEAD")])?;
+    Ok(!output.trim().is_empty())
+}
+
 #[cfg(test)]
 mod tests {
     use super::*;

staged/src-tauri/src/git/worktree.rs

@@ -1710,6 +1710,36 @@ This is critical - the application parses this to link the PR.
     Ok(session.id)
 }
 
+/// Build the GitHub PR URL for a branch from its remote origin and PR number.
+///
+/// Parses the `origin` remote URL to extract the GitHub owner/repo, then
+/// returns `https://github.com/{owner}/{repo}/pull/{pr_number}`.
+#[tauri::command(rename_all = "camelCase")]
+fn get_pr_url(
+    store: tauri::State<'_, Mutex<Option<Arc<Store>>>>,
+    branch_id: String,
+    pr_number: u64,
+) -> Result<String, String> {
+    let store = get_store(&store)?;
+
+    let branch = store
+        .get_branch(&branch_id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("Branch not found: {branch_id}"))?;
+
+    let project = store
+        .get_project(&branch.project_id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("Project not found: {}", branch.project_id))?;
+
+    let repo_path = Path::new(&project.repo_path);
+    let (owner, repo_name) = git::github::get_github_repo(repo_path).map_err(|e| e.to_string())?;
+
+    Ok(format!(
+        "https://github.com/{owner}/{repo_name}/pull/{pr_number}"
+    ))
+}
+
 /// Update the PR number for a branch.
 #[tauri::command(rename_all = "camelCase")]
 fn update_branch_pr(
@@ -1722,14 +1752,148 @@ fn update_branch_pr(
         .map_err(|e| e.to_string())
 }
 
+/// Check if a branch has commits that haven't been pushed to the remote.
+#[tauri::command(rename_all = "camelCase")]
+fn has_unpushed_commits(
+    store: tauri::State<'_, Mutex<Option<Arc<Store>>>>,
+    branch_id: String,
+) -> Result<bool, String> {
+    let store = get_store(&store)?;
+
+    let branch = store
+        .get_branch(&branch_id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("Branch not found: {branch_id}"))?;
+
+    let workdir = store
+        .get_workdir_for_branch(&branch_id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("No worktree for branch: {branch_id}"))?;
+
+    git::has_unpushed_commits(Path::new(&workdir.path), &branch.branch_name)
+        .map_err(|e| e.to_string())
+}
+
+/// Push a branch to its remote by kicking off an agent session.
+///
+/// The agent runs `git push` and can diagnose and fix pre-push hook
+/// failures or other push errors. Returns the session ID so the
+/// frontend can track progress (same pattern as `create_pr`).
+///
+/// For remote branches the session runs inside the Blox workspace.
+#[tauri::command(rename_all = "camelCase")]
+fn push_branch(
+    store: tauri::State<'_, Mutex<Option<Arc<Store>>>>,
+    registry: tauri::State<'_, Arc<session_runner::SessionRegistry>>,
+    app_handle: tauri::AppHandle,
+    branch_id: String,
+    provider: Option<String>,
+    force: Option<bool>,
+) -> Result<String, String> {
+    let store = get_store(&store)?;
+
+    let branch = store
+        .get_branch(&branch_id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("Branch not found: {branch_id}"))?;
+
+    let project = store
+        .get_project(&branch.project_id)
+        .map_err(|e| e.to_string())?
+        .ok_or_else(|| format!("Project not found: {}", branch.project_id))?;
+
+    let is_remote = branch.branch_type == store::BranchType::Remote;
+
+    let (working_dir, workspace_name) = if is_remote {
+        let repo_path = PathBuf::from(&project.repo_path);
+        (repo_path, branch.workspace_name.clone())
+    } else {
+        let workdir = store
+            .get_workdir_for_branch(&branch_id)
+            .map_err(|e| e.to_string())?
+            .ok_or_else(|| format!("No worktree for branch: {branch_id}"))?;
+
+        let mut working_dir = PathBuf::from(&workdir.path);
+        if let Some(ref subpath) = project.subpath {
+            working_dir = working_dir.join(subpath);
+        }
+        (working_dir, None)
+    };
+
+    let force = force.unwrap_or(false);
+
+    let prompt = if force {
+        format!(
+            r#"<action>
+Push the current branch to the remote using force-with-lease.
+
+Run: `git push -u origin {branch_name} --force-with-lease`
+
+If the push fails due to pre-push hook errors, read the error output, fix the underlying issue, and retry the push.
+
+The push must succeed before you finish.
+</action>"#,
+            branch_name = branch.branch_name,
+        )
+    } else {
+        format!(
+            r#"<action>
+Push the current branch to the remote.
+
+Run: `git push -u origin {branch_name}`
+
+IMPORTANT: You MUST NOT use --force, --force-with-lease, or any force-push variant. Only a normal push is allowed.
+
+If the push fails due to pre-push hook errors, read the error output, fix the underlying issue, and retry the push.
+
+If the push is rejected because the remote has commits that would be lost (non-fast-forward rejection), do NOT attempt to fix it. Instead, output the following marker on its own line and stop:
+PUSH_REJECTED: NON_FAST_FORWARD
+
+For any other failure, diagnose the problem and fix it, then retry the push.
+
+The push must succeed before you finish (unless you output the non-fast-forward marker above).
+</action>"#,
+            branch_name = branch.branch_name,
+        )
+    };
+
+    // Create the session
+    let mut session = store::Session::new_running(&prompt, &working_dir);
+    if let Some(ref p) = provider {
+        session = session.with_provider(p);
+    }
+    store.create_session(&session).map_err(|e| e.to_string())?;
+
+    session_runner::start_session(
+        session_runner::SessionConfig {
+            session_id: session.id.clone(),
+            prompt,
+            working_dir,
+            agent_session_id: None,
+            pre_head_sha: None,
+            provider,
+            workspace_name,
+        },
+        store,
+        app_handle,
+        Arc::clone(&registry),
+    )?;
+
+    Ok(session.id)
+}
+
 // =============================================================================
 // Utilities
 // =============================================================================
 
 /// Open a URL in the user's default browser.
 #[tauri::command]
-fn open_url(url: String) -> Result<(), String> {
-    open::that(&url).map_err(|e| format!("Failed to open URL: {e}"))
+fn open_url(app_handle: tauri::AppHandle, url: String) -> Result<(), String> {
+    use tauri_plugin_opener::OpenerExt;
+    app_handle
+        .opener()
+        .open_url(&url, None::<&str>)
+        .map_err(|e| format!("Failed to open URL: {e}"))
 }
 
 /// Check whether the `sq` CLI is available on this system.
@@ -1900,6 +2064,7 @@ pub fn run() {
     tauri::Builder::default()
         .plugin(tauri_plugin_dialog::init())
         .plugin(tauri_plugin_clipboard_manager::init())
+        .plugin(tauri_plugin_opener::init())
         .plugin(
             tauri_plugin_window_state::Builder::new()
                 .with_state_flags(
@@ -2120,7 +2285,10 @@ pub fn run() {
             list_pull_requests,
             list_issues,
             create_pr,
+            get_pr_url,
             update_branch_pr,
+            has_unpushed_commits,
+            push_branch,
             open_url,
             is_sq_available,
             get_available_openers,

staged/src-tauri/src/lib.rs

@@ -440,7 +440,28 @@ export function createPr(branchId: string, provider?: string): Promise<string> {
   return invoke('create_pr', { branchId, provider: provider ?? null });
 }
 
+/** Build the GitHub PR URL from the repo's origin remote and a PR number. */
+export function getPrUrl(branchId: string, prNumber: number): Promise<string> {
+  return invoke('get_pr_url', { branchId, prNumber });
+}
+
 /** Update the PR number stored for a branch. */
 export function updateBranchPr(branchId: string, prNumber: number | null): Promise<void> {
   return invoke('update_branch_pr', { branchId, prNumber });
 }
+
+/** Check whether a branch has local commits not yet pushed to the remote. */
+export function hasUnpushedCommits(branchId: string): Promise<boolean> {
+  return invoke('has_unpushed_commits', { branchId });
+}
+
+/** Push a branch to its remote via an agent session.
+ *  The agent runs git push and can fix pre-push hook failures.
+ *  Returns the session ID so the frontend can track progress. */
+export function pushBranch(branchId: string, provider?: string, force?: boolean): Promise<string> {
+  return invoke('push_branch', {
+    branchId,
+    provider: provider ?? null,
+    force: force ?? null,
+  });
+}