fix: improve open-workspace errors and add daemon RPC parity tests

Author: Dimillian

memory/decisions.md

@@ -197,3 +197,10 @@ Type: preference
 Event: User selected Orbit-only path for mobile remote architecture and requested canonical plan updates away from custom Cloudflare bridge implementation.
 Action: Rewrote `docs/mobile-ios-cloudflare-blueprint.md` to Orbit-only architecture, setup flows, settings model, transport refactor, and implementation milestones; removed custom Worker/DO protocol/envelope sections.
 Rule: For current mobile rollout, plan and implementation should target Orbit integration only (hosted and self-host modes), not a custom bridge protocol/service.
+
+## 2026-02-07 17:39
+Context: Daemon parity hardening follow-up
+Type: decision
+Event: Added daemon-side RPC parity coverage for recently extracted workspace/prompts/local-usage adapters and improved open-app failure diagnostics.
+Action: Added RPC tests in `src-tauri/src/bin/codex_monitor_daemon.rs` for `add_clone`, `prompts_list`, and `local_usage_snapshot` routing; updated `open_workspace_in_core` in `src-tauri/src/shared/workspaces_core.rs` to include bounded stdout/stderr snippets in non-zero exit errors.
+Rule: Keep daemon adapter parity guarded by RPC-level tests for representative workspace/prompts/local-usage methods, and preserve process-output context in open-app failure errors.

src-tauri/src/bin/codex_monitor_daemon.rs

@@ -76,8 +76,8 @@ use backend::events::{AppServerEvent, EventSink, TerminalExit, TerminalOutput};
 use shared::codex_core::CodexLoginCancelState;
 use shared::prompts_core::{self, CustomPromptEntry};
 use shared::{
-    codex_aux_core, codex_core, files_core, git_core, git_ui_core, local_usage_core,
-    settings_core, workspaces_core, worktree_core,
+    codex_aux_core, codex_core, files_core, git_core, git_ui_core, local_usage_core, settings_core,
+    workspaces_core, worktree_core,
 };
 use storage::{read_settings, read_workspaces};
 use types::{
@@ -784,8 +784,13 @@ impl DaemonState {
         workspace_id: String,
         sha: String,
     ) -> Result<Vec<GitCommitDiff>, String> {
-        git_ui_core::get_git_commit_diff_core(&self.workspaces, &self.app_settings, workspace_id, sha)
-            .await
+        git_ui_core::get_git_commit_diff_core(
+            &self.workspaces,
+            &self.app_settings,
+            workspace_id,
+            sha,
+        )
+        .await
     }
 
     async fn get_git_remote(&self, workspace_id: String) -> Result<Option<String>, String> {
@@ -860,8 +865,12 @@ impl DaemonState {
         workspace_id: String,
         pr_number: u64,
     ) -> Result<Vec<GitHubPullRequestComment>, String> {
-        git_ui_core::get_github_pull_request_comments_core(&self.workspaces, workspace_id, pr_number)
-            .await
+        git_ui_core::get_github_pull_request_comments_core(
+            &self.workspaces,
+            workspace_id,
+            pr_number,
+        )
+        .await
     }
 
     async fn list_git_branches(&self, workspace_id: String) -> Result<Value, String> {
@@ -881,8 +890,12 @@ impl DaemonState {
     }
 
     async fn prompts_workspace_dir(&self, workspace_id: String) -> Result<String, String> {
-        prompts_core::prompts_workspace_dir_core(&self.workspaces, &self.settings_path, workspace_id)
-            .await
+        prompts_core::prompts_workspace_dir_core(
+            &self.workspaces,
+            &self.settings_path,
+            workspace_id,
+        )
+        .await
     }
 
     async fn prompts_global_dir(&self, workspace_id: String) -> Result<String, String> {
@@ -1104,7 +1117,6 @@ fn emit_background_thread_hide(event_sink: &DaemonEventSink, workspace_id: &str,
     });
 }
 
-
 fn send_notification_fallback_inner(title: String, body: String) -> Result<(), String> {
     #[cfg(all(target_os = "macos", debug_assertions))]
     {
@@ -2120,6 +2132,158 @@ async fn handle_client(
     write_task.abort();
 }
 
+#[cfg(test)]
+mod tests {
+    use super::*;
+    use crate::types::WorkspaceKind;
+    use serde_json::json;
+    use std::future::Future;
+    use std::path::PathBuf;
+    use std::time::{SystemTime, UNIX_EPOCH};
+
+    fn run_async_test<F>(future: F)
+    where
+        F: Future<Output = ()>,
+    {
+        tokio::runtime::Builder::new_current_thread()
+            .enable_all()
+            .build()
+            .expect("runtime")
+            .block_on(future);
+    }
+
+    fn make_temp_dir(prefix: &str) -> PathBuf {
+        let unique = SystemTime::now()
+            .duration_since(UNIX_EPOCH)
+            .expect("time")
+            .as_nanos();
+        let dir = std::env::temp_dir().join(format!(
+            "codex-monitor-{prefix}-{}-{unique}",
+            std::process::id()
+        ));
+        std::fs::create_dir_all(&dir).expect("create temp dir");
+        dir
+    }
+
+    fn test_state(data_dir: &std::path::Path) -> DaemonState {
+        let (tx, _rx) = broadcast::channel::<DaemonEvent>(32);
+        DaemonState {
+            data_dir: data_dir.to_path_buf(),
+            workspaces: Mutex::new(HashMap::new()),
+            sessions: Mutex::new(HashMap::new()),
+            storage_path: data_dir.join("workspaces.json"),
+            settings_path: data_dir.join("settings.json"),
+            app_settings: Mutex::new(AppSettings::default()),
+            event_sink: DaemonEventSink { tx },
+            codex_login_cancels: Mutex::new(HashMap::new()),
+        }
+    }
+
+    async fn insert_workspace(state: &DaemonState, workspace_id: &str, workspace_path: &str) {
+        let entry = WorkspaceEntry {
+            id: workspace_id.to_string(),
+            name: "Workspace".to_string(),
+            path: workspace_path.to_string(),
+            codex_bin: None,
+            kind: WorkspaceKind::Main,
+            parent_id: None,
+            worktree: None,
+            settings: WorkspaceSettings {
+                codex_home: Some(format!("{workspace_path}/.codex-home")),
+                ..WorkspaceSettings::default()
+            },
+        };
+        state
+            .workspaces
+            .lock()
+            .await
+            .insert(workspace_id.to_string(), entry);
+    }
+
+    #[test]
+    fn rpc_add_clone_uses_workspace_core_validation() {
+        run_async_test(async {
+            let tmp = make_temp_dir("rpc-add-clone");
+            let state = test_state(&tmp);
+
+            let err = handle_rpc_request(
+                &state,
+                "add_clone",
+                json!({
+                    "sourceWorkspaceId": "source",
+                    "copiesFolder": tmp.to_string_lossy().to_string(),
+                    "copyName": "   "
+                }),
+                "daemon-test".to_string(),
+            )
+            .await
+            .expect_err("expected validation error");
+
+            assert_eq!(err, "Copy name is required.");
+            let _ = std::fs::remove_dir_all(&tmp);
+        });
+    }
+
+    #[test]
+    fn rpc_prompts_list_reads_workspace_prompts() {
+        run_async_test(async {
+            let tmp = make_temp_dir("rpc-prompts-list");
+            let workspace_id = "ws-prompts";
+            let workspace_dir = tmp.join("workspace");
+            std::fs::create_dir_all(&workspace_dir).expect("create workspace dir");
+
+            let state = test_state(&tmp);
+            insert_workspace(&state, workspace_id, &workspace_dir.to_string_lossy()).await;
+
+            let prompts_dir = tmp.join("workspaces").join(workspace_id).join("prompts");
+            std::fs::create_dir_all(&prompts_dir).expect("create prompts dir");
+            std::fs::write(prompts_dir.join("review.md"), "Prompt body").expect("write prompt");
+
+            let result = handle_rpc_request(
+                &state,
+                "prompts_list",
+                json!({ "workspaceId": workspace_id }),
+                "daemon-test".to_string(),
+            )
+            .await
+            .expect("prompts_list should succeed");
+
+            let prompts = result.as_array().expect("array result");
+            assert!(
+                prompts.iter().any(|entry| {
+                    entry
+                        .get("name")
+                        .and_then(Value::as_str)
+                        .is_some_and(|name| name == "review")
+                }),
+                "expected prompts_list to include workspace prompt"
+            );
+            let _ = std::fs::remove_dir_all(&tmp);
+        });
+    }
+
+    #[test]
+    fn rpc_local_usage_snapshot_returns_snapshot_shape() {
+        run_async_test(async {
+            let tmp = make_temp_dir("rpc-local-usage");
+            let state = test_state(&tmp);
+
+            let result = handle_rpc_request(
+                &state,
+                "local_usage_snapshot",
+                json!({ "days": 7 }),
+                "daemon-test".to_string(),
+            )
+            .await
+            .expect("local_usage_snapshot should succeed");
+
+            assert!(result.get("days").and_then(Value::as_array).is_some());
+            assert!(result.get("totals").is_some());
+            let _ = std::fs::remove_dir_all(&tmp);
+        });
+    }
+}
+
 fn main() {
     let config = match parse_args() {
         Ok(config) => config,

src-tauri/src/codex/mod.rs

@@ -8,9 +8,9 @@ pub(crate) mod args;
 pub(crate) mod config;
 pub(crate) mod home;
 
+use crate::backend::app_server::spawn_workspace_session as spawn_workspace_session_inner;
 pub(crate) use crate::backend::app_server::WorkspaceSession;
 use crate::backend::events::AppServerEvent;
-use crate::backend::app_server::spawn_workspace_session as spawn_workspace_session_inner;
 use crate::event_sink::TauriEventSink;
 use crate::remote_backend;
 use crate::shared::codex_core;
@@ -411,12 +411,7 @@ pub(crate) async fn codex_login(
         .await;
     }
 
-    codex_core::codex_login_core(
-        &state.sessions,
-        &state.codex_login_cancels,
-        workspace_id,
-    )
-    .await
+    codex_core::codex_login_core(&state.sessions, &state.codex_login_cancels, workspace_id).await
 }
 
 #[tauri::command]
@@ -515,7 +510,9 @@ pub(crate) async fn get_commit_message_prompt(
         return Err("No changes to generate commit message for".to_string());
     }
 
-    Ok(crate::shared::codex_aux_core::build_commit_message_prompt(&diff))
+    Ok(crate::shared::codex_aux_core::build_commit_message_prompt(
+        &diff,
+    ))
 }
 
 #[tauri::command]

src-tauri/src/git/mod.rs

@@ -113,9 +113,11 @@ pub(crate) async fn get_workspace_diff(
     workspace_id: &str,
     state: &State<'_, AppState>,
 ) -> Result<String, String> {
-    let repo_root =
-        git_ui_core::resolve_repo_root_for_workspace_core(&state.workspaces, workspace_id.to_string())
-            .await?;
+    let repo_root = git_ui_core::resolve_repo_root_for_workspace_core(
+        &state.workspaces,
+        workspace_id.to_string(),
+    )
+    .await?;
     git_ui_core::collect_workspace_diff_core(&repo_root)
 }
 

src-tauri/src/shared/codex_aux_core.rs

@@ -129,7 +129,9 @@ pub(crate) async fn codex_doctor_core(
     command.stdout(std::process::Stdio::piped());
     command.stderr(std::process::Stdio::piped());
     let app_server_ok = match timeout(Duration::from_secs(5), command.output()).await {
-        Ok(result) => result.map(|output| output.status.success()).unwrap_or(false),
+        Ok(result) => result
+            .map(|output| output.status.success())
+            .unwrap_or(false),
         Err(_) => false,
     };
     let (node_ok, node_version, node_details) = {
@@ -181,7 +183,11 @@ pub(crate) async fn codex_doctor_core(
                     }
                 }
             },
-            Err(_) => (false, None, Some("Timed out while checking Node.".to_string())),
+            Err(_) => (
+                false,
+                None,
+                Some("Timed out while checking Node.".to_string()),
+            ),
         }
     };
     let details = if app_server_ok {

src-tauri/src/shared/local_usage_core.rs

@@ -282,10 +282,11 @@ fn scan_file(
                 continue;
             }
 
-            let info = payload.and_then(|payload| payload.get("info")).and_then(|v| v.as_object());
+            let info = payload
+                .and_then(|payload| payload.get("info"))
+                .and_then(|v| v.as_object());
             let (input, cached, output, used_total) = if let Some(info) = info {
-                if let Some(total) =
-                    find_usage_map(info, &["total_token_usage", "totalTokenUsage"])
+                if let Some(total) = find_usage_map(info, &["total_token_usage", "totalTokenUsage"])
                 {
                     (
                         read_i64(total, &["input_tokens", "inputTokens"]),
@@ -338,7 +339,11 @@ fn scan_file(
                     cached: (cached - prev.cached).max(0),
                     output: (output - prev.output).max(0),
                 };
-                previous_totals = Some(UsageTotals { input, cached, output });
+                previous_totals = Some(UsageTotals {
+                    input,
+                    cached,
+                    output,
+                });
             } else {
                 // Some streams emit `last_token_usage` deltas between `total_token_usage` snapshots.
                 // Treat those as already-counted to avoid double-counting when the next total arrives.
@@ -443,7 +448,11 @@ fn find_usage_map<'a>(
 fn read_i64(map: &serde_json::Map<String, Value>, keys: &[&str]) -> i64 {
     keys.iter()
         .find_map(|key| map.get(*key))
-        .and_then(|value| value.as_i64().or_else(|| value.as_f64().map(|value| value as i64)))
+        .and_then(|value| {
+            value
+                .as_i64()
+                .or_else(|| value.as_f64().map(|value| value as i64))
+        })
         .unwrap_or(0)
 }
 
@@ -523,7 +532,9 @@ fn resolve_sessions_roots(
     if let Some(workspace_path) = workspace_path {
         let codex_home_override =
             resolve_workspace_codex_home_for_path(workspaces, Some(workspace_path));
-        return resolve_codex_sessions_root(codex_home_override).into_iter().collect();
+        return resolve_codex_sessions_root(codex_home_override)
+            .into_iter()
+            .collect();
     }
 
     let mut roots = Vec::new();
@@ -607,10 +618,7 @@ mod tests {
 
     fn make_temp_sessions_root() -> PathBuf {
         let mut root = std::env::temp_dir();
-        root.push(format!(
-            "codexmonitor-local-usage-root-{}",
-            Uuid::new_v4()
-        ));
+        root.push(format!("codexmonitor-local-usage-root-{}", Uuid::new_v4()));
         fs::create_dir_all(&root).expect("create temp root");
         root
     }
@@ -765,11 +773,9 @@ mod tests {
             .last()
             .cloned()
             .unwrap_or_else(|| Local::now().format("%Y-%m-%d").to_string());
-        let naive = NaiveDateTime::parse_from_str(
-            &format!("{day_key} 12:00:00"),
-            "%Y-%m-%d %H:%M:%S",
-        )
-        .expect("timestamp");
+        let naive =
+            NaiveDateTime::parse_from_str(&format!("{day_key} 12:00:00"), "%Y-%m-%d %H:%M:%S")
+                .expect("timestamp");
         let timestamp_ms = Local
             .from_local_datetime(&naive)
             .single()

src-tauri/src/shared/mod.rs

@@ -8,5 +8,5 @@ pub(crate) mod local_usage_core;
 pub(crate) mod process_core;
 pub(crate) mod prompts_core;
 pub(crate) mod settings_core;
-pub(crate) mod worktree_core;
 pub(crate) mod workspaces_core;
+pub(crate) mod worktree_core;