fix: support tilde paths and persistent recent dirs in mobile add-workspaces (Dimillian#512)

Author: vforsh

docs/screenshots/SCR-20260225-jjrk.png

@@ -137,7 +137,7 @@ fn join_env_path(prefix: &str, remainder: &str) -> PathBuf {
     }
 }
 
-fn resolve_home_dir() -> Option<PathBuf> {
+pub(crate) fn resolve_home_dir() -> Option<PathBuf> {
     if let Ok(value) = env::var("HOME") {
         if !value.trim().is_empty() {
             return Some(PathBuf::from(value));
@@ -148,6 +148,24 @@ fn resolve_home_dir() -> Option<PathBuf> {
             return Some(PathBuf::from(value));
         }
     }
+    #[cfg(unix)]
+    {
+        // Fallback for daemon environments that do not expose HOME.
+        unsafe {
+            let uid = libc::geteuid();
+            let pwd = libc::getpwuid(uid);
+            if !pwd.is_null() {
+                let dir_ptr = (*pwd).pw_dir;
+                if !dir_ptr.is_null() {
+                    if let Ok(dir) = std::ffi::CStr::from_ptr(dir_ptr).to_str() {
+                        if !dir.trim().is_empty() {
+                            return Some(PathBuf::from(dir));
+                        }
+                    }
+                }
+            }
+        }
+    }
     None
 }
 

src-tauri/src/codex/home.rs

@@ -15,7 +15,7 @@ use crate::storage::write_workspaces;
 use crate::types::{AppSettings, WorkspaceEntry, WorkspaceInfo, WorkspaceKind, WorkspaceSettings};
 
 use super::connect::{kill_session_by_id, take_live_shared_session, workspace_session_spawn_lock};
-use super::helpers::normalize_setup_script;
+use super::helpers::{normalize_setup_script, normalize_workspace_path_input};
 
 pub(crate) async fn add_workspace_core<F, Fut>(
     path: String,
@@ -29,9 +29,11 @@ where
     F: Fn(WorkspaceEntry, Option<String>, Option<String>, Option<PathBuf>) -> Fut,
     Fut: Future<Output = Result<Arc<WorkspaceSession>, String>>,
 {
-    if !PathBuf::from(&path).is_dir() {
+    let normalized_path = normalize_workspace_path_input(&path);
+    if !normalized_path.is_dir() {
         return Err("Workspace path must be a folder.".to_string());
     }
+    let path = normalized_path.to_string_lossy().to_string();
 
     let name = PathBuf::from(&path)
         .file_name()

src-tauri/src/shared/workspaces_core/crud_persistence.rs

@@ -63,7 +63,22 @@ pub(crate) fn worktree_setup_marker_path(data_dir: &PathBuf, workspace_id: &str)
 }
 
 pub(crate) fn is_workspace_path_dir_core(path: &str) -> bool {
-    PathBuf::from(path).is_dir()
+    normalize_workspace_path_input(path).is_dir()
+}
+
+pub(crate) fn normalize_workspace_path_input(path: &str) -> PathBuf {
+    let trimmed = path.trim();
+    if let Some(rest) = trimmed.strip_prefix("~/") {
+        if let Some(home) = crate::codex::home::resolve_home_dir() {
+            return home.join(rest);
+        }
+    }
+    if trimmed == "~" {
+        if let Some(home) = crate::codex::home::resolve_home_dir() {
+            return home;
+        }
+    }
+    PathBuf::from(trimmed)
 }
 
 pub(crate) async fn list_workspaces_core(
@@ -131,9 +146,15 @@ pub(super) fn sort_workspaces(workspaces: &mut [WorkspaceInfo]) {
 
 #[cfg(test)]
 mod tests {
-    use super::{copy_agents_md_from_parent_to_worktree, AGENTS_MD_FILE_NAME};
+    use super::{
+        copy_agents_md_from_parent_to_worktree, normalize_workspace_path_input, AGENTS_MD_FILE_NAME,
+    };
+    use std::path::PathBuf;
+    use std::sync::Mutex;
     use uuid::Uuid;
 
+    static ENV_LOCK: Mutex<()> = Mutex::new(());
+
     fn make_temp_dir() -> std::path::PathBuf {
         let dir = std::env::temp_dir().join(format!("codex-monitor-{}", Uuid::new_v4()));
         std::fs::create_dir_all(&dir).expect("failed to create temp dir");
@@ -179,4 +200,21 @@ mod tests {
         let _ = std::fs::remove_dir_all(parent);
         let _ = std::fs::remove_dir_all(worktree);
     }
+
+    #[test]
+    fn normalize_workspace_path_input_expands_home_prefix() {
+        let _guard = ENV_LOCK.lock().expect("lock env");
+        let previous_home = std::env::var("HOME").ok();
+        std::env::set_var("HOME", "/tmp/cm-home");
+
+        assert_eq!(
+            normalize_workspace_path_input("~/dev/repo"),
+            PathBuf::from("/tmp/cm-home/dev/repo")
+        );
+
+        match previous_home {
+            Some(value) => std::env::set_var("HOME", value),
+            None => std::env::remove_var("HOME"),
+        }
+    }
 }

src-tauri/src/shared/workspaces_core/helpers.rs

@@ -236,6 +236,7 @@ function MainApp() {
     addWorkspacesFromPaths,
     mobileRemoteWorkspacePathPrompt,
     updateMobileRemoteWorkspacePathInput,
+    appendMobileRemoteWorkspacePathFromRecent,
     cancelMobileRemoteWorkspacePathPrompt,
     submitMobileRemoteWorkspacePathPrompt,
     addCloneAgent,
@@ -2710,6 +2711,9 @@ function MainApp() {
         onWorkspaceFromUrlPromptConfirm={submitWorkspaceFromUrlPrompt}
         mobileRemoteWorkspacePathPrompt={mobileRemoteWorkspacePathPrompt}
         onMobileRemoteWorkspacePathPromptChange={updateMobileRemoteWorkspacePathInput}
+        onMobileRemoteWorkspacePathPromptRecentPathSelect={
+          appendMobileRemoteWorkspacePathFromRecent
+        }
         onMobileRemoteWorkspacePathPromptCancel={cancelMobileRemoteWorkspacePathPrompt}
         onMobileRemoteWorkspacePathPromptConfirm={submitMobileRemoteWorkspacePathPrompt}
         branchSwitcher={branchSwitcher}

src/App.tsx

@@ -56,6 +56,7 @@ type WorkspaceFromUrlPromptState = ReturnType<
 type MobileRemoteWorkspacePathPromptState = {
   value: string;
   error: string | null;
+  recentPaths: string[];
 } | null;
 
 type AppModalsProps = {
@@ -102,6 +103,7 @@ type AppModalsProps = {
   onWorkspaceFromUrlPromptConfirm: () => void;
   mobileRemoteWorkspacePathPrompt: MobileRemoteWorkspacePathPromptState;
   onMobileRemoteWorkspacePathPromptChange: (value: string) => void;
+  onMobileRemoteWorkspacePathPromptRecentPathSelect: (path: string) => void;
   onMobileRemoteWorkspacePathPromptCancel: () => void;
   onMobileRemoteWorkspacePathPromptConfirm: () => void;
   branchSwitcher: BranchSwitcherState;
@@ -155,6 +157,7 @@ export const AppModals = memo(function AppModals({
   onWorkspaceFromUrlPromptConfirm,
   mobileRemoteWorkspacePathPrompt,
   onMobileRemoteWorkspacePathPromptChange,
+  onMobileRemoteWorkspacePathPromptRecentPathSelect,
   onMobileRemoteWorkspacePathPromptCancel,
   onMobileRemoteWorkspacePathPromptConfirm,
   branchSwitcher,
@@ -270,7 +273,9 @@ export const AppModals = memo(function AppModals({
           <MobileRemoteWorkspacePrompt
             value={mobileRemoteWorkspacePathPrompt.value}
             error={mobileRemoteWorkspacePathPrompt.error}
+            recentPaths={mobileRemoteWorkspacePathPrompt.recentPaths}
             onChange={onMobileRemoteWorkspacePathPromptChange}
+            onRecentPathSelect={onMobileRemoteWorkspacePathPromptRecentPathSelect}
             onCancel={onMobileRemoteWorkspacePathPromptCancel}
             onConfirm={onMobileRemoteWorkspacePathPromptConfirm}
           />

src/features/app/components/AppModals.tsx

@@ -70,6 +70,7 @@ describe("useWorkspaceController dialogs", () => {
   beforeEach(() => {
     vi.clearAllMocks();
     vi.mocked(isMobilePlatform).mockReturnValue(false);
+    window.localStorage.clear();
   });
 
   it("shows add-workspaces summary in controller layer", async () => {
@@ -176,5 +177,99 @@ describe("useWorkspaceController dialogs", () => {
     expect(added).toMatchObject({ id: workspaceOne.id });
     expect(isWorkspacePathDir).toHaveBeenCalledWith("/srv/codex-monitor");
     expect(result.current.mobileRemoteWorkspacePathPrompt).toBeNull();
+    expect(window.localStorage.getItem("mobile-remote-workspace-recent-paths")).toBe(
+      JSON.stringify(["/tmp/ws-1"]),
+    );
+  });
+
+  it("appends selected recent path only when missing", async () => {
+    vi.mocked(isMobilePlatform).mockReturnValue(true);
+    window.localStorage.setItem(
+      "mobile-remote-workspace-recent-paths",
+      JSON.stringify(["/srv/one", "/srv/two"]),
+    );
+    vi.mocked(listWorkspaces).mockResolvedValue([]);
+
+    const { result } = renderHook(() =>
+      useWorkspaceController({
+        appSettings: {
+          ...baseAppSettings,
+          backendMode: "remote",
+        },
+        addDebugEntry: vi.fn(),
+        queueSaveSettings: vi.fn(async (next) => next),
+      }),
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    await act(async () => {
+      void result.current.addWorkspace();
+    });
+
+    expect(result.current.mobileRemoteWorkspacePathPrompt?.recentPaths).toEqual([
+      "/srv/one",
+      "/srv/two",
+    ]);
+
+    await act(async () => {
+      result.current.appendMobileRemoteWorkspacePathFromRecent("/srv/one");
+    });
+    expect(result.current.mobileRemoteWorkspacePathPrompt?.value).toBe("/srv/one");
+
+    await act(async () => {
+      result.current.appendMobileRemoteWorkspacePathFromRecent("/srv/one");
+    });
+    expect(result.current.mobileRemoteWorkspacePathPrompt?.value).toBe("/srv/one");
+
+    await act(async () => {
+      result.current.appendMobileRemoteWorkspacePathFromRecent("/srv/two");
+    });
+    expect(result.current.mobileRemoteWorkspacePathPrompt?.value).toBe(
+      "/srv/one\n/srv/two",
+    );
+  });
+
+  it("accepts quoted mobile remote paths", async () => {
+    vi.mocked(isMobilePlatform).mockReturnValue(true);
+    vi.mocked(listWorkspaces).mockResolvedValue([]);
+    vi.mocked(isWorkspacePathDir).mockResolvedValue(true);
+    vi.mocked(addWorkspace).mockResolvedValue(workspaceOne);
+
+    const { result } = renderHook(() =>
+      useWorkspaceController({
+        appSettings: {
+          ...baseAppSettings,
+          backendMode: "remote",
+        },
+        addDebugEntry: vi.fn(),
+        queueSaveSettings: vi.fn(async (next) => next),
+      }),
+    );
+
+    await act(async () => {
+      await Promise.resolve();
+    });
+
+    let addPromise: Promise<WorkspaceInfo | null> = Promise.resolve(null);
+    await act(async () => {
+      addPromise = result.current.addWorkspace();
+    });
+
+    await act(async () => {
+      result.current.updateMobileRemoteWorkspacePathInput("'~/dev/personal'");
+    });
+
+    await act(async () => {
+      result.current.submitMobileRemoteWorkspacePathPrompt();
+    });
+
+    await act(async () => {
+      await addPromise;
+    });
+
+    expect(isWorkspacePathDir).toHaveBeenCalledWith("~/dev/personal");
   });
 });

src/features/app/hooks/useWorkspaceController.test.tsx

@@ -3,6 +3,7 @@ import { useWorkspaces } from "../../workspaces/hooks/useWorkspaces";
 import type { AppSettings, WorkspaceInfo } from "../../../types";
 import type { DebugEntry } from "../../../types";
 import { useWorkspaceDialogs } from "./useWorkspaceDialogs";
+import { isMobilePlatform } from "../../../utils/platformPaths";
 
 type WorkspaceControllerOptions = {
   appSettings: AppSettings;
@@ -34,29 +35,52 @@ export function useWorkspaceController({
     updateMobileRemoteWorkspacePathInput,
     cancelMobileRemoteWorkspacePathPrompt,
     submitMobileRemoteWorkspacePathPrompt,
+    appendMobileRemoteWorkspacePathFromRecent,
+    rememberRecentMobileRemoteWorkspacePaths,
     showAddWorkspacesResult,
     confirmWorkspaceRemoval,
     confirmWorktreeRemoval,
     showWorkspaceRemovalError,
     showWorktreeRemovalError,
   } = useWorkspaceDialogs();
 
-  const addWorkspacesFromPaths = useCallback(
-    async (paths: string[]): Promise<WorkspaceInfo | null> => {
+  const runAddWorkspacesFromPaths = useCallback(
+    async (
+      paths: string[],
+      options?: { rememberMobileRemoteRecents?: boolean },
+    ) => {
       const result = await addWorkspacesFromPathsCore(paths);
       await showAddWorkspacesResult(result);
+      if (options?.rememberMobileRemoteRecents && result.added.length > 0) {
+        rememberRecentMobileRemoteWorkspacePaths(result.added.map((entry) => entry.path));
+      }
+      return result;
+    },
+    [
+      addWorkspacesFromPathsCore,
+      rememberRecentMobileRemoteWorkspacePaths,
+      showAddWorkspacesResult,
+    ],
+  );
+
+  const addWorkspacesFromPaths = useCallback(
+    async (paths: string[]): Promise<WorkspaceInfo | null> => {
+      const result = await runAddWorkspacesFromPaths(paths);
       return result.firstAdded;
     },
-    [addWorkspacesFromPathsCore, showAddWorkspacesResult],
+    [runAddWorkspacesFromPaths],
   );
 
   const addWorkspace = useCallback(async (): Promise<WorkspaceInfo | null> => {
     const paths = await requestWorkspacePaths(appSettings.backendMode);
     if (paths.length === 0) {
       return null;
     }
-    return addWorkspacesFromPaths(paths);
-  }, [addWorkspacesFromPaths, appSettings.backendMode, requestWorkspacePaths]);
+    const result = await runAddWorkspacesFromPaths(paths, {
+      rememberMobileRemoteRecents: isMobilePlatform() && appSettings.backendMode === "remote",
+    });
+    return result.firstAdded;
+  }, [appSettings.backendMode, requestWorkspacePaths, runAddWorkspacesFromPaths]);
 
   const removeWorkspace = useCallback(
     async (workspaceId: string) => {
@@ -96,6 +120,7 @@ export function useWorkspaceController({
     updateMobileRemoteWorkspacePathInput,
     cancelMobileRemoteWorkspacePathPrompt,
     submitMobileRemoteWorkspacePathPrompt,
+    appendMobileRemoteWorkspacePathFromRecent,
     removeWorkspace,
     removeWorktree,
   };