refactor: 优化 ostool run，减少依赖条件 (#39)

* feat: 添加 thiserror 依赖并改进错误处理

* feat: 添加 someboot 模块并实现自动检测构建配置

* feat: 更新 someboot 模块的导入方式并改进构建配置检测

* feat: 更新 ostool 版本至 0.8.12，并增强 CargoBuilder 以支持从 Cargo JSON 消息解析可执行文件路径

* feat: 移除不必要的 schema 生成代码以简化 run_uboot 函数

* feat: 优化 detect_build_config 函数的参数格式并改进错误处理

Author: ZR233

Cargo.lock

@@ -8,7 +8,7 @@ license = "MIT OR Apache-2.0"
 name = "ostool"
 readme = "../README.md"
 repository = "https://github.com/drivercraft/ostool"
-version = "0.8.11"
+version = "0.8.12"
 
 [package.metadata.binstall]
 bin-dir = "{ name }-{ target }-v{ version }/{ bin }{ binary-ext }"
@@ -57,4 +57,5 @@ lzma-rs = "0.3"
 regex = "1"
 sha2 = "0.10"
 tar = "0.4"
+thiserror = {workspace = true}
 ureq = "3.0"

ostool/Cargo.toml

@@ -1,4 +1,8 @@
-use std::{env, path::PathBuf, process::exit};
+use std::{
+    env,
+    path::PathBuf,
+    process::{ExitCode, exit},
+};
 
 use clap::{Parser, Subcommand};
 use log::{LevelFilter, debug};
@@ -76,7 +80,18 @@ struct CliUboot {
 }
 
 #[tokio::main]
-async fn main() -> anyhow::Result<()> {
+async fn main() -> ExitCode {
+    match try_main().await {
+        Ok(()) => ExitCode::SUCCESS,
+        Err(err) => {
+            eprintln!("Error: {err:#}");
+            eprintln!("\nTrace:\n{err:?}");
+            ExitCode::FAILURE
+        }
+    }
+}
+
+async fn try_main() -> anyhow::Result<()> {
     env_logger::builder()
         .format_module_path(false)
         .filter_level(LevelFilter::Info)
@@ -118,7 +133,7 @@ async fn main() -> anyhow::Result<()> {
         ..Default::default()
     };
 
-    app.set_elf_path(args.elf).await;
+    app.set_elf_path(args.elf).await?;
     app.objcopy_elf()?;
 
     app.debug = args.debug;

ostool/src/bin/cargo-osrun.rs

@@ -6,12 +6,20 @@
 
 use std::{
     collections::HashMap,
+    io::BufReader,
     path::{Path, PathBuf},
+    process::Stdio,
 };
 
+use anyhow::{Context, anyhow, bail};
+use cargo_metadata::{Message, PackageId};
 use colored::Colorize;
 
-use crate::{build::config::Cargo, ctx::AppContext, utils::Command};
+use crate::{
+    build::{config::Cargo, someboot},
+    ctx::AppContext,
+    utils::{Command, PathResultExt},
+};
 
 /// A builder for constructing and executing Cargo commands.
 ///
@@ -35,6 +43,8 @@ pub struct CargoBuilder<'a> {
     extra_args: Vec<String>,
     extra_envs: HashMap<String, String>,
     skip_objcopy: bool,
+    resolve_artifact_from_json: bool,
+    resolved_elf_path: Option<PathBuf>,
     config_path: Option<PathBuf>,
 }
 
@@ -54,6 +64,8 @@ impl<'a> CargoBuilder<'a> {
             extra_args: Vec::new(),
             extra_envs: HashMap::new(),
             skip_objcopy: false,
+            resolve_artifact_from_json: false,
+            resolved_elf_path: None,
             config_path,
         }
     }
@@ -73,6 +85,8 @@ impl<'a> CargoBuilder<'a> {
             extra_args: Vec::new(),
             extra_envs: HashMap::new(),
             skip_objcopy: true,
+            resolve_artifact_from_json: false,
+            resolved_elf_path: None,
             config_path,
         }
     }
@@ -130,6 +144,12 @@ impl<'a> CargoBuilder<'a> {
         self
     }
 
+    /// Enables artifact path resolution from Cargo JSON messages.
+    pub fn resolve_artifact_from_json(mut self, enable: bool) -> Self {
+        self.resolve_artifact_from_json = enable;
+        self
+    }
+
     /// Executes the configured Cargo command.
     ///
     /// This runs pre-build commands, executes Cargo, handles output artifacts,
@@ -162,11 +182,78 @@ impl<'a> CargoBuilder<'a> {
     }
 
     async fn run_cargo(&mut self) -> anyhow::Result<()> {
+        if self.resolve_artifact_from_json {
+            return self.run_cargo_and_resolve_artifact().await;
+        }
+
         let mut cmd = self.build_cargo_command().await?;
         cmd.run()?;
         Ok(())
     }
 
+    async fn run_cargo_and_resolve_artifact(&mut self) -> anyhow::Result<()> {
+        let (target_pkg_id, default_run) = self.target_package_info()?;
+        let mut cmd = self.build_cargo_command().await?;
+
+        cmd.stdout(Stdio::piped());
+        cmd.stderr(Stdio::inherit());
+        cmd.print_cmd();
+
+        let mut child = cmd
+            .spawn()
+            .context("failed to spawn cargo build command for artifact resolution")?;
+
+        let stdout = child
+            .stdout
+            .take()
+            .ok_or_else(|| anyhow!("failed to capture cargo stdout for message parsing"))?;
+        let reader = BufReader::new(stdout);
+
+        let mut executable_artifacts: Vec<(String, PathBuf)> = Vec::new();
+        for message in Message::parse_stream(reader) {
+            let message = message.context("failed to parse cargo JSON message stream")?;
+            match message {
+                Message::CompilerArtifact(artifact) => {
+                    if artifact.package_id == target_pkg_id
+                        && artifact.target.is_bin()
+                        && let Some(executable) = artifact.executable
+                    {
+                        executable_artifacts
+                            .push((artifact.target.name, executable.into_std_path_buf()));
+                    }
+                }
+                Message::CompilerMessage(msg) => {
+                    if let Some(rendered) = msg.message.rendered {
+                        eprint!("{rendered}");
+                    }
+                }
+                Message::TextLine(line) => {
+                    println!("{line}");
+                }
+                _ => {}
+            }
+        }
+
+        let status = child
+            .wait()
+            .context("failed waiting for cargo build process")?;
+        if !status.success() {
+            bail!("failed with status: {status}");
+        }
+
+        let resolved = self.pick_executable_artifact(&executable_artifacts, default_run.as_deref());
+        let Some(resolved) = resolved else {
+            bail!(
+                "no executable artifact found for package '{}' and target '{}'; please check system.Cargo.package/system.Cargo.target",
+                self.config.package,
+                self.config.target
+            );
+        };
+
+        self.resolved_elf_path = Some(resolved);
+        Ok(())
+    }
+
     async fn build_cargo_command(&mut self) -> anyhow::Result<Command> {
         let mut cmd = self.ctx.command("cargo");
 
@@ -212,11 +299,32 @@ impl<'a> CargoBuilder<'a> {
             cmd.arg(arg);
         }
 
+        // Auto-detected args from someboot/build-info.toml
+        let workspace_manifest = self.ctx.paths.workspace.join("Cargo.toml");
+        if workspace_manifest.exists() {
+            let detected_args =
+                someboot::detect_build_config(&workspace_manifest, &self.config.target)
+                    .with_context(|| {
+                        format!(
+                            "failed to detect someboot build config from {}",
+                            workspace_manifest.display()
+                        )
+                    })?;
+            for arg in detected_args {
+                cmd.arg(arg);
+            }
+        }
+
         // Release mode
         if !self.ctx.debug {
             cmd.arg("--release");
         }
 
+        if self.resolve_artifact_from_json {
+            cmd.arg("--message-format");
+            cmd.arg("json-render-diagnostics");
+        }
+
         // Extra args
         for arg in &self.extra_args {
             cmd.arg(arg);
@@ -230,14 +338,18 @@ impl<'a> CargoBuilder<'a> {
     }
 
     async fn handle_output(&mut self) -> anyhow::Result<()> {
-        let target_dir = self.ctx.paths.build_dir();
+        let elf_path = if let Some(path) = &self.resolved_elf_path {
+            path.clone()
+        } else {
+            let target_dir = self.ctx.paths.build_dir();
 
-        let elf_path = target_dir
-            .join(&self.config.target)
-            .join(if self.ctx.debug { "debug" } else { "release" })
-            .join(&self.config.package);
+            target_dir
+                .join(&self.config.target)
+                .join(if self.ctx.debug { "debug" } else { "release" })
+                .join(&self.config.package)
+        };
 
-        self.ctx.set_elf_path(elf_path).await;
+        self.ctx.set_elf_path(elf_path).await?;
 
         if self.config.to_bin && !self.skip_objcopy {
             self.ctx.objcopy_output_bin()?;
@@ -253,6 +365,43 @@ impl<'a> CargoBuilder<'a> {
         Ok(())
     }
 
+    fn target_package_info(&self) -> anyhow::Result<(PackageId, Option<String>)> {
+        let metadata = self.ctx.metadata()?;
+        let Some(package) = metadata
+            .packages
+            .iter()
+            .find(|pkg| pkg.name == self.config.package)
+        else {
+            bail!(
+                "package '{}' not found in cargo metadata under {}",
+                self.config.package,
+                self.ctx.paths.manifest.display()
+            );
+        };
+        Ok((package.id.clone(), package.default_run.clone()))
+    }
+
+    fn pick_executable_artifact(
+        &self,
+        executable_artifacts: &[(String, PathBuf)],
+        default_run: Option<&str>,
+    ) -> Option<PathBuf> {
+        executable_artifacts
+            .iter()
+            .rev()
+            .find(|(name, _)| name == &self.config.package)
+            .or_else(|| {
+                default_run.and_then(|default_bin| {
+                    executable_artifacts
+                        .iter()
+                        .rev()
+                        .find(|(name, _)| name == default_bin)
+                })
+            })
+            .or_else(|| executable_artifacts.last())
+            .map(|(_, path)| path.clone())
+    }
+
     fn build_features(&self) -> Vec<String> {
         let mut features = self.config.features.clone();
         if let Some(log_level) = self.log_level_feature() {
@@ -310,7 +459,12 @@ impl<'a> CargoBuilder<'a> {
                 if let Some(ref config_path) = self.config_path {
                     let combined = config_path
                         .parent()
-                        .ok_or_else(|| anyhow::anyhow!("Invalid config path"))?
+                        .ok_or_else(|| {
+                            anyhow::anyhow!(
+                                "invalid config path without parent: {}",
+                                config_path.display()
+                            )
+                        })?
                         .join(extra);
                     Ok(Some(combined))
                 } else {
@@ -397,7 +551,8 @@ impl<'a> CargoBuilder<'a> {
         // Write to temp file
         tokio::fs::write(&target_path, content)
             .await
-            .map_err(|e| anyhow::anyhow!("Failed to write to temp file: {}", e))?;
+            .with_path("failed to write downloaded cargo config", &target_path)
+            .with_context(|| format!("while downloading cargo config from {url}"))?;
 
         println!("Config downloaded to: {}", target_path.display());