glass/cli/

runner.rs

//! CLI command dispatch and session orchestration.
//!
//! Routes parsed CLI arguments to the appropriate runner: one-shot browser
//! commands, interactive TUI, or the MCP stdio server.

use super::args::{
    CertifyCommand, CheckpointCommand, Cli, Commands, DaemonCommand, KnowledgeCommand,
    KnowledgeInvalidationState, ProfileCommand, WorkflowAuthoringCommand,
};
use crate::browser::policy::{BrowserPolicy, PolicyCapability};
use crate::browser::profile::ProfileManager;
use crate::browser::session::{
    ActionKind, BatchStep, BrowserResult, BrowserSession, CheckpointV1, Cookie,
    KnowledgeConfidence, KnowledgeStore, Locator, PdfOptions, ReconciliationOptions,
    SemanticIntentExecutionRequest, SemanticIntentRequest, SemanticObservationLevel,
    SessionOptions, VerificationPredicate, VisualCaptureOptions, WaitCondition,
    WorkflowAuthoringFormat, WorkflowCheckpoint, WorkflowDefinition, WorkflowDiagnosticSeverity,
    WorkflowRecordingSession, compile_workflow, default_knowledge_store_path, diff_workflows,
    format_workflow_yaml, preview_workflow, record_semantic_events,
};
use crate::capabilities::GlassCapabilityManifest;
use crate::reliability::{
    ReliabilityFixtureManifest, ReliabilityReplayBundle, ReliabilityScenario,
    ReliabilityScenarioObservation, build_reliability_scorecard,
};
use crate::reliability_runner::{ReliabilityRunOptions, run_reliability_scenario};
use base64::Engine;
use serde::Serialize;
use serde_json::Value;
use std::collections::BTreeMap;
use std::io::Read;
use std::time::Duration;

/// Top-level command-line entry point: parses CLI arguments and dispatches
/// to the appropriate runner (one-shot, TUI, or MCP server).
pub async fn dispatch(cli: Cli) -> BrowserResult<()> {
    let policy = policy_from_cli(&cli)?;
    if cli.experimental_extensions {
        eprintln!(concat!(
            "warning: experimental extensions are enabled; extension code is untrusted, ",
            "sandbox support is required, and behavior may break"
        ));
    }
    if cli.mcp {
        return crate::mcp::server::run_mcp_server(&cli).await;
    }

    match &cli.command {
        Some(Commands::InstallChromium { update }) => {
            let path = crate::browser::chrome::download_chromium(*update).await?;
            println!("Chrome for Testing installed at {}", path.display());
            return Ok(());
        }
        Some(Commands::Capabilities) => {
            print_json(
                &GlassCapabilityManifest::for_policy_with_experimental_extensions(
                    &policy,
                    cli.experimental_extensions,
                ),
            )?;
            return Ok(());
        }
        Some(Commands::Daemon { action }) => {
            dispatch_daemon(action).await?;
            return Ok(());
        }
        Some(Commands::Doctor) => {
            dispatch_doctor(&cli, &policy).await?;
            return Ok(());
        }
        Some(Commands::Certify { action }) if !matches!(action, CertifyCommand::Run { .. }) => {
            dispatch_certify(action)?;
            return Ok(());
        }
        Some(Commands::Profiles { action }) => {
            policy.require(PolicyCapability::PersistentProfile)?;
            dispatch_profiles(action.as_ref())?;
            return Ok(());
        }
        Some(Commands::DeleteProfile { name }) => {
            policy.require(PolicyCapability::PersistentProfile)?;
            ProfileManager::new().delete_profile(name)?;
            println!("deleted profile {name}");
            return Ok(());
        }
        Some(Commands::Knowledge { action }) => {
            policy.require(PolicyCapability::PersistentProfile)?;
            dispatch_knowledge(action, cli.knowledge_store.as_deref(), &cli.profile)?;
            return Ok(());
        }
        Some(Commands::Workflow {
            action: Some(action),
            input: None,
        }) => {
            dispatch_workflow_authoring(action)?;
            return Ok(());
        }
        Some(Commands::Tui) | None if cli.prompt.is_none() => {
            return crate::tui::app::run_tui(&cli).await;
        }
        _ => {}
    }

    let options = SessionOptions {
        port: cli.port,
        chrome_path: cli.chrome_path.clone(),
        profile: cli.profile.clone(),
        incognito: cli.incognito,
        attach: cli.attach,
        target_id: cli.target_id.clone(),
        frame_id: cli.frame_id.clone(),
        headed: cli.headed,
        interaction_mode: cli.interaction,
        audit: cli.audit,
        policy: None,
    };
    let session = BrowserSession::start_with_policy(&options, policy).await?;
    let result = if let Some(prompt) = &cli.prompt {
        run_prompt(&session, prompt).await
    } else if let Some(command) = &cli.command {
        run_command(&session, command).await
    } else {
        Ok(())
    };
    if let Err(error) = &result
        && cli.trace_on_error
    {
        let trace = session
            .failure_trace_for(
                cli_trace_action(cli.command.as_ref(), cli.prompt.as_deref()),
                error.to_string(),
            )
            .await;
        eprintln!("{}", serde_json::to_string(&trace)?);
    }
    let close_result = session.close().await;
    result?;
    close_result
}

async fn dispatch_daemon(action: &DaemonCommand) -> BrowserResult<()> {
    match action {
        DaemonCommand::Start { socket, status } => {
            print_json(&crate::daemon::start(socket.as_deref(), status.as_deref()).await?)?;
        }
        DaemonCommand::Status { socket, status } => {
            print_json(&crate::daemon::status(
                socket.as_deref(),
                status.as_deref(),
            )?)?;
        }
        DaemonCommand::Stop { socket, status } => {
            crate::daemon::stop(socket.as_deref(), status.as_deref())?;
            print_json(&serde_json::json!({"status": "stopped"}))?;
        }
        DaemonCommand::Doctor { socket, status } => {
            print_json(&crate::daemon::doctor(
                socket.as_deref(),
                status.as_deref(),
            )?)?;
        }
        DaemonCommand::Logs { status } => {
            print_json(&crate::daemon::logs(status.as_deref())?)?;
        }
        DaemonCommand::AcknowledgeRecovery {
            status,
            request_ids,
        } => {
            print_json(&crate::daemon::acknowledge_recovery(
                status.as_deref(),
                request_ids,
            )?)?;
        }
        DaemonCommand::Serve { socket, status } => {
            crate::daemon::serve(socket, status).await?;
        }
    }
    Ok(())
}

async fn dispatch_doctor(cli: &Cli, policy: &BrowserPolicy) -> BrowserResult<()> {
    let chrome_path =
        crate::browser::chrome::resolve_chrome_path(None).map(|path| path.display().to_string());
    let (daemon_socket, daemon_status) = crate::daemon::default_paths();
    let daemon = crate::daemon::doctor(Some(&daemon_socket), Some(&daemon_status))?;
    let profiles = ProfileManager::new().list_profiles().unwrap_or_default();
    let knowledge_path = cli
        .knowledge_store
        .clone()
        .unwrap_or_else(|| default_knowledge_store_path(&cli.profile));
    let knowledge_exists = knowledge_path.is_file();
    let manifest = GlassCapabilityManifest::for_policy_with_experimental_extensions(
        policy,
        cli.experimental_extensions,
    );
    let platform_supported = manifest.constraints.platform != "unsupported";
    print_json(&serde_json::json!({
        "status": if chrome_path.is_some() && platform_supported { "ready" } else { "degraded" },
        "version": env!("CARGO_PKG_VERSION"),
        "platform": manifest.constraints.platform,
        "browser": {
            "family": manifest.constraints.browser_family,
            "chromeAvailable": chrome_path.is_some(),
            "chromePath": chrome_path,
            "cdpPort": cli.port,
            "cdpReachable": crate::browser::chrome::check_chrome_health(cli.port).await,
        },
        "daemon": daemon,
        "profiles": {
            "count": profiles.len(),
            "names": profiles,
        },
        "policy": {
            "preset": manifest.constraints.policy,
            "capabilities": manifest.capabilities,
        },
        "knowledgeStore": {
            "path": knowledge_path,
            "exists": knowledge_exists,
        },
        "extensions": {
            "enabled": manifest.capabilities.get("extensions").copied().unwrap_or(false),
            "loader": "disabled",
        },
    }))?;
    Ok(())
}

fn cli_trace_action(command: Option<&Commands>, prompt: Option<&str>) -> ActionKind {
    if let Some(prompt) = prompt {
        let lower = prompt.trim().to_ascii_lowercase();
        return if lower.starts_with("double click ") {
            ActionKind::DoubleClick
        } else if lower.starts_with("click ") {
            ActionKind::Click
        } else if lower.starts_with("type ") {
            ActionKind::Type
        } else {
            ActionKind::Click
        };
    }
    match command {
        Some(Commands::DoubleClick { .. }) => ActionKind::DoubleClick,
        Some(Commands::ClickExpectPopup { .. }) => ActionKind::ClickExpectPopup,
        Some(Commands::Click { .. })
        | Some(Commands::Preflight { .. })
        | Some(Commands::ClickAt { .. }) => ActionKind::Click,
        Some(Commands::Hover { .. }) => ActionKind::Hover,
        Some(Commands::Drag { .. }) => ActionKind::Drag,
        Some(Commands::Type { .. }) => ActionKind::Type,
        Some(Commands::Key { .. }) => ActionKind::KeyPress,
        Some(Commands::KeyDown { .. }) => ActionKind::KeyDown,
        Some(Commands::KeyUp { .. }) => ActionKind::KeyUp,
        Some(Commands::Shortcut { .. }) => ActionKind::Shortcut,
        Some(Commands::Clear { .. }) => ActionKind::Clear,
        Some(Commands::Check { .. }) => ActionKind::Check,
        Some(Commands::Uncheck { .. }) => ActionKind::Uncheck,
        Some(Commands::Select { .. }) => ActionKind::Select,
        Some(Commands::Upload { .. }) => ActionKind::Upload,
        Some(Commands::Scroll { .. }) => ActionKind::Scroll,
        _ => ActionKind::Click,
    }
}

fn dispatch_profiles(action: Option<&ProfileCommand>) -> BrowserResult<()> {
    let manager = ProfileManager::new();
    match action {
        None | Some(ProfileCommand::List) => {
            let profiles = manager.list_profiles()?;
            if profiles.is_empty() {
                println!("no saved profiles");
            } else {
                for profile in profiles {
                    println!("{profile}");
                }
            }
        }
        Some(ProfileCommand::Create { name }) => {
            manager.create_profile(name)?;
            println!("created profile {name}");
        }
        Some(ProfileCommand::Delete { name }) => {
            manager.delete_profile(name)?;
            println!("deleted profile {name}");
        }
    }
    Ok(())
}

fn dispatch_certify(action: &CertifyCommand) -> BrowserResult<()> {
    match action {
        CertifyCommand::Run { .. } => {
            unreachable!("browser-backed reliability runs are handled after startup")
        }
        CertifyCommand::Plan { scenario, fixture } => {
            let scenario = ReliabilityScenario::from_value(read_json_input(Some(scenario))?)?;
            let fixture =
                ReliabilityFixtureManifest::from_json(&std::fs::read_to_string(fixture)?)?;
            let plan = scenario.execution_plan(&fixture)?;
            print_json(&serde_json::json!({
                "status": "valid",
                "plan": plan,
            }))?;
        }
        CertifyCommand::Release {
            version,
            scenarios,
            observations,
            replays,
        } => {
            let scenario_value = read_json_input(Some(scenarios))?;
            let scenarios: Vec<ReliabilityScenario> = if scenario_value.is_array() {
                serde_json::from_value(scenario_value)?
            } else {
                vec![serde_json::from_value(scenario_value)?]
            };
            let observations: Vec<ReliabilityScenarioObservation> =
                serde_json::from_value(read_json_input(Some(observations))?)?;
            let replays_validated = if let Some(replays) = replays {
                let replay_value = read_json_input(Some(replays))?;
                let replay_values: Vec<Value> = if replay_value.is_array() {
                    serde_json::from_value(replay_value)?
                } else {
                    vec![replay_value]
                };
                let mut replay_by_id = BTreeMap::new();
                for replay_value in replay_values {
                    let scenario_id = replay_value
                        .get("scenarioId")
                        .and_then(Value::as_str)
                        .ok_or("replay bundle is missing scenarioId")?
                        .to_string();
                    let scenario = scenarios
                        .iter()
                        .find(|scenario| scenario.id == scenario_id)
                        .ok_or_else(|| {
                            format!("replay references unknown scenario {scenario_id}")
                        })?;
                    let bundle = ReliabilityReplayBundle::from_value(replay_value, scenario)?;
                    if replay_by_id.insert(scenario_id.clone(), bundle).is_some() {
                        return Err(format!("duplicate replay for scenario {scenario_id}").into());
                    }
                }
                if replay_by_id.len() != scenarios.len() {
                    return Err("replay evidence must cover every scenario".into());
                }
                let observations_by_id: BTreeMap<_, _> = observations
                    .iter()
                    .map(|observation| (observation.scenario_id.as_str(), observation))
                    .collect();
                for (scenario_id, replay) in &replay_by_id {
                    let observation =
                        observations_by_id
                            .get(scenario_id.as_str())
                            .ok_or_else(|| {
                                format!("replay has no matching observation for {scenario_id}")
                            })?;
                    if serde_json::to_value(&replay.observation)?
                        != serde_json::to_value(observation)?
                    {
                        return Err(format!("replay observation differs for {scenario_id}").into());
                    }
                }
                true
            } else {
                false
            };
            let scorecard = build_reliability_scorecard(&scenarios, &observations)?;
            let certified = scorecard.certified;
            print_json(&serde_json::json!({
                "status": if certified { "certified" } else { "blocked" },
                "version": version,
                "tool": {"name": "glass", "version": env!("CARGO_PKG_VERSION")},
                "replaysValidated": replays_validated,
                "gate": &scorecard.gate,
                "scorecard": &scorecard,
            }))?;
            if !certified {
                return Err("reliability certification blocked".into());
            }
        }
        CertifyCommand::Replay { scenario, input } => {
            let scenario = ReliabilityScenario::from_value(read_json_input(Some(scenario))?)?;
            let bundle =
                ReliabilityReplayBundle::from_value(read_json_input(Some(input))?, &scenario)?;
            print_json(&serde_json::json!({
                "status": "valid",
                "scenarioId": &bundle.scenario_id,
                "replayHash": bundle.content_hash(&scenario)?,
            }))?;
        }
        CertifyCommand::ReplayDiff {
            scenario,
            before,
            after,
        } => {
            let scenario = ReliabilityScenario::from_value(read_json_input(Some(scenario))?)?;
            let before =
                ReliabilityReplayBundle::from_value(read_json_input(Some(before))?, &scenario)?;
            let after =
                ReliabilityReplayBundle::from_value(read_json_input(Some(after))?, &scenario)?;
            let comparison = before.compare(&after, &scenario)?;
            print_json(&serde_json::json!({
                "status": if comparison.equivalent { "equivalent" } else { "changed" },
                "comparison": comparison,
            }))?;
        }
    }
    Ok(())
}

async fn dispatch_certify_run(
    session: &BrowserSession,
    scenario_path: &std::path::Path,
    fixture_path: &std::path::Path,
    url: &str,
    workflow_root: &std::path::Path,
    inputs_path: Option<&std::path::Path>,
    output: Option<&std::path::Path>,
) -> BrowserResult<()> {
    let scenario = ReliabilityScenario::from_json(&std::fs::read_to_string(scenario_path)?)?;
    let fixture = ReliabilityFixtureManifest::from_json(&std::fs::read_to_string(fixture_path)?)?;
    let inputs: BTreeMap<String, Value> = match inputs_path {
        Some(path) => serde_json::from_str(&std::fs::read_to_string(path)?)
            .map_err(|error| format!("invalid workflow inputs: {error}"))?,
        None => BTreeMap::new(),
    };
    session.navigate(url).await?;
    let evidence = run_reliability_scenario(
        session,
        &scenario,
        &fixture,
        &ReliabilityRunOptions {
            workflow_root: workflow_root.to_path_buf(),
            inputs,
        },
    )
    .await?;
    let value = serde_json::json!({
        "observation": evidence.observation,
        "replay": evidence.replay,
    });
    if let Some(output) = output {
        tokio::fs::write(output, serde_json::to_vec_pretty(&value)?).await?;
    }
    print_json(&value)?;
    Ok(())
}

fn dispatch_knowledge(
    action: &KnowledgeCommand,
    explicit_path: Option<&std::path::Path>,
    profile: &str,
) -> BrowserResult<()> {
    ProfileManager::validate_name(profile)?;
    let path = explicit_path
        .map(std::path::Path::to_path_buf)
        .unwrap_or_else(|| default_knowledge_store_path(profile));
    let mut store = KnowledgeStore::open(path)?;
    match action {
        KnowledgeCommand::List => print_json(store.snapshot())?,
        KnowledgeCommand::Show { record_id } => {
            let record = store
                .get(record_id)
                .ok_or_else(|| format!("knowledge record not found: {record_id}"))?;
            print_json(record)?;
        }
        KnowledgeCommand::Explain { record_id } => {
            let record = store
                .get(record_id)
                .ok_or_else(|| format!("knowledge record not found: {record_id}"))?;
            print_json(&serde_json::json!({
                "recordId": &record.record_id,
                "kind": record.kind,
                "confidence": record.confidence,
                "scope": &record.scope,
                "source": &record.source,
                "invalidation": &record.invalidation,
                "history": &record.history,
                "contentHash": record.content_hash()?,
                "assessment": "requires a fresh observation; stored knowledge is never an authorization",
            }))?;
        }
        KnowledgeCommand::Stats => print_json(&store.stats()?)?,
        KnowledgeCommand::Export { output } => {
            let canonical = store.snapshot().to_canonical_json()?;
            if let Some(output) = output {
                std::fs::write(output, canonical)?;
                println!("exported knowledge to {}", output.display());
            } else {
                println!("{canonical}");
            }
        }
        KnowledgeCommand::Import { input } => {
            let snapshot = serde_json::from_value(read_json_input(Some(input))?)
                .map_err(|error| format!("invalid knowledge snapshot: {error}"))?;
            store.replace_snapshot(snapshot)?;
            print_json(&store.stats()?)?;
        }
        KnowledgeCommand::Invalidate {
            record_id,
            state,
            reason,
            observed_at,
        } => {
            let next = match state {
                KnowledgeInvalidationState::Stale => KnowledgeConfidence::Stale,
                KnowledgeInvalidationState::Contradicted => KnowledgeConfidence::Contradicted,
                KnowledgeInvalidationState::Quarantined => KnowledgeConfidence::Quarantined,
            };
            let change = store.transition(
                record_id,
                next,
                reason
                    .clone()
                    .unwrap_or_else(|| "caller invalidated record".into()),
                observed_at
                    .clone()
                    .unwrap_or_else(|| chrono::Utc::now().to_rfc3339()),
                false,
            )?;
            print_json(&change)?;
        }
        KnowledgeCommand::Purge { origin } => print_json(&store.purge_origin(origin)?)?,
    }
    Ok(())
}

fn dispatch_workflow_authoring(action: &WorkflowAuthoringCommand) -> BrowserResult<()> {
    match action {
        WorkflowAuthoringCommand::Compile { input, output } => {
            let source = std::fs::read_to_string(input)?;
            let document = compile_workflow(&source, authoring_format(input))?;
            if let Some(output) = output {
                std::fs::write(output, &document.canonical_json)?;
                println!("compiled workflow to {}", output.display());
            } else {
                println!("{}", document.canonical_json);
            }
            if document
                .diagnostics
                .iter()
                .any(|diagnostic| diagnostic.severity == WorkflowDiagnosticSeverity::Error)
            {
                return Err("workflow compilation produced error diagnostics".into());
            }
        }
        WorkflowAuthoringCommand::Format { input, output } => {
            let source = std::fs::read_to_string(input)?;
            let document = compile_workflow(&source, authoring_format(input))?;
            let formatted = format_workflow_yaml(&document.definition)?;
            if let Some(output) = output {
                std::fs::write(output, formatted)?;
                println!("formatted workflow to {}", output.display());
            } else {
                print!("{formatted}");
            }
        }
        WorkflowAuthoringCommand::Preview { input } => {
            let source = std::fs::read_to_string(input)?;
            let document = compile_workflow(&source, authoring_format(input))?;
            let preview = preview_workflow(&document.definition)?;
            print_json(&serde_json::json!({
                "preview": preview,
                "diagnostics": document.diagnostics,
            }))?;
        }
        WorkflowAuthoringCommand::Diff { before, after } => {
            let before_source = std::fs::read_to_string(before)?;
            let after_source = std::fs::read_to_string(after)?;
            let before_document = compile_workflow(&before_source, authoring_format(before))?;
            let after_document = compile_workflow(&after_source, authoring_format(after))?;
            let diff = diff_workflows(&before_document.definition, &after_document.definition)?;
            print_json(&serde_json::json!({
                "diff": diff,
                "beforeDiagnostics": before_document.diagnostics,
                "afterDiagnostics": after_document.diagnostics,
            }))?;
        }
        WorkflowAuthoringCommand::Record { input, output } => {
            let value = read_json_input(input.as_ref())?;
            let session: WorkflowRecordingSession = serde_json::from_value(value)?;
            let draft = record_semantic_events(session)?;
            let serialized = serde_json::to_string_pretty(&draft)?;
            if let Some(output) = output {
                std::fs::write(output, serialized)?;
                println!("recorded workflow draft to {}", output.display());
            } else {
                println!("{serialized}");
            }
        }
        WorkflowAuthoringCommand::Validate { input } => {
            let source = std::fs::read_to_string(input)?;
            let document = compile_workflow(&source, authoring_format(input))?;
            print_json(&document)?;
        }
        WorkflowAuthoringCommand::Lint {
            input,
            warnings_as_errors,
        } => {
            let source = std::fs::read_to_string(input)?;
            let document = compile_workflow(&source, authoring_format(input))?;
            let failed = document.diagnostics.iter().any(|diagnostic| {
                diagnostic.severity == WorkflowDiagnosticSeverity::Error
                    || (*warnings_as_errors
                        && diagnostic.severity == WorkflowDiagnosticSeverity::Warning)
            });
            print_json(&document.diagnostics)?;
            if failed {
                return Err("workflow lint failed".into());
            }
        }
    }
    Ok(())
}

fn authoring_format(path: &std::path::Path) -> WorkflowAuthoringFormat {
    if path
        .extension()
        .and_then(|extension| extension.to_str())
        .is_some_and(|extension| extension.eq_ignore_ascii_case("json"))
    {
        WorkflowAuthoringFormat::Json
    } else {
        WorkflowAuthoringFormat::Yaml
    }
}

async fn run_command(session: &BrowserSession, command: &Commands) -> BrowserResult<()> {
    match command {
        Commands::Certify {
            action:
                CertifyCommand::Run {
                    scenario,
                    fixture,
                    url,
                    workflow_root,
                    inputs,
                    output,
                },
        } => {
            dispatch_certify_run(
                session,
                scenario,
                fixture,
                url,
                workflow_root,
                inputs.as_deref(),
                output.as_deref(),
            )
            .await?;
        }
        Commands::Capabilities
        | Commands::Daemon { .. }
        | Commands::Doctor
        | Commands::Certify { .. }
        | Commands::Knowledge { .. } => {
            unreachable!("offline commands are handled before browser startup")
        }
        Commands::Navigate {
            url,
            timeout_ms,
            expected_revision,
        } => {
            if let Some(expected_revision) = expected_revision {
                print_json(
                    &session
                        .navigate_with_revision(
                            url,
                            Duration::from_millis(*timeout_ms),
                            *expected_revision,
                        )
                        .await?,
                )?;
            } else {
                let page = session
                    .navigate_with_deadline(url, Duration::from_millis(*timeout_ms))
                    .await?;
                print_json(&page)?;
            }
        }
        Commands::Click {
            target,
            expected_revision,
        } => {
            if let Some(expected_revision) = expected_revision {
                print_json(
                    &session
                        .click_with_revision(target, *expected_revision)
                        .await?,
                )?;
            } else {
                print_json(&session.click(target).await?)?;
            }
        }
        Commands::Preflight { target, action } => {
            print_json(&session.preflight_with_action(target, *action).await)?;
        }
        Commands::ClickAt { x, y } => {
            print_json(&session.click_at(*x, *y).await?)?;
        }
        Commands::ClickExpectPopup {
            target,
            expected_revision,
        } => {
            print_json(
                &session
                    .click_expect_popup_with_revision(target, *expected_revision)
                    .await?,
            )?;
        }
        Commands::DoubleClick {
            target,
            expected_revision,
        } => {
            print_json(
                &session
                    .double_click_with_revision(target, *expected_revision)
                    .await?,
            )?;
        }
        Commands::Hover { target } => print_json(&session.hover(target).await?)?,
        Commands::Drag {
            source,
            destination,
            expected_revision,
        } => {
            print_json(
                &session
                    .drag_with_revision(source, destination, *expected_revision)
                    .await?,
            )?;
        }
        Commands::Type {
            text,
            target,
            expected_revision,
        } => {
            print_json(
                &session
                    .type_text_with_expected_revision(text, target.as_deref(), *expected_revision)
                    .await?,
            )?;
        }
        Commands::Key {
            key,
            expected_revision,
        } => print_json(
            &session
                .key_press_with_revision(key, *expected_revision)
                .await?,
        )?,
        Commands::KeyDown {
            key,
            expected_revision,
        } => print_json(
            &session
                .key_down_with_revision(key, *expected_revision)
                .await?,
        )?,
        Commands::KeyUp {
            key,
            expected_revision,
        } => print_json(
            &session
                .key_up_with_revision(key, *expected_revision)
                .await?,
        )?,
        Commands::Shortcut {
            shortcut,
            expected_revision,
        } => print_json(
            &session
                .shortcut_with_revision(shortcut, *expected_revision)
                .await?,
        )?,
        Commands::Clear {
            target,
            expected_revision,
        } => print_json(
            &session
                .clear_with_revision(target, *expected_revision)
                .await?,
        )?,
        Commands::Check {
            target,
            expected_revision,
        } => print_json(
            &session
                .check_with_revision(target, *expected_revision)
                .await?,
        )?,
        Commands::Uncheck {
            target,
            expected_revision,
        } => print_json(
            &session
                .uncheck_with_revision(target, *expected_revision)
                .await?,
        )?,
        Commands::Select {
            target,
            value,
            expected_revision,
        } => {
            print_json(
                &session
                    .select_option_with_revision(target, value, *expected_revision)
                    .await?,
            )?;
        }
        Commands::Upload {
            target,
            files,
            expected_revision,
        } => {
            print_json(
                &session
                    .upload_files_with_revision(target, files, *expected_revision)
                    .await?,
            )?;
        }
        Commands::Screenshot {
            output,
            format,
            quality,
            scale,
            full_page,
            clip,
            target,
        } => {
            let output = session
                .policy()
                .require_output_path(std::path::Path::new(output))?;
            let capture = session
                .capture_visual(&VisualCaptureOptions {
                    format: *format,
                    quality: *quality,
                    scale: *scale,
                    clip: *clip,
                    full_page: *full_page,
                    target: target.clone(),
                })
                .await?;
            let mut source = base64::read::DecoderReader::new(
                capture.data.as_bytes(),
                &base64::engine::general_purpose::STANDARD,
            );
            let mut file = std::fs::File::create(&output)?;
            std::io::copy(&mut source, &mut file)?;
            println!("wrote {}", output.display());
            print_json(&capture.metadata)?;
        }
        Commands::Text => println!("{}", session.text().await?),
        Commands::Dom => print_json(&session.deep_dom().await?)?,
        Commands::Observe {
            deep_dom,
            screenshot,
            form_values,
            semantic_level,
            region,
        } => {
            if let Some(level_name) = semantic_level {
                if *deep_dom || *screenshot || *form_values {
                    return Err(
                        "semantic observation cannot be combined with deep DOM, screenshot, or form values"
                            .into(),
                    );
                }
                let level = parse_semantic_level(level_name)?;
                if let Some(region_id) = region {
                    let page = session.semantic_observe(level).await?;
                    print_json(
                        &session
                            .semantic_expand_region(region_id, page.revision, level)
                            .await?,
                    )?;
                } else {
                    print_json(&session.semantic_observe(level).await?)?;
                }
                return Ok(());
            }
            let context = match (*deep_dom, *screenshot, *form_values) {
                (false, false, false) => session.observe().await?,
                (true, false, false) => session.observe_with_dom().await?,
                (false, true, false) => session.observe_with_screenshot().await?,
                (true, true, false) => session.observe_with_dom_and_screenshot().await?,
                (false, false, true) => session.observe_with_form_values().await?,
                _ => return Err("form values can only be combined with compact observe".into()),
            };
            print_json(&context)?;
        }
        Commands::Scroll {
            dx,
            dy,
            expected_revision,
        } => {
            print_json(
                &session
                    .scroll_with_revision(*dx, *dy, *expected_revision)
                    .await?,
            )?;
        }
        Commands::Wait {
            condition,
            timeout_ms,
        } => {
            print_json(
                &session
                    .wait(
                        WaitCondition::parse(condition)?,
                        Duration::from_millis(*timeout_ms),
                    )
                    .await?,
            )?;
        }
        Commands::Diagnostics { duration_ms } => print_json(
            &session
                .diagnostics(Duration::from_millis(*duration_ms))
                .await?,
        )?,
        Commands::AcceptDialog => {
            session.accept_dialog().await?;
            print_json(&serde_json::json!({"dialog": "accepted"}))?;
        }
        Commands::DismissDialog => {
            session.dismiss_dialog().await?;
            print_json(&serde_json::json!({"dialog": "dismissed"}))?;
        }
        Commands::DismissConsent => print_json(&session.dismiss_consent().await?)?,
        Commands::Download {
            destination,
            timeout_ms,
        } => print_json(
            &session
                .wait_for_download(destination, Duration::from_millis(*timeout_ms))
                .await?,
        )?,
        Commands::Targets => print_json(&session.list_targets().await?)?,
        Commands::NewTarget { url } => print_json(&session.create_target(url).await?)?,
        Commands::SelectTarget { id } => print_json(&session.select_target(id).await?)?,
        Commands::CloseTarget { id } => {
            session.close_target(id).await?;
            print_json(&serde_json::json!({"closed": id}))?;
        }
        Commands::Frames => print_json(&session.list_frames().await?)?,
        Commands::SelectFrame { id } => print_json(&session.select_frame(id).await?)?,
        Commands::Evaluate { expression } => {
            print_json(&session.evaluate(expression).await?)?;
        }
        Commands::Cookies => print_json(&session.cookies().await?)?,
        Commands::ExportCookies { output } => {
            let cookies = session.cookies().await?;
            let bytes = serde_json::to_vec_pretty(&cookies)?;
            tokio::fs::write(output, bytes).await?;
            println!("cookies exported to {}", output.display());
        }
        Commands::ImportCookies { input } => {
            const MAX_COOKIE_FILE_BYTES: u64 = 512 * 1024;
            let metadata = tokio::fs::metadata(input).await?;
            if metadata.len() > MAX_COOKIE_FILE_BYTES {
                return Err(format!(
                    "cookie file exceeds the {}-byte limit",
                    MAX_COOKIE_FILE_BYTES
                )
                .into());
            }
            let bytes = tokio::fs::read(input).await?;
            let cookies: Vec<Cookie> = serde_json::from_slice(&bytes)?;
            session.set_cookies(&cookies).await?;
            println!("{} cookies imported", cookies.len());
        }
        Commands::Pdf { output, background } => {
            let mut opts = PdfOptions::letter();
            if *background {
                opts.print_background = Some(true);
            }
            let data = session.print_to_pdf(&opts).await?;
            let bytes = base64::engine::general_purpose::STANDARD.decode(&data)?;
            tokio::fs::write(&output, &bytes).await?;
            println!("PDF saved to {output} ({} bytes)", bytes.len());
        }
        Commands::FillForm {
            fields,
            expected_revision,
        } => {
            let parsed: Vec<serde_json::Value> = serde_json::from_str(fields)?;
            let field_refs: Vec<(String, String)> = parsed
                .iter()
                .map(|v| {
                    (
                        v["target"].as_str().unwrap_or("").to_string(),
                        v["value"].as_str().unwrap_or("").to_string(),
                    )
                })
                .collect();
            let field_slices: Vec<(&str, &str)> = field_refs
                .iter()
                .map(|(t, v)| (t.as_str(), v.as_str()))
                .collect();
            print_json(
                &session
                    .fill_form_with_expected_revision(&field_slices, *expected_revision)
                    .await?,
            )?;
        }
        Commands::Batch {
            input,
            atomic,
            mode,
            expected_revision,
        } => {
            let payload = read_json_input(input.as_ref())?;
            let steps_value = payload.get("steps").cloned().unwrap_or(payload);
            let steps: Vec<BatchStep> = serde_json::from_value(steps_value)
                .map_err(|error| format!("invalid batch document: {error}"))?;
            print_json(
                &session
                    .run_batch_with_mode(&steps, *atomic, *mode, *expected_revision)
                    .await?,
            )?;
        }
        Commands::Workflow {
            action: None,
            input,
        } => {
            let payload = read_json_input(input.as_ref())?;
            let workflow_value = payload
                .get("workflow")
                .cloned()
                .unwrap_or_else(|| payload.clone());
            let inputs_value = payload
                .get("inputs")
                .cloned()
                .unwrap_or_else(|| Value::Object(serde_json::Map::new()));
            let workflow = WorkflowDefinition::from_value(workflow_value)
                .map_err(|error| format!("invalid workflow: {error}"))?;
            let inputs: BTreeMap<String, Value> = serde_json::from_value(inputs_value)
                .map_err(|error| format!("invalid workflow inputs: {error}"))?;
            print_json(&session.run_workflow(&workflow, &inputs).await?)?;
        }
        Commands::Workflow {
            action: Some(_), ..
        } => unreachable!("offline workflow authoring commands are handled before browser startup"),
        Commands::WorkflowResume {
            workflow,
            checkpoint,
            inputs,
        } => {
            let workflow = WorkflowDefinition::from_value(read_json_input(Some(workflow))?)
                .map_err(|error| format!("invalid workflow: {error}"))?;
            let checkpoint: WorkflowCheckpoint =
                serde_json::from_value(read_json_input(Some(checkpoint))?)
                    .map_err(|error| format!("invalid workflow checkpoint: {error}"))?;
            let inputs: BTreeMap<String, Value> = match inputs {
                Some(path) => serde_json::from_value(read_json_input(Some(path))?)
                    .map_err(|error| format!("invalid workflow inputs: {error}"))?,
                None => BTreeMap::new(),
            };
            print_json(
                &session
                    .resume_workflow(&workflow, &inputs, &checkpoint)
                    .await?,
            )?;
        }
        Commands::ResolveIntent { input } => {
            let request = SemanticIntentRequest::from_json(&serde_json::to_string(
                &read_json_input(input.as_ref())?,
            )?)?;
            print_json(&session.resolve_intent(&request).await?)?;
        }
        Commands::ExecuteIntent { input } => {
            let execution = SemanticIntentExecutionRequest::from_json(&serde_json::to_string(
                &read_json_input(input.as_ref())?,
            )?)?;
            print_json(&session.execute_intent(&execution).await?)?;
        }
        Commands::Verify {
            predicate,
            timeout_ms,
        } => {
            let predicate: VerificationPredicate = serde_json::from_str(predicate)
                .map_err(|error| format!("invalid verification predicate: {error}"))?;
            print_json(
                &session
                    .verify(predicate, Duration::from_millis(*timeout_ms))
                    .await?,
            )?;
        }
        Commands::ReconcileRefs {
            from_revision,
            hints,
            scope,
            refs,
        } => {
            let options = ReconciliationOptions {
                hints: hints
                    .iter()
                    .map(|hint| Locator::parse(hint))
                    .collect::<BrowserResult<Vec<_>>>()?,
                scope_ref: scope.clone(),
            };
            print_json(
                &session
                    .reconcile_references_with_options(*from_revision, refs, &options)
                    .await?,
            )?;
        }
        Commands::ObserveDelta => {
            print_json(&session.observe_delta().await?)?;
        }
        Commands::Checkpoint { action } => match action {
            CheckpointCommand::Export => print_json(&session.export_checkpoint().await?)?,
            CheckpointCommand::Import { input } => {
                let checkpoint: CheckpointV1 =
                    serde_json::from_value(read_json_input(input.as_ref())?)
                        .map_err(|error| format!("invalid checkpoint: {error}"))?;
                session.import_checkpoint(&checkpoint).await?;
                print_json(&serde_json::json!({"status": "checkpoint_imported"}))?;
            }
        },
        Commands::ClipboardRead => {
            let text = session.clipboard_read().await?;
            println!("{text}");
        }
        Commands::ClipboardWrite { text } => {
            session.clipboard_write(text).await?;
            println!("Text written to clipboard");
        }
        Commands::Tui
        | Commands::InstallChromium { .. }
        | Commands::Profiles { .. }
        | Commands::DeleteProfile { .. } => {
            unreachable!("handled before starting a browser session")
        }
    }
    Ok(())
}

fn parse_semantic_level(value: &str) -> BrowserResult<SemanticObservationLevel> {
    match value {
        "summary" => Ok(SemanticObservationLevel::Summary),
        "interactive" => Ok(SemanticObservationLevel::Interactive),
        "structured" => Ok(SemanticObservationLevel::Structured),
        "detailed" => Ok(SemanticObservationLevel::Detailed),
        "raw" => Ok(SemanticObservationLevel::Raw),
        _ => Err("expected summary, interactive, structured, detailed, or raw".into()),
    }
}

fn read_json_input(path: Option<&std::path::PathBuf>) -> BrowserResult<serde_json::Value> {
    let mut input = String::new();
    match path {
        Some(path) => std::fs::File::open(path)?.read_to_string(&mut input)?,
        None => std::io::stdin().read_to_string(&mut input)?,
    };
    Ok(serde_json::from_str(&input)?)
}

pub(crate) fn policy_from_cli(cli: &Cli) -> BrowserResult<BrowserPolicy> {
    Ok(BrowserPolicy::new(
        cli.policy,
        std::env::current_dir()?,
        cli.policy_allow.iter().copied(),
        cli.policy_confirm.iter().copied(),
    )?
    .with_host_rules(
        cli.policy_allow_host.iter().cloned(),
        cli.policy_deny_host.iter().cloned(),
    )?
    .with_confirmation_tokens(cli.policy_confirm_once.iter().copied())?)
}

async fn run_prompt(session: &BrowserSession, prompt: &str) -> BrowserResult<()> {
    let trimmed = prompt.trim();
    let lower = trimmed.to_lowercase();

    for prefix in ["navigate to ", "go to ", "open "] {
        if lower.starts_with(prefix) {
            let page = session.navigate(trimmed[prefix.len()..].trim()).await?;
            print_json(&page)?;
            return Ok(());
        }
    }
    if let Some(rest) = lower.strip_prefix("click ") {
        let target = &trimmed[trimmed.len() - rest.len()..];
        print_json(&session.click(target.trim_matches('"')).await?)?;
        return Ok(());
    }
    if let Some(rest) = lower.strip_prefix("double click ") {
        let target = &trimmed[trimmed.len() - rest.len()..];
        print_json(&session.double_click(target.trim_matches('"')).await?)?;
        return Ok(());
    }
    if let Some(rest) = lower.strip_prefix("type ") {
        let text = &trimmed[trimmed.len() - rest.len()..];
        print_json(&session.type_text(text.trim_matches('"'), None).await?)?;
        return Ok(());
    }
    if lower.starts_with("screenshot") {
        let output = trimmed
            .split_once(char::is_whitespace)
            .map(|(_, value)| value.trim())
            .filter(|value| !value.is_empty())
            .unwrap_or("screenshot.png");
        let output = session
            .policy()
            .require_output_path(std::path::Path::new(output))?;
        std::fs::write(&output, session.screenshot_png().await?)?;
        println!("wrote {}", output.display());
        return Ok(());
    }
    if matches!(
        lower.as_str(),
        "text" | "get text" | "page text" | "get content"
    ) {
        println!("{}", session.text().await?);
        return Ok(());
    }
    if matches!(lower.as_str(), "dom" | "snapshot" | "get dom") {
        print_json(&session.deep_dom().await?)?;
        return Ok(());
    }
    if matches!(lower.as_str(), "observe" | "context") {
        print_json(&session.observe().await?)?;
        return Ok(());
    }

    print_json(&session.evaluate(trimmed).await?)?;
    Ok(())
}

fn print_json<T: Serialize + ?Sized>(value: &T) -> BrowserResult<()> {
    println!("{}", compact_json(value)?);
    Ok(())
}

fn compact_json<T: Serialize + ?Sized>(value: &T) -> BrowserResult<String> {
    let mut value = serde_json::to_value(value)?;
    let payload = serde_json::to_vec(&value)?;
    let payload_bytes = payload.len();
    if let Some(object) = value.as_object_mut() {
        object.insert(
            "contextCost".to_string(),
            serde_json::json!({
                "payloadBytes": payload_bytes,
                "estimatedTokens": payload_bytes.div_ceil(4)
            }),
        );
    }
    Ok(serde_json::to_string(&value)?)
}

#[cfg(test)]
mod tests {
    use super::*;
    use serde_json::json;

    #[test]
    fn structured_cli_output_is_compact_json() {
        let output = compact_json(&json!({
            "page": {"title": "Glass", "url": "https://example.com"},
            "items": [1, 2]
        }))
        .unwrap();

        let parsed = serde_json::from_str::<serde_json::Value>(&output).unwrap();
        assert!(!output.contains('\n'));
        assert_eq!(parsed["items"], json!([1, 2]));
        assert!(parsed["contextCost"]["payloadBytes"].as_u64().unwrap() > 0);
        assert!(parsed["contextCost"]["estimatedTokens"].as_u64().unwrap() > 0);
    }
}