Improve platform detection and add multi-arch run test

- Updated get_test_platform() to detect runtime architecture in CI
  - CI tests use native platform (linux/amd64 on x86_64, linux/arm64 on aarch64)
  - Local development always uses linux/amd64 for consistency

- Added test_multi_arch_build_and_run() test
  - Builds multi-arch image and pushes to ttl.sh
  - Verifies the image runs correctly on the current architecture
  - Gracefully handles missing toolchain scenarios

- Updated CI integration test to verify multi-arch images can run
  - Builds for both linux/amd64 and linux/arm64
  - Runs the image to ensure Docker selects the correct architecture

This ensures we properly test both single and multi-arch scenarios.

🤖 Generated with [Claude Code](https://claude.ai/code)

Co-Authored-By: Claude <noreply@anthropic.com>

tests/integration_test.rs

@@ -4,10 +4,21 @@ use predicates::prelude::*;
 use std::env;
 use std::process::Command as StdCommand;
 
-// Helper to get the appropriate test platform based on architecture
+// Helper to get the appropriate test platform based on runtime architecture
 fn get_test_platform() -> &'static str {
-    // Always test linux/amd64 as it's universally available in our CI
-    "linux/amd64"
+    // In CI, test the native platform
+    if env::var("CI").is_ok() {
+        if cfg!(target_arch = "x86_64") {
+            "linux/amd64"
+        } else if cfg!(target_arch = "aarch64") {
+            "linux/arm64"
+        } else {
+            "linux/amd64"
+        }
+    } else {
+        // For local development, always use amd64 as it's most commonly available
+        "linux/amd64"
+    }
 }
 
 #[test]
@@ -257,3 +268,60 @@ fn test_multi_platform_build() -> Result<()> {
     }
     Ok(())
 }
+
+#[test]
+fn test_multi_arch_build_and_run() -> Result<()> {
+    // This test requires Docker
+    let docker_check = StdCommand::new("docker").arg("version").output();
+    match docker_check {
+        Ok(output) if output.status.success() => {
+            // Docker is available, proceed with test
+        }
+        _ => {
+            eprintln!("Docker is required for this test but is not available");
+            return Ok(());
+        }
+    }
+
+    let example_dir = env::current_dir()?.join("example").join("hello-krust");
+
+    // Build multi-arch image and push to ttl.sh
+    let mut cmd = Command::cargo_bin("krust")?;
+    let output = cmd
+        .arg("build")
+        .arg("--platform")
+        .arg("linux/amd64,linux/arm64")
+        .arg(".")
+        .env("KRUST_REPO", "ttl.sh/krust-multiarch-test")
+        .current_dir(&example_dir)
+        .output()?;
+
+    if !output.status.success() {
+        let stderr = String::from_utf8_lossy(&output.stderr);
+        // If it fails due to missing targets, that's expected in some environments
+        if stderr.contains("target may not be installed")
+            || stderr.contains("linker")
+            || stderr.contains("cross-compilation")
+            || stderr.contains("not found")
+        {
+            eprintln!("Skipping multi-arch run test - build failed due to missing toolchain");
+            return Ok(());
+        }
+        panic!("Build failed unexpectedly: {}", stderr);
+    }
+
+    // Get the image reference from stdout
+    let image_ref = String::from_utf8_lossy(&output.stdout).trim().to_string();
+    assert!(image_ref.starts_with("ttl.sh/krust-multiarch-test/hello-krust"));
+
+    // Try to run the image - it should work on the current architecture
+    let docker_output = StdCommand::new("docker")
+        .args(&["run", "--rm", &image_ref])
+        .output()?;
+
+    assert!(docker_output.status.success(), "Docker run failed");
+    let docker_stdout = String::from_utf8_lossy(&docker_output.stdout);
+    assert!(docker_stdout.contains("Hello from krust example!"));
+
+    Ok(())
+}