Struct ClaudeHarness 

pub struct ClaudeHarness;

Claude Code CLI as a Harness.

Implementations

impl ClaudeHarness

pub fn new() -> Self

Examples found in repository

examples/setup.rs (line 16)

fn main() -> Result<(), HarnessError> {
    let claude = Claude::new();

    // A logger for the install/login progress stream.
    let log: harness::InstallCallback = Arc::new(|ev| match ev {
        InstallEvent::Step { text } => eprintln!("• {text}"),
        InstallEvent::Stdout { text } | InstallEvent::Stderr { text } => eprintln!("  {text}"),
        InstallEvent::Done { ok, .. } => eprintln!("done (ok={ok})"),
    });

    let r = claude.readiness();
    // Fallible calls return the typed `HarnessError`; `?` propagates it.
    if !r.installed {
        claude.install(Arc::clone(&log))?; // npm i -g @anthropic-ai/claude-code
    }
    if !r.auth_configured {
        claude.login(log)?; // `claude auth login` — opens the browser
    }

    println!("ready: {}", claude.readiness().ready);
    Ok(())
}

examples/run_prompt.rs (line 12)

fn main() -> Result<(), HarnessError> {
    // Pick a harness. `Claude` drives the `claude` CLI (must be installed +
    // signed in). Swap for `harness::Bob::new()` or `harness::Codex::new()`.
    let claude = Claude::new();

    // `run_channel()` starts the run and hands back the events on a channel,
    // so there's no callback/`Sender` plumbing to write by hand. It returns
    // immediately; events arrive on background threads. (`run()` is still
    // there for push semantics — forwarding straight onto a Tauri Channel or
    // SSE sink from inside a callback.)
    let (_handle, rx) = claude.run_channel(RunRequest {
        run_id: "demo".into(),
        prompt: "In one sentence, what is a Markdown heading?".into(),
        cwd: None,                    // working dir for the agent's tool calls
        mode: RunMode::Ask,           // Ask = answer only; Edit = may edit files
        tuning: RunTuning::default(), // optional: model / effort / max_turns
    })?; // keep `_handle` to `.cancel()`; dropping it does NOT stop the run

    // ONE normalized event stream, regardless of the backing CLI. `rx` hangs
    // up on its own when the run ends, so this loop terminates without
    // touching the handle:
    for ev in rx {
        match ev {
            RunEvent::Text { delta, .. } => print!("{delta}"), // the answer
            RunEvent::Thinking { delta, .. } => eprint!("{delta}"), // model reasoning
            RunEvent::ToolStart { name, .. } => eprintln!("\n[tool] {name}"),
            RunEvent::Error { message, .. } => eprintln!("\n[error] {message}"),
            RunEvent::Exited { .. } => break,
            _ => {}
        }
    }
    Ok(())
}

Trait Implementations

impl Clone for ClaudeHarness

fn clone(&self) -> ClaudeHarness

Returns a duplicate of the value.

fn clone_from(&mut self, source: &Self)

Performs copy-assignment from source.

impl Debug for ClaudeHarness

fn fmt(&self, f: &mut Formatter<'_>) -> Result

Formats the value using the given formatter.

impl Default for ClaudeHarness

fn default() -> ClaudeHarness

Returns the “default value” for a type.

impl Harness for ClaudeHarness

fn info(&self) -> HarnessInfo

Static metadata for the UI.

fn readiness(&self) -> HarnessReadiness

Probe availability / version / auth. May shell out; callers should treat it as blocking and run it off the UI thread.

fn install(&self, on_event: InstallCallback) -> Result<(), HarnessError>

Stream a one-time install. Harnesses that need no install (e.g. a hosted-API adapter) return Ok(()) immediately.

fn run( &self, request: RunRequest, on_event: RunCallback, ) -> Result<RunHandle, HarnessError>

Start a run, streaming events through on_event. Returns a handle immediately; work continues on background threads.

fn credential(&self) -> CredentialSpec

The credential this harness needs.

fn login(&self, on_event: InstallCallback) -> Result<(), HarnessError>

Trigger the harness’s own interactive sign-in (its CLI’s OAuth), streaming progress as InstallEvents — the same subprocess stream shape as install. The flow opens the user’s browser; this blocks until the login process exits, then Done { ok } reports success. Default: unsupported — harnesses that Compose authenticates itself (bob, via its API key) keep it.

fn run_channel( &self, request: RunRequest, ) -> Result<(RunHandle, Receiver<RunEvent>), HarnessError>

Convenience over run for callers that want to pull events off a channel instead of supplying a push callback. Forwards each RunEvent into an mpsc channel and hands the receiver back alongside the run handle, so the caller can simply for event in rx { … } rather than re-write the Arc::new(move |ev| tx.send(ev)) plumbing at every call site.