//! End-to-end coverage for `exec`'s command-line handling against the real sidecar.//!//! `exec` takes a command *line*, not a pre-split argv. The client mirrors the sidecar's//! child_process shell decision: shell-free commands spawn directly (preserving the command's real//! exit code), while shell syntax or a POSIX builtin head runs under `sh -c <line>`. These tests//! prove both paths produce truthful results inside the VM.//!//! Self-gating: skips when the sidecar binary or coreutils wasm artifacts are absent. mod common; use agentos_client::ExecOptions; #[tokio::test]async fn exec_command_line_paths() {    if !common::sidecar_available() {        eprintln!("skipping exec_command_line_paths: sidecar binary not built");        return;    }    let Some(os) = common::new_vm_with_commands().await else {        eprintln!("skipping exec_command_line_paths: coreutils wasm artifacts absent");        return;    };     // Direct path: a simple command with arguments runs and returns its output.    let echo = os        .exec("echo hello world", ExecOptions::default())        .await        .expect("exec echo");    assert_eq!(echo.exit_code, 0, "echo exit (stderr: {:?})", echo.stderr);    assert_eq!(echo.stdout.trim_end(), "hello world", "echo stdout");     // Direct path preserves a real non-zero exit code (the `sh -c` wrapper can swallow it).    let missing = os        .exec("cat /no/such/file", ExecOptions::default())        .await        .expect("exec cat missing returns a result");    assert_ne!(        missing.exit_code, 0,        "cat of a missing file must report a non-zero exit code"    );     // Shell path: a `&&` chain runs as a single `sh -c` execution.    let chain = os        .exec("echo a && echo b", ExecOptions::default())        .await        .expect("exec && chain");    assert_eq!(        chain.exit_code, 0,        "chain exit (stderr: {:?})",        chain.stderr    );    assert_eq!(chain.stdout, "a\nb\n", "chain stdout");     // Shell path: a redirect writes a file the VM can read back.    let redirect = os        .exec(            "echo redirected > /tmp/exec_redirect.txt",            ExecOptions::default(),        )        .await        .expect("exec redirect");    assert_eq!(        redirect.exit_code, 0,        "redirect exit (stderr: {:?})",        redirect.stderr    );    let body = os        .read_file("/tmp/exec_redirect.txt")        .await        .expect("read redirected file");    assert_eq!(        String::from_utf8_lossy(&body).trim_end(),        "redirected",        "redirected file contents"    );     // Shell path: a quoted argument with a space stays one token through `sh -c`.    let quoted = os        .exec("echo 'a b'", ExecOptions::default())        .await        .expect("exec quoted");    assert_eq!(quoted.stdout.trim_end(), "a b", "quoted stdout");     // An empty command line is an explicit error, not a silent no-op.    assert!(        os.exec("   ", ExecOptions::default()).await.is_err(),        "empty command line must error"    );     os.shutdown().await.expect("shutdown");}