feat: support multiple run actions (#636)

Author: dohooo

src-tauri/src/commands/script_commands.rs

@@ -1,20 +1,99 @@
 use tauri::ipc::Channel;
 use tauri::{AppHandle, State};
 
-use crate::repos;
+use crate::repos::{self, RunAction};
 use crate::workspace::scripts::{ScriptContext, ScriptEvent, ScriptProcessManager};
 
 use super::common::CmdResult;
 
+/// Internal `script_type` namespace for the run script after the multi-action
+/// refactor. Process keys for run scripts are `"run:<action_id>"` so the
+/// process manager can distinguish per-action lifecycles within the same
+/// workspace, and so `kill_others_in_repo` naturally implements per-action
+/// exclusive mode by filtering on the full `"run:<id>"` string.
+fn run_script_type(action_id: &str) -> String {
+    format!("run:{action_id}")
+}
+
+/// Resolve which `RunAction` the caller is targeting.
+///
+///   - If `action_id` is supplied, look it up by id; error if it's gone.
+///   - If `action_id` is None, fall back to the first action in display order
+///     (legacy callers that haven't been updated yet).
+///
+/// Returns the action plus the process key to use for it.
+fn resolve_run_target(
+    repo_id: &str,
+    workspace_id: Option<&str>,
+    action_id: Option<&str>,
+) -> anyhow::Result<RunAction> {
+    let scripts = repos::load_repo_scripts(repo_id, workspace_id)?;
+    let action = match action_id {
+        Some(id) => scripts
+            .run_actions
+            .into_iter()
+            .find(|a| a.id == id)
+            .ok_or_else(|| anyhow::anyhow!("Run action not found: {id}"))?,
+        None => scripts
+            .run_actions
+            .into_iter()
+            .next()
+            .ok_or_else(|| anyhow::anyhow!("No run actions configured for repo {repo_id}"))?,
+    };
+    Ok(action)
+}
+
 #[tauri::command]
 pub async fn execute_repo_script(
     app: AppHandle,
     manager: State<'_, ScriptProcessManager>,
     repo_id: String,
     script_type: String,
     workspace_id: Option<String>,
+    action_id: Option<String>,
     channel: Channel<ScriptEvent>,
 ) -> CmdResult<()> {
+    // Run scripts are dispatched per `action_id` against the multi-action
+    // model. Setup / archive remain single per repo.
+    if script_type == "run" {
+        let ws = workspace_id.clone();
+        let rid = repo_id.clone();
+        let aid = action_id.clone();
+        let action = match tauri::async_runtime::spawn_blocking(move || {
+            resolve_run_target(&rid, ws.as_deref(), aid.as_deref())
+        })
+        .await
+        .map_err(|e| anyhow::anyhow!("spawn_blocking join failed: {e}"))?
+        {
+            Ok(a) => a,
+            Err(e) => {
+                let _ = channel.send(ScriptEvent::Error {
+                    message: e.to_string(),
+                });
+                return Ok(());
+            }
+        };
+
+        let process_type = run_script_type(&action.id);
+        // Per-action exclusive: same `script_type` ("run:<id>") across
+        // workspaces in the repo gets killed; different action ids are
+        // independent because the filter compares the full string.
+        if action.mode == "non-concurrent" {
+            manager.kill_others_in_repo(&repo_id, &process_type, workspace_id.as_deref());
+        }
+
+        return spawn_script(
+            app,
+            manager,
+            repo_id,
+            process_type,
+            workspace_id,
+            action.command,
+            channel,
+        )
+        .await;
+    }
+
     let scripts = tauri::async_runtime::spawn_blocking({
         let repo_id = repo_id.clone();
         let ws_id = workspace_id.clone();
@@ -25,7 +104,6 @@ pub async fn execute_repo_script(
 
     let script = match script_type.as_str() {
         "setup" => scripts.setup_script.clone(),
-        "run" => scripts.run_script.clone(),
         "archive" => scripts.archive_script.clone(),
         _ => None,
     };
@@ -37,13 +115,27 @@ pub async fn execute_repo_script(
         return Ok(());
     };
 
-    // Non-concurrent run mode: starting a run script stops any other live
-    // run script in the same repo first. Only applies to "run" — setup
-    // and archive each have their own one-off lifecycle.
-    if script_type == "run" && scripts.run_script_mode == "non-concurrent" {
-        manager.kill_others_in_repo(&repo_id, "run", workspace_id.as_deref());
-    }
+    spawn_script(
+        app,
+        manager,
+        repo_id,
+        script_type,
+        workspace_id,
+        script,
+        channel,
+    )
+    .await
+}
 
+async fn spawn_script(
+    app: AppHandle,
+    manager: State<'_, ScriptProcessManager>,
+    repo_id: String,
+    script_type: String,
+    workspace_id: Option<String>,
+    script: String,
+    channel: Channel<ScriptEvent>,
+) -> CmdResult<()> {
     let (repo, workspace) = tauri::async_runtime::spawn_blocking({
         let repo_id = repo_id.clone();
         let ws_id = workspace_id.clone();
@@ -98,6 +190,9 @@ pub async fn execute_repo_script(
     };
     let mgr = manager.inner().clone();
 
+    // Setup-completion hook keys on the literal `"setup"` script_type — run
+    // actions (which carry a `"run:<id>"` script_type now) never trigger it.
+    let is_setup = script_type == "setup";
     tauri::async_runtime::spawn_blocking(move || {
         match crate::workspace::scripts::run_script(
             &mgr,
@@ -109,7 +204,7 @@ pub async fn execute_repo_script(
             &context,
             channel.clone(),
         ) {
-            Ok(Some(0)) if script_type == "setup" => {
+            Ok(Some(0)) if is_setup => {
                 if let Some(ws_id) = &workspace_id {
                     if let Ok(ts) = crate::models::db::current_timestamp() {
                         let _ = crate::models::workspaces::mark_setup_completed(ws_id, &ts);
@@ -135,8 +230,10 @@ pub async fn stop_repo_script(
     repo_id: String,
     script_type: String,
     workspace_id: Option<String>,
+    action_id: Option<String>,
 ) -> CmdResult<bool> {
-    let key = (repo_id, script_type, workspace_id);
+    let process_type = process_type_for(&script_type, action_id.as_deref());
+    let key = (repo_id, process_type, workspace_id);
     Ok(manager.kill(&key))
 }
 
@@ -149,9 +246,11 @@ pub async fn write_repo_script_stdin(
     repo_id: String,
     script_type: String,
     workspace_id: Option<String>,
+    action_id: Option<String>,
     data: String,
 ) -> CmdResult<bool> {
-    let key = (repo_id, script_type, workspace_id);
+    let process_type = process_type_for(&script_type, action_id.as_deref());
+    let key = (repo_id, process_type, workspace_id);
     Ok(manager.write_stdin(&key, data.as_bytes())?)
 }
 
@@ -163,9 +262,127 @@ pub async fn resize_repo_script(
     repo_id: String,
     script_type: String,
     workspace_id: Option<String>,
+    action_id: Option<String>,
     cols: u16,
     rows: u16,
 ) -> CmdResult<bool> {
-    let key = (repo_id, script_type, workspace_id);
+    let process_type = process_type_for(&script_type, action_id.as_deref());
+    let key = (repo_id, process_type, workspace_id);
     Ok(manager.resize(&key, cols, rows)?)
 }
+
+/// Stop / write / resize need the SAME process-key shape `execute_repo_script`
+/// registered with. For "run" that means `"run:<id>"`; for any other
+/// script_type the original literal is used (`"setup"`, `"archive"`, or the
+/// terminal/agent-login UUID-namespaced strings).
+fn process_type_for(script_type: &str, action_id: Option<&str>) -> String {
+    if script_type == "run" {
+        if let Some(id) = action_id {
+            return run_script_type(id);
+        }
+    }
+    script_type.to_string()
+}
+
+#[tauri::command]
+pub async fn create_repo_run_action(
+    app: AppHandle,
+    repo_id: String,
+    name: String,
+    command: String,
+    mode: String,
+) -> CmdResult<repos::RunAction> {
+    let result = tauri::async_runtime::spawn_blocking({
+        let repo_id = repo_id.clone();
+        move || repos::create_repo_run_action(&repo_id, name.trim(), command.trim(), &mode)
+    })
+    .await
+    .map_err(|e| anyhow::anyhow!("spawn_blocking join failed: {e}"))??;
+
+    crate::ui_sync::publish(
+        &app,
+        crate::ui_sync::UiMutationEvent::RepoRunActionsChanged {
+            repo_id: repo_id.clone(),
+        },
+    );
+    Ok(result)
+}
+
+#[tauri::command]
+pub async fn update_repo_run_action(
+    app: AppHandle,
+    repo_id: String,
+    action_id: String,
+    name: String,
+    command: String,
+    mode: String,
+) -> CmdResult<()> {
+    tauri::async_runtime::spawn_blocking({
+        let action_id = action_id.clone();
+        move || repos::update_repo_run_action(&action_id, name.trim(), command.trim(), &mode)
+    })
+    .await
+    .map_err(|e| anyhow::anyhow!("spawn_blocking join failed: {e}"))??;
+
+    crate::ui_sync::publish(
+        &app,
+        crate::ui_sync::UiMutationEvent::RepoRunActionsChanged { repo_id },
+    );
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn delete_repo_run_action(
+    app: AppHandle,
+    repo_id: String,
+    action_id: String,
+) -> CmdResult<()> {
+    tauri::async_runtime::spawn_blocking({
+        let action_id = action_id.clone();
+        move || repos::delete_repo_run_action(&action_id)
+    })
+    .await
+    .map_err(|e| anyhow::anyhow!("spawn_blocking join failed: {e}"))??;
+
+    crate::ui_sync::publish(
+        &app,
+        crate::ui_sync::UiMutationEvent::RepoRunActionsChanged { repo_id },
+    );
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn reorder_repo_run_actions(
+    app: AppHandle,
+    repo_id: String,
+    ordered_ids: Vec<String>,
+) -> CmdResult<()> {
+    tauri::async_runtime::spawn_blocking({
+        let repo_id = repo_id.clone();
+        move || repos::reorder_repo_run_actions(&repo_id, &ordered_ids)
+    })
+    .await
+    .map_err(|e| anyhow::anyhow!("spawn_blocking join failed: {e}"))??;
+
+    crate::ui_sync::publish(
+        &app,
+        crate::ui_sync::UiMutationEvent::RepoRunActionsChanged { repo_id },
+    );
+    Ok(())
+}
+
+#[tauri::command]
+pub async fn set_workspace_active_run_action(
+    workspace_id: String,
+    action_id: Option<String>,
+) -> CmdResult<()> {
+    tauri::async_runtime::spawn_blocking(move || {
+        crate::models::workspaces::update_workspace_active_run_action(
+            &workspace_id,
+            action_id.as_deref(),
+        )
+    })
+    .await
+    .map_err(|e| anyhow::anyhow!("spawn_blocking join failed: {e}"))??;
+    Ok(())
+}

src-tauri/src/lib.rs

@@ -331,6 +331,11 @@ pub fn run() {
             commands::script_commands::stop_repo_script,
             commands::script_commands::write_repo_script_stdin,
             commands::script_commands::resize_repo_script,
+            commands::script_commands::create_repo_run_action,
+            commands::script_commands::update_repo_run_action,
+            commands::script_commands::delete_repo_run_action,
+            commands::script_commands::reorder_repo_run_actions,
+            commands::script_commands::set_workspace_active_run_action,
             commands::terminal_commands::spawn_terminal,
             commands::terminal_commands::stop_terminal,
             commands::terminal_commands::write_terminal_stdin,