use clap::{Parser, Subcommand, ValueEnum};
use std::path::PathBuf;
use crate::browser::policy::{PolicyCapability, PolicyPreset};
use crate::browser::session::{
BatchMode, InteractionMode, PreflightAction, VisualClip, VisualFormat,
};
use crate::results::ResponseMode;
#[derive(Debug, Parser)]
#[command(
name = "glass",
version,
about = "Semantic browser execution for humans and agents",
after_help = "Start here:\n glass doctor Check browser and local runtime support\n glass Open the interactive terminal workspace\n glass navigate https://example.com Open a page in one bounded operation\n glass observe --level interactive Inspect current semantic understanding\n glass task compile task.json ir.json Compile a deterministic browser-free task\n\nUse `glass <command> --help` for command-specific options and examples."
)]
pub struct Cli {
#[arg(long, global = true)]
pub yolo: bool,
#[arg(long, global = true, value_enum, default_value_t = PolicyPreset::Development)]
pub policy: PolicyPreset,
#[arg(long = "policy-allow", global = true, value_enum)]
pub policy_allow: Vec<PolicyCapability>,
#[arg(long = "policy-confirm", global = true, value_enum)]
pub policy_confirm: Vec<PolicyCapability>,
#[arg(long = "policy-confirm-once", global = true, value_enum)]
pub policy_confirm_once: Vec<PolicyCapability>,
#[arg(long, global = true)]
pub experimental_extensions: bool,
#[arg(long = "policy-allow-host", global = true)]
pub policy_allow_host: Vec<String>,
#[arg(long = "policy-deny-host", global = true)]
pub policy_deny_host: Vec<String>,
#[arg(long, global = true, default_value = "default")]
pub profile: String,
#[arg(long, global = true)]
pub incognito: bool,
#[arg(long, global = true)]
pub attach: bool,
#[arg(long = "target-id", global = true)]
pub target_id: Option<String>,
#[arg(long = "frame-id", global = true)]
pub frame_id: Option<String>,
#[arg(long, global = true, default_value_t = 9222)]
pub port: u16,
#[arg(long, global = true)]
pub headed: bool,
#[arg(long, global = true, value_name = "WIDTHxHEIGHT")]
pub viewport: Option<String>,
#[arg(long, global = true, value_enum, default_value_t = InteractionMode::Human)]
pub interaction: InteractionMode,
#[arg(long, global = true)]
pub audit: bool,
#[arg(long, global = true)]
pub trace_on_error: bool,
#[arg(long = "chrome-path", alias = "chrome", global = true)]
pub chrome_path: Option<PathBuf>,
#[arg(long)]
pub mcp: bool,
#[arg(long = "tui-layout", global = true, value_enum, default_value_t = TuiLayout::Auto)]
pub tui_layout: TuiLayout,
#[arg(long = "tui-transport", global = true, value_enum, default_value_t = TuiTransport::Auto)]
pub tui_transport: TuiTransport,
#[arg(long = "tui-graphics", global = true, value_enum, default_value_t = TuiGraphics::Auto)]
pub tui_graphics: TuiGraphics,
#[arg(long = "tui-rtt-ms", global = true)]
pub tui_rtt_ms: Option<f64>,
#[arg(long = "tui-throughput-mbps", global = true)]
pub tui_throughput_mbps: Option<f64>,
#[arg(long = "tui-live", global = true, value_enum, default_value_t = TuiLiveMode::Off)]
pub tui_live: TuiLiveMode,
#[arg(long = "tui-live-backend", global = true, value_enum, default_value_t = TuiLiveBackend::Auto)]
pub tui_live_backend: TuiLiveBackend,
#[arg(long = "tui-live-quality", global = true, value_enum, default_value_t = TuiLiveQuality::Balanced)]
pub tui_live_quality: TuiLiveQuality,
#[arg(long = "tui-live-fit", global = true, value_enum, default_value_t = TuiLiveFit::Contain)]
pub tui_live_fit: TuiLiveFit,
#[arg(long, global = true)]
pub knowledge_store: Option<PathBuf>,
#[arg(long, global = true, value_enum, default_value_t = ResponseMode::Minimal)]
pub response_mode: ResponseMode,
#[arg(value_name = "PROMPT")]
pub prompt: Option<String>,
#[command(subcommand)]
pub command: Option<Commands>,
}
#[derive(Debug, Clone, Copy, ValueEnum)]
pub enum McpClient {
Generic,
ClaudeCode,
Codex,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum, Default)]
pub enum TuiLayout {
#[default]
Auto,
Desktop,
Mobile,
Compact,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum, Default)]
pub enum TuiTransport {
#[default]
Auto,
Local,
RemoteFast,
RemoteConstrained,
Mosh,
UnknownRemote,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum, Default)]
pub enum TuiGraphics {
#[default]
Auto,
Kitty,
Sixel,
ITermInline,
Ansi,
SemanticOnly,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum, Default)]
pub enum TuiLiveMode {
#[default]
Off,
Auto,
On,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum, Default)]
pub enum TuiLiveBackend {
#[default]
Auto,
Herdr,
Kitty,
Ansi,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum, Default)]
pub enum TuiLiveQuality {
Data,
#[default]
Balanced,
Smooth,
}
#[derive(Debug, Clone, Copy, PartialEq, Eq, ValueEnum, Default)]
pub enum TuiLiveFit {
#[default]
Contain,
Cover,
Actual,
}
#[derive(Debug, Subcommand)]
pub enum Commands {
Update {
#[arg(long)]
dry_run: bool,
#[arg(long)]
version: Option<String>,
#[arg(long)]
force: bool,
#[arg(long)]
registry: Option<String>,
},
InstallChromium {
#[arg(long)]
update: bool,
},
Certify {
#[command(subcommand)]
action: CertifyCommand,
},
Workspace {
#[command(subcommand)]
action: WorkspaceCommand,
},
Project {
#[command(subcommand)]
action: ProjectCommand,
},
Agent {
#[command(subcommand)]
action: AgentCommand,
},
Memory {
#[command(subcommand)]
action: MemoryCommand,
},
Surfaces {
#[command(subcommand)]
action: SurfaceCommand,
},
Backend {
#[command(subcommand)]
action: BackendCommand,
},
Daemon {
#[command(subcommand)]
action: DaemonCommand,
},
Replay {
#[command(subcommand)]
action: ReplayCommand,
},
Capabilities,
Doctor {
#[arg(long)]
json: bool,
},
McpConfig {
#[arg(long, value_enum, default_value_t = McpClient::Generic)]
client: McpClient,
#[arg(long)]
print: bool,
},
Profiles {
#[command(subcommand)]
action: Option<ProfileCommand>,
},
Knowledge {
#[command(subcommand)]
action: KnowledgeCommand,
},
Result {
#[command(subcommand)]
action: ResultCommand,
},
DeleteProfile { name: String },
Navigate {
url: String,
#[arg(long, default_value_t = 20_000)]
timeout_ms: u64,
#[arg(long)]
expected_revision: Option<u64>,
},
Click {
target: String,
#[arg(long)]
expected_revision: Option<u64>,
},
Preflight {
target: String,
#[arg(long, value_enum, default_value_t = PreflightAction::Click)]
action: PreflightAction,
},
ClickAt { x: f64, y: f64 },
ClickExpectPopup {
target: String,
#[arg(long)]
expected_revision: Option<u64>,
},
DoubleClick {
target: String,
#[arg(long)]
expected_revision: Option<u64>,
},
Hover { target: String },
Drag {
source: String,
destination: String,
#[arg(long)]
expected_revision: Option<u64>,
},
Type {
text: String,
#[arg(long)]
target: Option<String>,
#[arg(long)]
expected_revision: Option<u64>,
},
Key {
key: String,
#[arg(long)]
expected_revision: Option<u64>,
},
KeyDown {
key: String,
#[arg(long)]
expected_revision: Option<u64>,
},
KeyUp {
key: String,
#[arg(long)]
expected_revision: Option<u64>,
},
Shortcut {
shortcut: String,
#[arg(long)]
expected_revision: Option<u64>,
},
Clear {
target: String,
#[arg(long)]
expected_revision: Option<u64>,
},
Check {
target: String,
#[arg(long)]
expected_revision: Option<u64>,
},
Uncheck {
target: String,
#[arg(long)]
expected_revision: Option<u64>,
},
Select {
target: String,
value: String,
#[arg(long)]
expected_revision: Option<u64>,
},
Upload {
target: String,
#[arg(required = true)]
files: Vec<PathBuf>,
#[arg(long)]
expected_revision: Option<u64>,
},
Screenshot {
#[arg(short, long, default_value = "screenshot.png")]
output: String,
#[arg(long, value_enum, default_value_t = VisualFormat::Png)]
format: VisualFormat,
#[arg(long)]
quality: Option<u8>,
#[arg(long, default_value_t = 1.0)]
scale: f64,
#[arg(long, conflicts_with_all = ["clip", "target"])]
full_page: bool,
#[arg(long, conflicts_with_all = ["full_page", "target"])]
clip: Option<VisualClip>,
#[arg(long, conflicts_with_all = ["full_page", "clip"])]
target: Option<String>,
},
Text,
Dom,
Observe {
#[arg(long)]
deep_dom: bool,
#[arg(long)]
screenshot: bool,
#[arg(long)]
form_values: bool,
#[arg(long = "level", alias = "semantic-level", value_parser = parse_semantic_level)]
semantic_level: Option<String>,
#[arg(long, requires = "semantic_level")]
region: Option<String>,
},
InspectPage,
SmokeSites {
input: PathBuf,
#[arg(long)]
stop_on_error: bool,
},
FindTarget { input: PathBuf },
ActAndVerify {
input: PathBuf,
#[arg(long)]
predicate: Option<String>,
#[arg(long, default_value_t = 10_000)]
timeout_ms: u64,
},
ExtractStructured { input: PathBuf },
RecoverRun { execution_id: String },
Scroll {
#[arg(long, default_value_t = 0.0)]
dx: f64,
#[arg(long, default_value_t = 600.0)]
dy: f64,
#[arg(long)]
expected_revision: Option<u64>,
},
Wait {
condition: String,
#[arg(long, default_value_t = 10_000)]
timeout_ms: u64,
},
Diagnostics {
#[arg(long, default_value_t = 1_000)]
duration_ms: u64,
},
AcceptDialog,
DismissDialog,
DismissConsent,
Download {
destination: PathBuf,
#[arg(long, default_value_t = 30_000)]
timeout_ms: u64,
},
Targets,
NewTarget { url: String },
SelectTarget { id: String },
CloseTarget { id: String },
Frames,
SelectFrame { id: String },
Evaluate { expression: String },
Cookies,
ExportCookies { output: PathBuf },
ImportCookies { input: PathBuf },
Pdf {
#[arg(short, long, default_value = "page.pdf")]
output: String,
#[arg(long)]
background: bool,
},
FillForm {
#[arg(long)]
fields: String,
#[arg(long)]
expected_revision: Option<u64>,
},
Batch {
input: Option<PathBuf>,
#[arg(long)]
atomic: bool,
#[arg(long, value_enum, default_value_t = BatchMode::Unguarded)]
mode: BatchMode,
#[arg(long)]
expected_revision: Option<u64>,
},
#[command(subcommand_precedence_over_arg = true)]
Workflow {
#[command(subcommand)]
action: Option<WorkflowAuthoringCommand>,
input: Option<PathBuf>,
},
Task {
#[command(subcommand)]
action: TaskCommand,
},
Ir {
#[command(subcommand)]
action: IrCommand,
},
WorkflowResume {
workflow: PathBuf,
checkpoint: PathBuf,
#[arg(long)]
inputs: Option<PathBuf>,
},
ResolveIntent {
input: Option<PathBuf>,
},
ExecuteIntent {
input: Option<PathBuf>,
},
Verify {
predicate: String,
#[arg(long, default_value_t = 10_000)]
timeout_ms: u64,
},
ReconcileRefs {
#[arg(long)]
from_revision: u64,
#[arg(long = "hint")]
hints: Vec<String>,
#[arg(long)]
scope: Option<String>,
#[arg(required = true)]
refs: Vec<String>,
},
ObserveDelta,
Checkpoint {
#[command(subcommand)]
action: CheckpointCommand,
},
Snapshot {
#[command(subcommand)]
action: SnapshotCommand,
},
ClipboardRead,
ClipboardWrite { text: String },
Tui,
}
fn parse_semantic_level(value: &str) -> Result<String, String> {
match value {
"summary" | "interactive" | "structured" | "detailed" | "raw" => Ok(value.into()),
_ => Err("expected summary, interactive, structured, detailed, or raw".into()),
}
}
#[derive(Debug, Subcommand)]
pub enum ProfileCommand {
List,
Create { name: String },
Delete { name: String },
}
#[derive(Debug, Subcommand)]
pub enum KnowledgeCommand {
List,
Show { record_id: String },
Explain { record_id: String },
Stats,
Export { output: Option<PathBuf> },
Import { input: PathBuf },
Invalidate {
record_id: String,
#[arg(value_enum)]
state: KnowledgeInvalidationState,
#[arg(long)]
reason: Option<String>,
#[arg(long)]
observed_at: Option<String>,
},
Purge { origin: String },
}
#[derive(Debug, Subcommand)]
pub enum WorkspaceCommand {
List,
Inspect { id: String },
Suspend { id: String },
Resume { id: String },
Delete { id: String },
}
#[derive(Debug, Subcommand)]
pub enum ProjectCommand {
Inspect {
#[arg(long, default_value = ".")]
root: PathBuf,
},
Files {
#[arg(long, default_value = ".")]
root: PathBuf,
},
Search {
query: String,
#[arg(long, default_value_t = 64)]
limit: usize,
#[arg(long, default_value = ".")]
root: PathBuf,
},
Read {
path: String,
#[arg(long, default_value = ".")]
root: PathBuf,
},
Edit {
path: String,
#[arg(long, conflicts_with = "input")]
content: Option<String>,
#[arg(long, conflicts_with = "content")]
input: Option<PathBuf>,
#[arg(long, default_value = ".")]
root: PathBuf,
},
Mkdir {
path: String,
#[arg(long, default_value = ".")]
root: PathBuf,
},
Rename {
from: String,
to: String,
#[arg(long, default_value = ".")]
root: PathBuf,
},
Delete {
path: String,
#[arg(long)]
yes: bool,
#[arg(long, default_value = ".")]
root: PathBuf,
},
Diagnostics {
path: String,
#[arg(long, default_value = ".")]
root: PathBuf,
},
Run {
name: String,
#[arg(long)]
command: Option<String>,
#[arg(long)]
wait: bool,
#[arg(long, default_value = ".")]
root: PathBuf,
},
Test {
#[arg(long, default_value = ".")]
root: PathBuf,
},
Lint {
#[arg(long, default_value = ".")]
root: PathBuf,
},
Process {
#[arg(long, default_value = ".")]
root: PathBuf,
#[command(subcommand)]
action: ProjectProcessCommand,
},
Diff {
#[arg(long, default_value = ".")]
root: PathBuf,
},
Link {
entity: String,
path: String,
#[arg(long)]
start_line: u32,
#[arg(long)]
end_line: u32,
#[arg(long, default_value = "explicit-marker")]
provenance: String,
#[arg(long, default_value_t = 1.0)]
confidence: f32,
#[arg(long, default_value = "explicit project link")]
detail: String,
#[arg(long, default_value = ".")]
root: PathBuf,
},
Graph {
#[arg(long, default_value = ".")]
root: PathBuf,
#[command(subcommand)]
action: ProjectGraphCommand,
},
Breakpoint {
kind: String,
entity: String,
before: PathBuf,
after: PathBuf,
#[arg(long, default_value = ".")]
root: PathBuf,
},
Timeline {
#[arg(long, default_value = ".")]
root: PathBuf,
},
Replay {
#[arg(long, default_value_t = 0)]
start: usize,
#[arg(long, default_value_t = 64)]
limit: usize,
#[arg(long, default_value = ".")]
root: PathBuf,
},
Neovim {
#[arg(long, default_value = ".")]
root: PathBuf,
#[command(subcommand)]
action: NeovimCommand,
},
Experiment {
#[arg(long, default_value = ".")]
root: PathBuf,
#[command(subcommand)]
action: ExperimentCommand,
},
Attach {
actor: String,
#[arg(long, default_value = ".")]
root: PathBuf,
},
}
#[derive(Debug, Subcommand)]
pub enum ProjectGraphCommand {
Discover,
Entity {
entity: String,
},
Source {
path: String,
#[arg(long)]
line: Option<u32>,
},
}
#[derive(Debug, Subcommand)]
pub enum NeovimCommand {
Probe,
Start {
#[arg(long, default_value = "neovim")]
name: String,
path: Option<PathBuf>,
},
}
#[derive(Debug, Subcommand)]
pub enum ExperimentCommand {
Create {
name: String,
#[arg(long)]
port: u16,
},
}
#[derive(Debug, Subcommand)]
pub enum ProjectProcessCommand {
List,
Start {
name: String,
command: String,
#[arg(long)]
wait: bool,
},
Stop {
name: String,
},
Restart {
name: String,
},
Remove {
name: String,
},
Input {
name: String,
input: String,
},
Resize {
name: String,
cols: u16,
rows: u16,
},
Output {
name: String,
},
}
#[derive(Debug, Subcommand)]
pub enum AgentCommand {
Doctor,
Setup {
#[arg(long)]
sdk_entry: Option<PathBuf>,
#[arg(long, requires = "sdk_entry")]
agent_dir: Option<PathBuf>,
#[arg(long)]
update: bool,
#[arg(long)]
login: bool,
},
Status,
#[command(hide = true)]
Tool {
call: String,
#[arg(long, default_value = ".")]
root: PathBuf,
#[arg(long)]
allow_mutation: bool,
#[arg(long)]
yes: bool,
},
#[command(hide = true)]
ToolFile {
path: PathBuf,
#[arg(long, default_value = ".")]
root: PathBuf,
#[arg(long)]
allow_mutation: bool,
#[arg(long)]
yes: bool,
},
Hello {
#[arg(long, default_value = ".")]
root: PathBuf,
#[arg(long, value_enum, default_value_t = AgentHarness::Local)]
harness: AgentHarness,
},
Prompt {
text: String,
#[arg(long, default_value = ".")]
root: PathBuf,
#[arg(long, value_enum, default_value_t = AgentHarness::Local)]
harness: AgentHarness,
},
Steer {
text: String,
#[arg(long, default_value = ".")]
root: PathBuf,
#[arg(long, value_enum, default_value_t = AgentHarness::Pi)]
harness: AgentHarness,
},
FollowUp {
text: String,
#[arg(long, default_value = ".")]
root: PathBuf,
},
Models {
#[arg(long, default_value = ".")]
root: PathBuf,
},
SetModel {
provider: String,
model_id: String,
#[arg(long, default_value = ".")]
root: PathBuf,
},
Thinking {
level: String,
#[arg(long, default_value = ".")]
root: PathBuf,
},
Abort {
#[arg(long, default_value = ".")]
root: PathBuf,
},
NewSession {
#[arg(long, default_value = ".")]
root: PathBuf,
},
}
#[derive(Debug, Clone, Copy, ValueEnum)]
pub enum AgentHarness {
Local,
Pi,
}
#[derive(Debug, Subcommand)]
pub enum MemoryCommand {
Status,
Inspect {
record_id: String,
},
Explain {
record_id: String,
},
Forget {
record_id: String,
},
Export {
output: Option<PathBuf>,
},
Prune,
Reindex,
}
#[derive(Debug, Subcommand)]
pub enum SurfaceCommand {
Inspect { input: PathBuf },
Coverage { input: PathBuf },
}
#[derive(Debug, Subcommand)]
pub enum BackendCommand {
Status { input: PathBuf },
Capabilities { input: PathBuf },
Test { input: PathBuf },
}
#[derive(Debug, Subcommand)]
pub enum ReplayCommand {
Inspect {
scenario: PathBuf,
input: PathBuf,
},
Diff {
scenario: PathBuf,
before: PathBuf,
after: PathBuf,
},
Attach {
scenario: PathBuf,
input: PathBuf,
},
}
#[derive(Debug, Subcommand)]
pub enum SnapshotCommand {
Create,
List,
Inspect { snapshot_id: String },
Diff { from: String, to: String },
Purge,
}
#[derive(Debug, Subcommand)]
pub enum ResultCommand {
Show {
result_id: String,
#[arg(long)]
section: Option<String>,
},
Purge {
#[arg(long = "older-than")]
older_than: String,
},
}
#[derive(Debug, Clone, Copy, ValueEnum)]
pub enum KnowledgeInvalidationState {
Stale,
Contradicted,
Quarantined,
}
#[derive(Debug, Subcommand)]
pub enum WorkflowAuthoringCommand {
Compile {
input: PathBuf,
#[arg(short, long)]
output: Option<PathBuf>,
},
Format {
input: PathBuf,
#[arg(short, long)]
output: Option<PathBuf>,
},
Preview { input: PathBuf },
Diff { before: PathBuf, after: PathBuf },
Record {
#[arg(long)]
input: Option<PathBuf>,
#[arg(short, long)]
output: Option<PathBuf>,
},
Validate { input: PathBuf },
Lint {
input: PathBuf,
#[arg(long)]
warnings_as_errors: bool,
},
Templates {
name: Option<String>,
#[arg(short, long)]
output: Option<PathBuf>,
},
Init {
name: String,
#[arg(short, long)]
output: Option<PathBuf>,
},
}
#[derive(Debug, Subcommand)]
pub enum TaskCommand {
Validate {
input: PathBuf,
},
Compile {
input: PathBuf,
ir: PathBuf,
#[arg(short, long)]
output: Option<PathBuf>,
#[arg(long)]
explain: bool,
},
Execute {
input: PathBuf,
#[arg(long)]
expected_revision: u64,
#[arg(long)]
confirm: bool,
},
}
#[derive(Debug, Subcommand)]
pub enum IrCommand {
Validate { input: PathBuf },
Inspect { input: PathBuf },
Diff {
before: PathBuf,
after: PathBuf,
#[arg(long)]
summary: bool,
},
Continuity {
before: PathBuf,
after: PathBuf,
entity_id: String,
},
Canonical { input: PathBuf },
}
#[derive(Debug, Subcommand)]
pub enum DaemonCommand {
Start {
#[arg(long)]
socket: Option<PathBuf>,
#[arg(long)]
status: Option<PathBuf>,
},
Status {
#[arg(long)]
socket: Option<PathBuf>,
#[arg(long)]
status: Option<PathBuf>,
},
Stop {
#[arg(long)]
socket: Option<PathBuf>,
#[arg(long)]
status: Option<PathBuf>,
},
Doctor {
#[arg(long)]
socket: Option<PathBuf>,
#[arg(long)]
status: Option<PathBuf>,
},
Logs {
#[arg(long)]
status: Option<PathBuf>,
},
AcknowledgeRecovery {
#[arg(long)]
status: Option<PathBuf>,
#[arg(long = "request-id", required = true)]
request_ids: Vec<String>,
},
#[command(hide = true)]
Serve {
#[arg(long)]
socket: PathBuf,
#[arg(long)]
status: PathBuf,
},
}
#[derive(Debug, Subcommand)]
pub enum CertifyCommand {
Run {
#[arg(long)]
scenario: PathBuf,
#[arg(long)]
fixture: PathBuf,
#[arg(long)]
url: String,
#[arg(long, default_value = ".")]
workflow_root: PathBuf,
#[arg(long)]
inputs: Option<PathBuf>,
#[arg(short, long)]
output: Option<PathBuf>,
},
Plan {
#[arg(long)]
scenario: PathBuf,
#[arg(long)]
fixture: PathBuf,
},
Release {
#[arg(long)]
version: String,
#[arg(long)]
scenarios: PathBuf,
#[arg(long)]
observations: PathBuf,
#[arg(long)]
replays: Option<PathBuf>,
},
Replay {
#[arg(long)]
scenario: PathBuf,
#[arg(long)]
input: PathBuf,
},
ReplayDiff {
#[arg(long)]
scenario: PathBuf,
#[arg(long)]
before: PathBuf,
#[arg(long)]
after: PathBuf,
},
}
#[derive(Debug, Subcommand)]
pub enum CheckpointCommand {
Export,
Import { input: Option<PathBuf> },
}
#[cfg(test)]
mod tests {
use super::*;
#[test]
fn default_invocation_is_promptless_and_commandless() {
let cli = Cli::try_parse_from(["glass"]).unwrap();
assert!(cli.prompt.is_none());
assert!(cli.command.is_none());
}
#[test]
fn tui_is_discoverable_as_an_explicit_command() {
assert!(matches!(
Cli::try_parse_from(["glass", "tui"]).unwrap().command,
Some(Commands::Tui)
));
}
#[test]
fn update_options_are_explicit_and_browser_free() {
let cli = Cli::try_parse_from([
"glass",
"update",
"--dry-run",
"--version",
"0.3.4",
"--force",
"--registry",
"internal",
])
.unwrap();
assert!(matches!(
cli.command,
Some(Commands::Update {
dry_run: true,
version: Some(ref version),
force: true,
registry: Some(ref registry),
}) if version == "0.3.4" && registry == "internal"
));
}
#[test]
fn tui_layout_defaults_to_auto_and_accepts_mobile_override() {
let default = Cli::try_parse_from(["glass", "tui"]).unwrap();
assert!(!default.yolo);
assert_eq!(default.tui_layout, TuiLayout::Auto);
assert_eq!(default.tui_live, TuiLiveMode::Off);
assert_eq!(default.tui_live_backend, TuiLiveBackend::Auto);
assert_eq!(default.tui_live_quality, TuiLiveQuality::Balanced);
assert_eq!(default.tui_live_fit, TuiLiveFit::Contain);
let mobile = Cli::try_parse_from([
"glass",
"--tui-layout",
"mobile",
"--tui-live",
"on",
"--tui-live-backend",
"ansi",
"--tui-live-quality",
"data",
"--tui-live-fit",
"cover",
"tui",
])
.unwrap();
assert_eq!(mobile.tui_layout, TuiLayout::Mobile);
assert_eq!(mobile.tui_live, TuiLiveMode::On);
assert_eq!(mobile.tui_live_backend, TuiLiveBackend::Ansi);
assert_eq!(mobile.tui_live_quality, TuiLiveQuality::Data);
assert_eq!(mobile.tui_live_fit, TuiLiveFit::Cover);
}
#[test]
fn yolo_is_an_explicit_global_opt_in() {
assert!(
Cli::try_parse_from(["glass", "--yolo", "tui"])
.unwrap()
.yolo
);
assert!(
Cli::try_parse_from(["glass", "agent", "hello", "--yolo"])
.unwrap()
.yolo
);
}
#[test]
fn agent_readiness_commands_are_explicit() {
assert!(matches!(
Cli::try_parse_from(["glass", "agent", "doctor"])
.unwrap()
.command,
Some(Commands::Agent {
action: AgentCommand::Doctor
})
));
assert!(matches!(
Cli::try_parse_from([
"glass",
"agent",
"setup",
"--sdk-entry",
"/opt/pi/dist/index.js",
"--agent-dir",
"/opt/pi/config",
"--update"
])
.unwrap()
.command,
Some(Commands::Agent {
action: AgentCommand::Setup {
sdk_entry: Some(_),
agent_dir: Some(_),
update: true,
login: false,
}
})
));
}
#[test]
fn observation_and_human_interaction_are_defaults() {
let cli = Cli::try_parse_from(["glass", "observe"]).unwrap();
assert_eq!(cli.interaction, InteractionMode::Human);
assert!(matches!(
cli.command,
Some(Commands::Observe {
deep_dom: false,
screenshot: false,
form_values: false,
semantic_level: None,
region: None,
})
));
}
#[test]
fn screenshot_and_fast_interaction_require_explicit_flags() {
let cli =
Cli::try_parse_from(["glass", "--interaction", "fast", "observe", "--screenshot"])
.unwrap();
assert_eq!(cli.interaction, InteractionMode::Fast);
assert!(matches!(
cli.command,
Some(Commands::Observe {
deep_dom: false,
screenshot: true,
form_values: false,
semantic_level: None,
region: None,
})
));
}
#[test]
fn deep_dom_requires_an_explicit_observation_flag() {
let cli = Cli::try_parse_from(["glass", "observe", "--deep-dom"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::Observe {
deep_dom: true,
screenshot: false,
form_values: false,
semantic_level: None,
region: None,
})
));
}
#[test]
fn semantic_observation_level_and_region_are_explicit() {
let cli = Cli::try_parse_from([
"glass",
"observe",
"--level",
"interactive",
"--region",
"region_main",
])
.unwrap();
assert!(matches!(
cli.command,
Some(Commands::Observe {
semantic_level: Some(level),
region: Some(region),
..
}) if level == "interactive" && region == "region_main"
));
assert!(Cli::try_parse_from(["glass", "observe", "--level", "verbose"]).is_err());
}
#[test]
fn screenshot_remains_a_separate_explicit_command() {
let cli = Cli::try_parse_from(["glass", "screenshot", "--output", "page.png"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::Screenshot { output, .. }) if output == "page.png"
));
}
#[test]
fn double_click_is_an_explicit_action_command() {
let cli = Cli::try_parse_from(["glass", "double-click", "r7:b42"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::DoubleClick { target, .. }) if target == "r7:b42"
));
}
#[test]
fn click_expect_popup_is_an_explicit_action_command() {
let cli = Cli::try_parse_from(["glass", "click-expect-popup", "css=#popup"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::ClickExpectPopup { target, .. }) if target == "css=#popup"
));
}
#[test]
fn wait_has_an_explicit_condition_and_bounded_default() {
let cli = Cli::try_parse_from(["glass", "wait", "text=Ready"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::Wait { condition, timeout_ms: 10_000 }) if condition == "text=Ready"
));
}
#[test]
fn topology_commands_are_explicit() {
assert!(matches!(
Cli::try_parse_from(["glass", "targets"]).unwrap().command,
Some(Commands::Targets)
));
let cli = Cli::try_parse_from([
"glass",
"--target-id",
"page-1",
"--frame-id",
"frame-1",
"evaluate",
"document.title",
])
.unwrap();
assert_eq!(cli.target_id.as_deref(), Some("page-1"));
assert_eq!(cli.frame_id.as_deref(), Some("frame-1"));
assert!(matches!(
Cli::try_parse_from(["glass", "select-frame", "frame-1"])
.unwrap()
.command,
Some(Commands::SelectFrame { id }) if id == "frame-1"
));
}
#[test]
fn complete_input_commands_are_explicit() {
assert!(matches!(
Cli::try_parse_from(["glass", "drag", "css=#from", "css=#to"])
.unwrap()
.command,
Some(Commands::Drag { source, destination, .. }) if source == "css=#from" && destination == "css=#to"
));
assert!(matches!(
Cli::try_parse_from(["glass", "shortcut", "Control+A"])
.unwrap()
.command,
Some(Commands::Shortcut { shortcut, .. }) if shortcut == "Control+A"
));
assert!(matches!(
Cli::try_parse_from([
"glass",
"fill-form",
"--fields",
"[]",
"--expected-revision",
"7"
])
.unwrap()
.command,
Some(Commands::FillForm {
fields,
expected_revision: Some(7)
}) if fields == "[]"
));
}
#[test]
fn rejects_unknown_interaction_modes() {
assert!(Cli::try_parse_from(["glass", "--interaction", "instant", "observe"]).is_err());
}
#[test]
fn attach_and_target_id_are_explicit_global_options() {
let cli = Cli::try_parse_from([
"glass",
"--attach",
"--port",
"9333",
"--target-id",
"page-2",
"observe",
])
.unwrap();
assert!(cli.attach);
assert_eq!(cli.port, 9333);
assert_eq!(cli.target_id.as_deref(), Some("page-2"));
}
#[test]
fn workflow_command_accepts_optional_json_input() {
let cli = Cli::try_parse_from(["glass", "workflow", "workflow.json"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::Workflow {
action: None,
input: Some(path)
})
if path.as_os_str() == "workflow.json"
));
let cli = Cli::try_parse_from(["glass", "workflow", "validate", "workflow.yaml"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::Workflow {
action: Some(WorkflowAuthoringCommand::Validate { input }),
input: None,
}) if input.as_os_str() == "workflow.yaml"
));
let cli = Cli::try_parse_from(["glass", "workflow", "preview", "workflow.yaml"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::Workflow {
action: Some(WorkflowAuthoringCommand::Preview { input }),
input: None,
}) if input.as_os_str() == "workflow.yaml"
));
let cli = Cli::try_parse_from([
"glass",
"workflow",
"record",
"--input",
"events.json",
"--output",
"draft.json",
])
.unwrap();
assert!(matches!(
cli.command,
Some(Commands::Workflow {
action: Some(WorkflowAuthoringCommand::Record { input: Some(input), output: Some(output) }),
input: None,
}) if input.as_os_str() == "events.json" && output.as_os_str() == "draft.json"
));
}
#[test]
fn certify_release_command_accepts_versioned_evidence_paths() {
let cli = Cli::try_parse_from([
"glass",
"certify",
"release",
"--version",
"0.2.0",
"--scenarios",
"scenarios.json",
"--observations",
"observations.json",
])
.unwrap();
assert!(matches!(
cli.command,
Some(Commands::Certify {
action: CertifyCommand::Release {
version,
scenarios,
observations,
replays: None,
},
}) if version == "0.2.0"
&& scenarios.as_os_str() == "scenarios.json"
&& observations.as_os_str() == "observations.json"
));
}
#[test]
fn certify_plan_command_accepts_scenario_and_fixture_paths() {
let cli = Cli::try_parse_from([
"glass",
"certify",
"plan",
"--scenario",
"scenario.json",
"--fixture",
"fixture.json",
])
.unwrap();
assert!(matches!(
cli.command,
Some(Commands::Certify {
action: CertifyCommand::Plan { scenario, fixture },
}) if scenario.as_os_str() == "scenario.json" && fixture.as_os_str() == "fixture.json"
));
}
#[test]
fn certify_replay_command_accepts_scenario_and_bundle_paths() {
let cli = Cli::try_parse_from([
"glass",
"certify",
"replay",
"--scenario",
"scenario.json",
"--input",
"replay.json",
])
.unwrap();
assert!(matches!(
cli.command,
Some(Commands::Certify {
action: CertifyCommand::Replay { scenario, input },
}) if scenario.as_os_str() == "scenario.json" && input.as_os_str() == "replay.json"
));
}
#[test]
fn certify_replay_diff_command_accepts_two_bundle_paths() {
let cli = Cli::try_parse_from([
"glass",
"certify",
"replay-diff",
"--scenario",
"scenario.json",
"--before",
"before.json",
"--after",
"after.json",
])
.unwrap();
assert!(matches!(
cli.command,
Some(Commands::Certify {
action: CertifyCommand::ReplayDiff { scenario, before, after },
}) if scenario.as_os_str() == "scenario.json"
&& before.as_os_str() == "before.json"
&& after.as_os_str() == "after.json"
));
}
#[test]
fn workflow_resume_command_accepts_checkpoint_and_inputs() {
let cli = Cli::try_parse_from([
"glass",
"workflow-resume",
"workflow.json",
"checkpoint.json",
"--inputs",
"inputs.json",
])
.unwrap();
assert!(matches!(
cli.command,
Some(Commands::WorkflowResume {
workflow,
checkpoint,
inputs: Some(inputs)
}) if workflow.as_os_str() == "workflow.json"
&& checkpoint.as_os_str() == "checkpoint.json"
&& inputs.as_os_str() == "inputs.json"
));
}
#[test]
fn resolve_intent_command_accepts_optional_json_input() {
let cli = Cli::try_parse_from(["glass", "resolve-intent", "intent.json"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::ResolveIntent { input: Some(path) })
if path.as_os_str() == "intent.json"
));
assert!(Cli::try_parse_from(["glass", "resolve-intent"]).is_ok());
}
#[test]
fn execute_intent_command_accepts_optional_json_input() {
let cli = Cli::try_parse_from(["glass", "execute-intent", "intent.json"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::ExecuteIntent { input: Some(path) })
if path.as_os_str() == "intent.json"
));
assert!(Cli::try_parse_from(["glass", "execute-intent"]).is_ok());
}
#[test]
fn reliability_run_command_requires_fixture_url_and_sources() {
let cli = Cli::try_parse_from([
"glass",
"certify",
"run",
"--scenario",
"scenario.json",
"--fixture",
"fixture.json",
"--url",
"http://127.0.0.1:8000/fixture.html",
"--workflow-root",
"fixtures",
"--inputs",
"inputs.json",
"--output",
"evidence.json",
])
.unwrap();
assert!(matches!(
cli.command,
Some(Commands::Certify {
action: CertifyCommand::Run {
scenario,
fixture,
url,
workflow_root,
inputs: Some(inputs),
output: Some(output),
}
}) if scenario.as_os_str() == "scenario.json"
&& fixture.as_os_str() == "fixture.json"
&& url == "http://127.0.0.1:8000/fixture.html"
&& workflow_root.as_os_str() == "fixtures"
&& inputs.as_os_str() == "inputs.json"
&& output.as_os_str() == "evidence.json"
));
}
#[test]
fn capabilities_command_is_explicitly_offline() {
let cli = Cli::try_parse_from(["glass", "capabilities"]).unwrap();
assert!(matches!(cli.command, Some(Commands::Capabilities)));
}
#[test]
fn experimental_extensions_require_an_explicit_global_opt_in() {
let cli =
Cli::try_parse_from(["glass", "--experimental-extensions", "capabilities"]).unwrap();
assert!(cli.experimental_extensions);
}
#[test]
fn daemon_lifecycle_commands_accept_explicit_local_paths() {
let cli = Cli::try_parse_from([
"glass",
"daemon",
"start",
"--socket",
"/tmp/glass.sock",
"--status",
"/tmp/glass.json",
])
.unwrap();
assert!(matches!(
cli.command,
Some(Commands::Daemon {
action: DaemonCommand::Start { socket: Some(socket), status: Some(status) }
}) if socket.as_os_str() == "/tmp/glass.sock"
&& status.as_os_str() == "/tmp/glass.json"
));
}
#[test]
fn doctor_command_is_available_without_starting_a_browser() {
let cli = Cli::try_parse_from(["glass", "doctor"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::Doctor { json: false })
));
}
#[test]
fn knowledge_management_commands_parse_without_browser_startup() {
let cli = Cli::try_parse_from(["glass", "knowledge", "list"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::Knowledge {
action: KnowledgeCommand::List
})
));
let cli = Cli::try_parse_from(["glass", "knowledge", "explain", "record-1"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::Knowledge {
action: KnowledgeCommand::Explain { .. }
})
));
let cli = Cli::try_parse_from([
"glass",
"--knowledge-store",
"knowledge.json",
"knowledge",
"invalidate",
"record-1",
"stale",
])
.unwrap();
assert!(matches!(
cli.command,
Some(Commands::Knowledge {
action: KnowledgeCommand::Invalidate { .. }
})
));
}
#[test]
fn task_compile_command_is_explicitly_offline() {
use clap::CommandFactory;
let cli = Cli::try_parse_from([
"glass",
"task",
"compile",
"task.json",
"web-ir.json",
"--output",
"plan.json",
"--explain",
])
.unwrap();
assert!(Cli::command().find_subcommand("task").is_some());
assert!(matches!(
cli.command,
Some(Commands::Task {
action: TaskCommand::Compile {
input,
ir,
output: Some(output),
explain
}
}) if input.as_os_str() == "task.json"
&& ir.as_os_str() == "web-ir.json"
&& output.as_os_str() == "plan.json"
&& explain
));
}
#[test]
fn task_execute_help_advertises_supported_families() {
use clap::CommandFactory;
let mut command = Cli::command();
let execute = command
.find_subcommand_mut("task")
.and_then(|task| task.find_subcommand_mut("execute"))
.expect("task execute command should be present");
let help = execute.render_help().to_string();
let normalized = help.split_whitespace().collect::<Vec<_>>().join(" ");
assert!(normalized.contains(
"form, navigation, dialog, pagination, extraction, or field-read Task Protocol families"
));
}
#[test]
fn task_validate_command_is_explicitly_offline() {
let cli = Cli::try_parse_from(["glass", "task", "validate", "task.json"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::Task {
action: TaskCommand::Validate { input }
}) if input.as_os_str() == "task.json"
));
}
#[test]
fn ir_commands_are_explicitly_offline() {
let cli = Cli::try_parse_from(["glass", "ir", "inspect", "draft.json"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::Ir {
action: IrCommand::Inspect { input }
}) if input.as_os_str() == "draft.json"
));
let cli =
Cli::try_parse_from(["glass", "ir", "diff", "before.json", "after.json"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::Ir {
action: IrCommand::Diff {
before,
after,
summary
}
}) if before.as_os_str() == "before.json"
&& after.as_os_str() == "after.json"
&& !summary
));
let cli = Cli::try_parse_from([
"glass",
"ir",
"diff",
"before.json",
"after.json",
"--summary",
])
.unwrap();
assert!(matches!(
cli.command,
Some(Commands::Ir {
action: IrCommand::Diff {
before,
after,
summary
}
}) if before.as_os_str() == "before.json"
&& after.as_os_str() == "after.json"
&& summary
));
let cli = Cli::try_parse_from([
"glass",
"ir",
"continuity",
"before.json",
"after.json",
"field-1",
])
.unwrap();
assert!(matches!(
cli.command,
Some(Commands::Ir {
action: IrCommand::Continuity {
before,
after,
entity_id
}
}) if before.as_os_str() == "before.json"
&& after.as_os_str() == "after.json"
&& entity_id == "field-1"
));
let cli = Cli::try_parse_from(["glass", "ir", "validate", "draft.json"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::Ir {
action: IrCommand::Validate { input }
}) if input.as_os_str() == "draft.json"
));
let cli = Cli::try_parse_from(["glass", "ir", "canonical", "draft.json"]).unwrap();
assert!(matches!(
cli.command,
Some(Commands::Ir {
action: IrCommand::Canonical { input }
}) if input.as_os_str() == "draft.json"
));
}
}