use std::io::Read;
use std::path::{Path, PathBuf};
use std::sync::Arc;
#[cfg(test)]
use arabica_adapters::SqliteSessionStore;
use arabica_protocol::{
Command, CommandEnvelope, CommandId, Event, EventEnvelope, SessionStatus, WorkspaceId,
};
use arabica_provider::{ApiModelProvider, ApiProviderConfig};
use arabica_runner::LocalTool;
use arabica_runtime::{BlendRoutingPolicy, RunCancellation, RunControl};
use arabica_session::{
DispatchControl, EventVisibility, FanOutObserver, SessionEventObserver, SessionManager,
};
use arabica_session::{NewSession, SessionStore, StoredSession};
use crate::host::{HostModel, HostRuntime, LocalRunnerPolicy, workspace_id_for};
#[derive(clap::ValueEnum, Clone, Copy, Debug, Default, Eq, PartialEq)]
#[value(rename_all = "lower")]
pub enum OutputFormat {
#[default]
Text,
Jsonl,
}
pub struct PrintOptions {
pub task: String,
pub output_format: OutputFormat,
pub allow_shell: bool,
pub read_only: bool,
pub resume: Resume,
pub remote_runner: Option<String>,
}
pub enum Resume {
None,
Continue,
Id(String),
}
pub fn resolve_task(value: &str) -> Result<String, std::io::Error> {
if value != "-" {
return Ok(value.to_owned());
}
let mut task = String::new();
std::io::stdin().read_to_string(&mut task)?;
Ok(task.trim_end_matches('\n').to_owned())
}
pub fn tool_policy(allow_shell: bool, read_only: bool) -> Result<LocalRunnerPolicy, String> {
match (allow_shell, read_only) {
(true, true) => Err("--allow-shell and --read-only are mutually exclusive".to_owned()),
(true, false) => Ok(LocalRunnerPolicy::coding().with_tool(LocalTool::Shell)),
(false, true) => Ok(LocalRunnerPolicy::read_only()),
(false, false) => Ok(LocalRunnerPolicy::coding()),
}
}
const EXIT_COMPLETED: i32 = 0;
const EXIT_FAILED: i32 = 1;
const EXIT_CONFIG_ERROR: i32 = 2;
const EXIT_CANCELLED: i32 = 130;
enum Outcome {
Completed(Option<String>),
Cancelled,
Failed(String),
}
fn classify(events: &[EventEnvelope]) -> Outcome {
if events
.iter()
.any(|envelope| matches!(envelope.event, Event::RunCancelled))
{
return Outcome::Cancelled;
}
for envelope in events {
match &envelope.event {
Event::RunCompleted { output } => return Outcome::Completed(output.clone()),
Event::RunFailed { message } => return Outcome::Failed(message.clone()),
_ => {}
}
}
Outcome::Failed("run ended without a terminal event".to_owned())
}
struct TextProgressObserver;
impl SessionEventObserver for TextProgressObserver {
fn observe(&self, envelope: &EventEnvelope, _visibility: EventVisibility) {
match &envelope.event {
Event::ToolCallRequested {
name, arguments, ..
} => eprintln!("\u{2192} {name} {arguments}"),
Event::ToolCallCompleted { name, is_error, .. } if *is_error => {
eprintln!("\u{2717} {name} failed")
}
_ => {}
}
}
}
struct JsonlObserver;
impl SessionEventObserver for JsonlObserver {
fn observe(&self, envelope: &EventEnvelope, _visibility: EventVisibility) {
match jsonl_line(envelope) {
Some(Ok(line)) => println!("{line}"),
Some(Err(error)) => eprintln!("structure -p: failed to serialize an event: {error}"),
None => {}
}
}
}
fn jsonl_line(envelope: &EventEnvelope) -> Option<Result<String, serde_json::Error>> {
if !envelope.event.is_client_visible() {
return None;
}
Some(serde_json::to_string(envelope))
}
pub async fn run(provider_config: ApiProviderConfig, options: PrintOptions) -> i32 {
let model = match ApiModelProvider::new(provider_config.clone()) {
Ok(model) => HostModel::Api(model),
Err(error) => {
eprintln!("error: {error}");
return EXIT_CONFIG_ERROR;
}
};
run_with_model(model, None, options).await
}
pub async fn run_with_model(
model: HostModel,
blend_policy: Option<BlendRoutingPolicy>,
options: PrintOptions,
) -> i32 {
let policy = match tool_policy(options.allow_shell, options.read_only) {
Ok(policy) => policy,
Err(message) => {
eprintln!("error: {message}");
return EXIT_CONFIG_ERROR;
}
};
let runner_root = match std::env::current_dir() {
Ok(root) => root,
Err(error) => {
eprintln!("error: {error}");
return EXIT_CONFIG_ERROR;
}
};
let arabica_home = match arabica_adapters::default_arabica_home() {
Ok(home) => home,
Err(error) => {
eprintln!("error: {error}");
return EXIT_CONFIG_ERROR;
}
};
let workspace_id = workspace_id_for(&runner_root);
let mcp = match crate::mcp::connect_configured(&runner_root, &arabica_home).await {
Ok((mcp, diagnostics)) => {
for diagnostic in diagnostics {
eprintln!("structure: {diagnostic}");
}
mcp
}
Err(message) => {
eprintln!("error: {message}");
return EXIT_CONFIG_ERROR;
}
};
let session_store = crate::host::session_store(&arabica_home);
let resumed = match resolve_resume(&options.resume, session_store.as_ref(), &workspace_id) {
Ok(resumed) => resumed,
Err(message) => {
eprintln!("error: {message}");
return EXIT_CONFIG_ERROR;
}
};
let remote = match &options.remote_runner {
Some(name) => match crate::runner::connect_configured(&arabica_home, name, &policy).await {
Ok(remote) => Some(remote),
Err(message) => {
eprintln!("error: {message}");
return EXIT_CONFIG_ERROR;
}
},
None => None,
};
match run_task(
model,
blend_policy,
&runner_root,
policy,
options,
arabica_home,
workspace_id,
resumed,
session_store,
mcp,
remote,
)
.await
{
Ok(outcome) => report(outcome),
Err(error) => {
eprintln!("error: {error}");
EXIT_FAILED
}
}
}
pub(crate) fn resolve_resume(
resume: &Resume,
session_store: &dyn SessionStore,
workspace_id: &WorkspaceId,
) -> Result<Option<StoredSession>, String> {
match resume {
Resume::None => Ok(None),
Resume::Continue => {
let listings = session_store
.list(Some(workspace_id))
.map_err(|error| error.to_string())?;
let Some(most_recent) = listings.first() else {
return Err("no session to continue in this workspace".to_owned());
};
session_store
.read(&most_recent.header.workspace_id, &most_recent.header.id)
.map(Some)
.map_err(|error| error.to_string())
}
Resume::Id(id) => session_store
.read(workspace_id, &arabica_protocol::SessionId::new(id.clone()))
.map(Some)
.map_err(|error| format!("could not resume session {id}: {error}")),
}
}
#[allow(clippy::too_many_arguments)]
async fn run_task(
model: HostModel,
blend_policy: Option<BlendRoutingPolicy>,
runner_root: &Path,
policy: LocalRunnerPolicy,
options: PrintOptions,
arabica_home: PathBuf,
workspace_id: WorkspaceId,
resumed: Option<StoredSession>,
session_store: Arc<dyn SessionStore>,
mcp: crate::mcp::McpTools,
remote: Option<arabica_runner_remote::RemoteRunner>,
) -> Result<Outcome, Box<dyn std::error::Error>> {
let runtime: HostRuntime = crate::host::build_host_runtime_with_blend_and_runner(
model,
runner_root,
policy,
&arabica_home,
mcp,
remote,
blend_policy,
)?;
let mut manager = SessionManager::with_ids(runtime, Box::new(crate::host::UuidIds));
let instructions_sha256 = crate::instructions::sha256(manager.runtime().system_instructions());
let (session_id, store) = match resumed {
Some(stored) => {
let session_id = stored.header.id.clone();
let store = session_store.open(&workspace_id, &session_id)?;
manager.restore_session(
stored.into_snapshot(),
CommandId::new(uuid::Uuid::now_v7().to_string()),
Some(store.as_ref()),
)?;
if manager
.session(&session_id)
.is_some_and(|session| session.status == SessionStatus::Suspended)
{
let resumed = manager
.dispatch(
CommandEnvelope::new(
CommandId::new(uuid::Uuid::now_v7().to_string()),
Some(session_id.clone()),
Command::SessionResume,
),
DispatchControl::default(),
)
.await?;
for event in &resumed {
store.observe(event, EventVisibility::Client);
}
}
(session_id, store)
}
None => {
let create = CommandEnvelope::new(
CommandId::new(uuid::Uuid::now_v7().to_string()),
None,
Command::SessionCreate {
workspace_id: workspace_id.clone(),
},
);
let created = manager.dispatch(create, DispatchControl::default()).await?;
let session_created = created
.into_iter()
.next()
.expect("session.create always produces at least one Event");
let session_id = session_created.session_id.clone();
let store = session_store.create(NewSession {
session_id: &session_id,
workspace_id: &workspace_id,
cwd: runner_root,
profile: None,
instructions_sha256: Some(&instructions_sha256),
})?;
store.observe(&session_created, EventVisibility::Client);
(session_id, store)
}
};
let progress_observer: Arc<dyn SessionEventObserver> = match options.output_format {
OutputFormat::Text => Arc::new(TextProgressObserver),
OutputFormat::Jsonl => Arc::new(JsonlObserver),
};
let mut observers: Vec<Arc<dyn SessionEventObserver>> =
vec![store as Arc<dyn SessionEventObserver>, progress_observer];
crate::evaluation::attach(&mut observers, &arabica_home);
let observer: Arc<dyn SessionEventObserver> = Arc::new(FanOutObserver::new(observers));
let cancellation = RunCancellation::new();
let ctrl_c = tokio::spawn({
let cancellation = cancellation.clone();
async move {
loop {
if tokio::signal::ctrl_c().await.is_err() {
return;
}
if cancellation.is_cancelled() {
eprintln!("structure: second interrupt, exiting immediately");
std::process::exit(EXIT_CANCELLED);
}
eprintln!("structure: interrupted, cancelling the current run...");
cancellation.cancel();
}
}
});
let prompt = CommandEnvelope::new(
CommandId::new(uuid::Uuid::now_v7().to_string()),
Some(session_id),
Command::MessageSend {
images: Vec::new(),
content: options.task,
},
);
let control = DispatchControl {
run: RunControl {
cancellation: Some(cancellation),
permissions: None,
},
observer: Some(observer),
};
let events = manager.dispatch(prompt, control).await?;
ctrl_c.abort();
Ok(classify(&events))
}
fn report(outcome: Outcome) -> i32 {
match outcome {
Outcome::Completed(output) => {
if let Some(output) = output {
println!("{output}");
}
EXIT_COMPLETED
}
Outcome::Cancelled => {
eprintln!("structure: cancelled");
EXIT_CANCELLED
}
Outcome::Failed(message) => {
eprintln!("error: {message}");
EXIT_FAILED
}
}
}
#[cfg(test)]
mod tests {
use super::*;
#[derive(Debug)]
struct ReadOnlyStore(arabica_session::SessionHeader);
impl SessionStore for ReadOnlyStore {
fn create(
&self,
_: NewSession<'_>,
) -> Result<Arc<dyn arabica_session::SessionWriter>, arabica_session::StoreError> {
panic!("resume lookup must not create a writer")
}
fn open(
&self,
_: &WorkspaceId,
_: &arabica_protocol::SessionId,
) -> Result<Arc<dyn arabica_session::SessionWriter>, arabica_session::StoreError> {
panic!("resume lookup must not acquire ownership")
}
fn read(
&self,
workspace: &WorkspaceId,
session: &arabica_protocol::SessionId,
) -> Result<StoredSession, arabica_session::StoreError> {
assert_eq!(workspace, &self.0.workspace_id);
assert_eq!(session, &self.0.id);
Ok(StoredSession {
header: self.0.clone(),
events: Vec::new(),
})
}
fn list(
&self,
workspace: Option<&WorkspaceId>,
) -> Result<Vec<arabica_session::SessionListing>, arabica_session::StoreError> {
assert_eq!(workspace, Some(&self.0.workspace_id));
Ok(vec![arabica_session::SessionListing {
header: self.0.clone(),
updated_at_ms: Some(42),
}])
}
}
#[test]
fn resume_lookup_uses_an_injected_store_without_backend_paths() {
let store = ReadOnlyStore(arabica_session::SessionHeader {
id: arabica_protocol::SessionId::new("stored-session"),
workspace_id: WorkspaceId::new("workspace"),
title: Some("Stored title".to_owned()),
cwd: "/virtual-workspace".to_owned(),
schema: "test".to_owned(),
created_at_ms: 42,
protocol_version: arabica_protocol::PROTOCOL_VERSION.to_owned(),
profile: None,
instructions_sha256: None,
});
let resumed = resolve_resume(&Resume::Continue, &store, &store.0.workspace_id)
.unwrap()
.unwrap();
assert_eq!(resumed.header.title.as_deref(), Some("Stored title"));
let resumed = resolve_resume(
&Resume::Id("stored-session".to_owned()),
&store,
&store.0.workspace_id,
)
.unwrap()
.unwrap();
assert_eq!(resumed.header.id, store.0.id);
}
#[test]
fn a_dash_reads_the_task_from_stdin_and_anything_else_passes_through() {
assert_eq!(resolve_task("fix the bug").unwrap(), "fix the bug");
}
#[test]
fn allow_shell_and_read_only_together_is_a_configuration_error() {
assert!(tool_policy(true, true).is_err());
}
#[test]
fn allow_shell_adds_shell_to_the_coding_policy() {
let policy = tool_policy(true, false).expect("valid combination");
assert_eq!(
policy,
LocalRunnerPolicy::coding().with_tool(LocalTool::Shell)
);
}
#[test]
fn read_only_never_includes_shell_or_any_mutating_tool() {
let policy = tool_policy(false, true).expect("valid combination");
assert_eq!(policy, LocalRunnerPolicy::read_only());
}
#[test]
fn the_default_policy_is_coding_without_shell() {
let policy = tool_policy(false, false).expect("valid combination");
assert_eq!(policy, LocalRunnerPolicy::coding());
}
fn envelope(event: Event) -> EventEnvelope {
EventEnvelope {
protocol_version: arabica_protocol::PROTOCOL_VERSION.to_owned(),
event_id: arabica_protocol::EventId::new("event-1"),
command_id: arabica_protocol::CommandId::new("command-1"),
workspace_id: arabica_protocol::WorkspaceId::new("ws-1"),
session_id: arabica_protocol::SessionId::new("session-1"),
run_id: Some(arabica_protocol::RunId::new("run-1")),
sequence: 1,
occurred_at_ms: 0,
event,
}
}
#[test]
fn classify_prefers_cancelled_over_a_terminal_completion() {
let events = vec![
envelope(Event::RunCompleted {
output: Some("done".to_owned()),
}),
envelope(Event::RunCancelled),
];
assert!(matches!(classify(&events), Outcome::Cancelled));
}
#[test]
fn classify_extracts_the_completed_output() {
let events = vec![envelope(Event::RunCompleted {
output: Some("the answer".to_owned()),
})];
match classify(&events) {
Outcome::Completed(Some(output)) => assert_eq!(output, "the answer"),
_ => panic!("expected Completed(Some(..))"),
}
}
#[test]
fn classify_extracts_the_failure_message() {
let events = vec![envelope(Event::RunFailed {
message: "boom".to_owned(),
})];
match classify(&events) {
Outcome::Failed(message) => assert_eq!(message, "boom"),
_ => panic!("expected Failed"),
}
}
#[test]
fn report_maps_each_outcome_to_its_documented_exit_code() {
assert_eq!(report(Outcome::Completed(None)), EXIT_COMPLETED);
assert_eq!(
report(Outcome::Completed(Some("hi".to_owned()))),
EXIT_COMPLETED
);
assert_eq!(report(Outcome::Cancelled), EXIT_CANCELLED);
assert_eq!(report(Outcome::Failed("x".to_owned())), EXIT_FAILED);
}
#[test]
fn jsonl_line_is_none_for_an_internal_event_and_some_for_a_client_visible_one() {
let internal = envelope(Event::ModelResponseItem {
model_step: 1,
item_index: 0,
item: arabica_model::RuntimeItem::Reasoning(arabica_model::ReasoningItem {
id: None,
summary: vec!["secret reasoning".to_owned()],
provider_state: None,
}),
});
assert!(jsonl_line(&internal).is_none());
let client_visible = envelope(Event::RunStarted);
let line = jsonl_line(&client_visible)
.expect("a client-visible event must produce a line")
.expect("serialization succeeds");
assert!(line.contains("run.started"));
}
fn temp_home(label: &str) -> PathBuf {
let unique = std::time::SystemTime::now()
.duration_since(std::time::UNIX_EPOCH)
.expect("clock is valid")
.as_nanos();
std::env::temp_dir().join(format!("arabica-cli-print-{label}-{unique}"))
}
fn seed_session(home: &Path, workspace_id: &WorkspaceId) -> arabica_protocol::SessionId {
let session_id = arabica_protocol::SessionId::new("session-1");
SqliteSessionStore::create(
home,
NewSession {
session_id: &session_id,
workspace_id,
cwd: Path::new("/repo"),
profile: None,
instructions_sha256: None,
},
)
.expect("store creates");
session_id
}
#[test]
fn resume_none_resolves_to_nothing_without_touching_the_filesystem() {
let home = PathBuf::from("/nonexistent/does-not-exist");
let workspace_id = WorkspaceId::new("ws-1");
assert!(
resolve_resume(
&Resume::None,
crate::host::session_store(&home).as_ref(),
&workspace_id
)
.expect("None never fails")
.is_none()
);
}
#[test]
fn continue_with_no_sessions_in_the_workspace_is_a_configuration_error() {
let home = temp_home("continue-empty");
let workspace_id = WorkspaceId::new("ws-1");
std::fs::create_dir_all(&home).expect("home creates");
let error = resolve_resume(
&Resume::Continue,
crate::host::session_store(&home).as_ref(),
&workspace_id,
)
.expect_err("no session exists to continue");
assert!(
error.contains("no session to continue"),
"unexpected message: {error}"
);
std::fs::remove_dir_all(&home).ok();
}
#[test]
fn continue_resolves_to_the_most_recently_active_session() {
let home = temp_home("continue-hit");
let workspace_id = WorkspaceId::new("ws-1");
let session_id = seed_session(&home, &workspace_id);
let resumed = resolve_resume(
&Resume::Continue,
crate::host::session_store(&home).as_ref(),
&workspace_id,
)
.expect("a session exists to continue")
.expect("Continue resolves to Some when a session exists");
assert_eq!(resumed.header.id, session_id);
std::fs::remove_dir_all(&home).ok();
}
#[test]
fn resume_by_an_unknown_id_is_a_configuration_error() {
let home = temp_home("resume-unknown");
let workspace_id = WorkspaceId::new("ws-1");
std::fs::create_dir_all(&home).expect("home creates");
let error = resolve_resume(
&Resume::Id("no-such-session".to_owned()),
crate::host::session_store(&home).as_ref(),
&workspace_id,
)
.expect_err("the named session does not exist");
assert!(
error.contains("could not resume session no-such-session"),
"unexpected message: {error}"
);
std::fs::remove_dir_all(&home).ok();
}
#[test]
fn resume_by_a_known_id_resolves_to_that_session() {
let home = temp_home("resume-hit");
let workspace_id = WorkspaceId::new("ws-1");
let session_id = seed_session(&home, &workspace_id);
let resumed = resolve_resume(
&Resume::Id(session_id.0.clone()),
crate::host::session_store(&home).as_ref(),
&workspace_id,
)
.expect("the named session exists")
.expect("Id resolves to Some when the session exists");
assert_eq!(resumed.header.id, session_id);
std::fs::remove_dir_all(&home).ok();
}
#[test]
fn resume_by_id_does_not_see_a_session_in_a_different_workspace() {
let home = temp_home("resume-cross-workspace");
let other_workspace = WorkspaceId::new("ws-other");
seed_session(&home, &other_workspace);
let this_workspace = WorkspaceId::new("ws-1");
let error = resolve_resume(
&Resume::Id("session-1".to_owned()),
crate::host::session_store(&home).as_ref(),
&this_workspace,
)
.expect_err("session-1 belongs to a different workspace");
assert!(
error.contains("could not resume session session-1"),
"unexpected message: {error}"
);
std::fs::remove_dir_all(&home).ok();
}
}