Function get_path_metadata

src/apps/desktop/src/api/path_target.rs:299–349

(
    app_state: &AppState,
    raw_path: &str,
)

}

pub async fn get_path_metadata(
    app_state: &AppState,
    raw_path: &str,
) -> Result<serde_json::Value, String> {
    match resolve_desktop_path_target(app_state, raw_path, None).await? {
        DesktopPathTarget::Local {
            requested_path,
            resolved_path,
            is_runtime_artifact,
        } => {
            let metadata =
                stat_local_path_metadata(&requested_path, &resolved_path, is_runtime_artifact)?;
            serde_json::to_value(metadata)
                .map_err(|e| format!("Failed to serialize file metadata: {}", e))
        }
        DesktopPathTarget::Remote {
            requested_path,
            entry,
        } => {
            let remote_fs = app_state
                .get_remote_file_service_async()
                .await
                .map_err(|e| format!("Remote file service not available: {}", e))?;

            let stat_entry = remote_fs
                .stat(&entry.connection_id, &requested_path)
                .await
                .map_err(|e| format!("Failed to stat remote file: {}", e))?;

            let (is_file, is_dir, size, modified) = match stat_entry {
                Some(entry) => (
                    entry.is_file,
                    entry.is_dir,
                    entry.size.unwrap_or(0),
                    entry.modified.unwrap_or(0),
                ),
                None => (false, false, 0, 0),
            };

            serde_json::to_value(RemoteFileMetadata {
                path: requested_path,
                modified,
                size,
                is_file,
                is_dir,
                is_remote: true,
            })
            .map_err(|e| format!("Failed to serialize remote file metadata: {}", e))
        }
    }
}

pub async fn rename_path(
    app_state: &AppState,