clawdex-mobile 5.0.8 → 5.1.2

package/services/rust-bridge/src/services/git.rs

@@ -4,9 +4,9 @@ use std::{
 };
 
 use crate::{
-    normalize_path, BridgeError, GitCommitResponse, GitDiffResponse, GitPushResponse,
-    GitStageAllResponse, GitStageResponse, GitStatusEntry, GitStatusResponse,
-    GitUnstageAllResponse, GitUnstageResponse,
+    normalize_path, BridgeError, GitCloneResponse, GitCommitResponse, GitDiffResponse,
+    GitHistoryCommit, GitHistoryResponse, GitPushResponse, GitStageAllResponse, GitStageResponse,
+    GitStatusEntry, GitStatusResponse, GitUnstageAllResponse, GitUnstageResponse,
 };
 
 use super::TerminalService;
@@ -196,6 +196,96 @@ impl GitService {
         })
     }
 
+    pub(crate) async fn get_history(
+        &self,
+        raw_cwd: Option<&str>,
+        limit: Option<usize>,
+    ) -> Result<GitHistoryResponse, BridgeError> {
+        let repo_path = self.resolve_repo_path(raw_cwd)?;
+        let history_limit = limit.unwrap_or(12).clamp(1, 30);
+        let args = vec![
+            "-C".to_string(),
+            repo_path.to_string_lossy().to_string(),
+            "log".to_string(),
+            "--first-parent".to_string(),
+            "--decorate=short".to_string(),
+            "--date=iso-strict".to_string(),
+            format!("--max-count={history_limit}"),
+            "--pretty=format:%H\x1f%h\x1f%an\x1f%aI\x1f%D\x1f%s\x1e".to_string(),
+            "HEAD".to_string(),
+        ];
+
+        let result = self
+            .terminal
+            .execute_binary("git", &args, repo_path.clone(), None)
+            .await?;
+
+        if result.code != Some(0) {
+            return Err(BridgeError::server(
+                &(if !result.stderr.is_empty() {
+                    result.stderr
+                } else if !result.stdout.is_empty() {
+                    result.stdout
+                } else {
+                    "git log failed".to_string()
+                }),
+            ));
+        }
+
+        Ok(GitHistoryResponse {
+            commits: parse_git_history(&result.stdout),
+            cwd: repo_path.to_string_lossy().to_string(),
+        })
+    }
+
+    pub(crate) async fn clone_repo(
+        &self,
+        repository_url: &str,
+        raw_parent_path: Option<&str>,
+        directory_name: &str,
+    ) -> Result<GitCloneResponse, BridgeError> {
+        let parent_path = self.resolve_repo_path(raw_parent_path)?;
+        if !parent_path.exists() {
+            return Err(BridgeError::invalid_params(
+                "destination parent path must exist",
+            ));
+        }
+        if !parent_path.is_dir() {
+            return Err(BridgeError::invalid_params(
+                "destination parent path must be a directory",
+            ));
+        }
+
+        let normalized_directory_name = resolve_clone_directory_name(directory_name)?;
+        let destination_path = normalize_path(&parent_path.join(&normalized_directory_name));
+        if destination_path.exists() {
+            return Err(BridgeError::invalid_params(
+                "destination path already exists",
+            ));
+        }
+
+        let args = vec![
+            "clone".to_string(),
+            "--".to_string(),
+            repository_url.trim().to_string(),
+            normalized_directory_name,
+        ];
+
+        let result = self
+            .terminal
+            .execute_binary("git", &args, parent_path.clone(), None)
+            .await?;
+
+        Ok(GitCloneResponse {
+            code: result.code,
+            stdout: result.stdout,
+            stderr: result.stderr,
+            cloned: result.code == Some(0),
+            cwd: destination_path.to_string_lossy().to_string(),
+            url: repository_url.trim().to_string(),
+        })
+    }
+
     pub(crate) async fn stage_file(
         &self,
         path: &str,
@@ -549,6 +639,49 @@ fn parse_status_has_upstream(raw: &str) -> bool {
         .unwrap_or(false)
 }
 
+fn parse_git_history(raw: &str) -> Vec<GitHistoryCommit> {
+    raw.split('\x1e')
+        .filter_map(|record| {
+            let trimmed = record.trim();
+            if trimmed.is_empty() {
+                return None;
+            }
+
+            let mut parts = trimmed.split('\x1f');
+            let hash = parts.next()?.trim().to_string();
+            let short_hash = parts.next().unwrap_or_default().trim().to_string();
+            let author_name = parts.next().unwrap_or_default().trim().to_string();
+            let authored_at = parts.next().unwrap_or_default().trim().to_string();
+            let refs_raw = parts.next().unwrap_or_default().trim().to_string();
+            let subject = parts.next().unwrap_or_default().trim().to_string();
+
+            if hash.is_empty() || short_hash.is_empty() || subject.is_empty() {
+                return None;
+            }
+
+            let ref_names = refs_raw
+                .split(',')
+                .map(str::trim)
+                .filter(|entry| !entry.is_empty())
+                .map(str::to_string)
+                .collect::<Vec<_>>();
+            let is_head = ref_names
+                .iter()
+                .any(|entry| entry == "HEAD" || entry.starts_with("HEAD ->"));
+
+            Some(GitHistoryCommit {
+                hash,
+                short_hash,
+                subject,
+                author_name,
+                authored_at,
+                ref_names,
+                is_head,
+            })
+        })
+        .collect()
+}
+
 fn select_default_remote_name(raw: &str) -> Option<String> {
     let remotes = raw
         .lines()
@@ -626,11 +759,47 @@ fn resolve_repo_relative_path(raw_path: &str, repo_path: &Path) -> Result<String
     Ok(relative.to_string_lossy().to_string())
 }
 
+fn resolve_clone_directory_name(raw_name: &str) -> Result<String, BridgeError> {
+    let trimmed = raw_name.trim();
+    if trimmed.is_empty() {
+        return Err(BridgeError::invalid_params(
+            "directoryName must not be empty",
+        ));
+    }
+
+    let requested = PathBuf::from(trimmed);
+    if requested.is_absolute() {
+        return Err(BridgeError::invalid_params(
+            "directoryName must be a folder name, not a path",
+        ));
+    }
+
+    let mut components = requested.components();
+    let Some(component) = components.next() else {
+        return Err(BridgeError::invalid_params(
+            "directoryName must not be empty",
+        ));
+    };
+    if components.next().is_some() {
+        return Err(BridgeError::invalid_params(
+            "directoryName must be a single folder name",
+        ));
+    }
+    if !matches!(component, std::path::Component::Normal(_)) {
+        return Err(BridgeError::invalid_params(
+            "directoryName must be a valid folder name",
+        ));
+    }
+
+    Ok(trimmed.to_string())
+}
+
 #[cfg(test)]
 mod tests {
     use super::{
-        parse_porcelain_status_entries, parse_status_has_upstream, resolve_git_cwd,
-        resolve_repo_relative_path, select_default_remote_name,
+        parse_git_history, parse_porcelain_status_entries, parse_status_has_upstream,
+        resolve_clone_directory_name, resolve_git_cwd, resolve_repo_relative_path,
+        select_default_remote_name,
     };
     use std::path::{Path, PathBuf};
 
@@ -685,6 +854,20 @@ mod tests {
         assert_eq!(error.code, -32602);
     }
 
+    #[test]
+    fn resolves_clone_directory_name_from_single_segment() {
+        let resolved =
+            resolve_clone_directory_name("my-repo").expect("resolve single directory name");
+        assert_eq!(resolved, "my-repo");
+    }
+
+    #[test]
+    fn rejects_nested_clone_directory_name() {
+        let error = resolve_clone_directory_name("nested/repo")
+            .expect_err("reject nested clone directory name");
+        assert_eq!(error.code, -32602);
+    }
+
     #[test]
     fn parses_porcelain_entries_for_rename_and_untracked() {
         let raw = "## main...origin/main\0R  new/path.ts\0old/path.ts\0?? fresh/file.ts\0";
@@ -729,4 +912,27 @@ mod tests {
         );
         assert_eq!(select_default_remote_name(""), None);
     }
+
+    #[test]
+    fn parses_git_history_records() {
+        let raw = concat!(
+            "abc123\x1fabc123\x1fMohit\x1f2026-04-05T10:00:00+05:30\x1fHEAD -> feat/test, origin/feat/test\x1fAdd history card\x1e",
+            "def456\x1fdef456\x1fMohit\x1f2026-04-04T09:00:00+05:30\x1forigin/main\x1fPrevious commit\x1e"
+        );
+
+        let commits = parse_git_history(raw);
+        assert_eq!(commits.len(), 2);
+        assert_eq!(commits[0].hash, "abc123");
+        assert_eq!(commits[0].subject, "Add history card");
+        assert!(commits[0].is_head);
+        assert_eq!(
+            commits[0].ref_names,
+            vec![
+                "HEAD -> feat/test".to_string(),
+                "origin/feat/test".to_string()
+            ]
+        );
+        assert_eq!(commits[1].subject, "Previous commit");
+        assert!(!commits[1].is_head);
+    }
 }

package/services/rust-bridge/src/services/update.rs

@@ -36,6 +36,7 @@ pub(crate) struct BridgeRuntimeInfo {
     pub(crate) version: String,
     pub(crate) install_kind: BridgeInstallKind,
     pub(crate) self_update_supported: bool,
+    pub(crate) safe_restart_supported: bool,
     pub(crate) latest_version: Option<String>,
     pub(crate) updater_status: Option<BridgeUpdaterStatus>,
 }
@@ -50,6 +51,44 @@ pub(crate) struct BridgeUpdateStartResponse {
     pub(crate) log_path: Option<String>,
 }
 
+#[derive(Debug, Clone, Serialize)]
+#[serde(rename_all = "camelCase")]
+pub(crate) struct BridgeRestartStartResponse {
+    pub(crate) ok: bool,
+    pub(crate) job_id: String,
+    pub(crate) message: String,
+    pub(crate) log_path: Option<String>,
+}
+
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+enum BridgeMaintenanceAction {
+    Update,
+    Restart,
+}
+
+impl BridgeMaintenanceAction {
+    fn as_arg(self) -> &'static str {
+        match self {
+            Self::Update => "update",
+            Self::Restart => "restart",
+        }
+    }
+
+    fn job_prefix(self) -> &'static str {
+        match self {
+            Self::Update => "bridge-update",
+            Self::Restart => "bridge-restart",
+        }
+    }
+}
+
+#[derive(Debug, Clone)]
+struct BridgeMaintenanceJobStart {
+    job_id: String,
+    target_version: String,
+    log_path: Option<String>,
+}
+
 #[derive(Clone)]
 pub(crate) struct UpdateService {
     package_root: Option<PathBuf>,
@@ -57,6 +96,8 @@ pub(crate) struct UpdateService {
     status_path: Option<PathBuf>,
     log_path: Option<PathBuf>,
     script_path: Option<PathBuf>,
+    launcher_path: Option<PathBuf>,
+    secure_env_path: Option<PathBuf>,
 }
 
 impl UpdateService {
@@ -75,6 +116,10 @@ impl UpdateService {
         let script_path = package_root
             .as_ref()
             .map(|root| root.join("scripts").join("bridge-self-update.js"));
+        let launcher_path = package_root
+            .as_ref()
+            .map(|root| root.join("scripts").join("start-bridge-secure.js"));
+        let secure_env_path = package_root.as_ref().map(|root| root.join(".env.secure"));
 
         Self {
             package_root,
@@ -82,13 +127,26 @@ impl UpdateService {
             status_path,
             log_path,
             script_path,
+            launcher_path,
+            secure_env_path,
         }
     }
 
+    pub(crate) fn is_safe_restart_supported(&self) -> bool {
+        self.package_root.is_some()
+            && self.script_path.as_ref().is_some_and(|path| path.is_file())
+            && self
+                .launcher_path
+                .as_ref()
+                .is_some_and(|path| path.is_file())
+            && self
+                .secure_env_path
+                .as_ref()
+                .is_some_and(|path| path.is_file())
+    }
+
     pub(crate) fn is_self_update_supported(&self) -> bool {
-        self.install_kind == BridgeInstallKind::PublishedCli
-            && self.package_root.is_some()
-            && self.script_path.as_ref().is_some_and(|path| path.exists())
+        self.install_kind == BridgeInstallKind::PublishedCli && self.is_safe_restart_supported()
     }
 
     pub(crate) async fn runtime_info(&self) -> BridgeRuntimeInfo {
@@ -96,6 +154,7 @@ impl UpdateService {
             version: env!("CARGO_PKG_VERSION").to_string(),
             install_kind: self.install_kind,
             self_update_supported: self.is_self_update_supported(),
+            safe_restart_supported: self.is_safe_restart_supported(),
             latest_version: fetch_latest_npm_version().await,
             updater_status: self.read_status(),
         }
@@ -107,11 +166,68 @@ impl UpdateService {
         bridge_pid: u32,
         now_iso: &str,
     ) -> Result<BridgeUpdateStartResponse, String> {
-        if !self.is_self_update_supported() {
-            return Err(
-                "Bridge self-update is only supported for published clawdex-mobile CLI installs."
+        let job = self.start_job(
+            BridgeMaintenanceAction::Update,
+            version,
+            bridge_pid,
+            now_iso,
+        )?;
+
+        Ok(BridgeUpdateStartResponse {
+            ok: true,
+            job_id: job.job_id,
+            target_version: job.target_version.clone(),
+            message: format!(
+                "Bridge update scheduled for {}. The bridge will disconnect briefly and should restart automatically.",
+                job.target_version
+            ),
+            log_path: job.log_path,
+        })
+    }
+
+    pub(crate) fn start_restart(
+        &self,
+        bridge_pid: u32,
+        now_iso: &str,
+    ) -> Result<BridgeRestartStartResponse, String> {
+        let job = self.start_job(
+            BridgeMaintenanceAction::Restart,
+            env!("CARGO_PKG_VERSION"),
+            bridge_pid,
+            now_iso,
+        )?;
+
+        Ok(BridgeRestartStartResponse {
+            ok: true,
+            job_id: job.job_id,
+            message:
+                "Bridge restart scheduled. The bridge will disconnect briefly and should restart automatically."
                     .to_string(),
-            );
+            log_path: job.log_path,
+        })
+    }
+
+    fn start_job(
+        &self,
+        action: BridgeMaintenanceAction,
+        version: &str,
+        bridge_pid: u32,
+        now_iso: &str,
+    ) -> Result<BridgeMaintenanceJobStart, String> {
+        match action {
+            BridgeMaintenanceAction::Update if !self.is_self_update_supported() => {
+                return Err(
+                    "Bridge self-update is only supported for published clawdex-mobile CLI installs."
+                        .to_string(),
+                );
+            }
+            BridgeMaintenanceAction::Restart if !self.is_safe_restart_supported() => {
+                return Err(
+                    "Bridge safe restart requires a detected clawdex-mobile install with .env.secure and launcher scripts available."
+                        .to_string(),
+                );
+            }
+            _ => {}
         }
 
         let package_root = self
@@ -132,7 +248,7 @@ impl UpdateService {
             .ok_or_else(|| "bridge updater log path is missing".to_string())?;
 
         let target_version = normalize_target_version(version)?;
-        let job_id = create_job_id();
+        let job_id = create_job_id(action.job_prefix());
 
         let log_file = OpenOptions::new()
             .create(true)
@@ -146,6 +262,8 @@ impl UpdateService {
         let mut command = std::process::Command::new(node_command());
         command
             .arg(script_path)
+            .arg("--action")
+            .arg(action.as_arg())
             .arg("--job-id")
             .arg(&job_id)
             .arg("--bridge-pid")
@@ -170,13 +288,9 @@ impl UpdateService {
             .map_err(|error| format!("failed to spawn updater: {error}"))?;
         let _ = child.id();
 
-        Ok(BridgeUpdateStartResponse {
-            ok: true,
+        Ok(BridgeMaintenanceJobStart {
             job_id,
-            target_version: target_version.clone(),
-            message: format!(
-                "Bridge update scheduled for {target_version}. The bridge will disconnect briefly and should restart automatically."
-            ),
+            target_version,
             log_path: Some(log_path.to_string_lossy().to_string()),
         })
     }
@@ -273,9 +387,9 @@ fn normalize_target_version(value: &str) -> Result<String, String> {
     Err("version must be 'latest' or a simple npm package version".to_string())
 }
 
-fn create_job_id() -> String {
+fn create_job_id(prefix: &str) -> String {
     format!(
-        "bridge-update-{}-{}",
+        "{prefix}-{}-{}",
         chrono::Utc::now().timestamp_millis(),
         std::process::id()
     )