//! Command-line engine boundary (`SMH-SPEC-SPEC0001`). //! //! Commands include credential management, eval, read-only observation, session inspection, and JSON-RPC. //! Eval and RPC use the shared runtime assembly from `smith-harness`. use clap::{CommandFactory, FromArgMatches, Parser, ValueEnum}; use smith::error::Result; use smith_harness::catalog::{refresh_models_dev, startup_catalog}; use smith_harness::durable::{ReadOnlyControl, writer_backend}; use smith_harness::http::default_executor; use smith_harness::oauth::login::SubscriptionProvider; use smith_harness::plugin_control::request_reload; use smith_harness::plugins::registry::{PackageRegistry, PackageSource}; use smith_harness::plugins::{Capability, NetScope, PluginPackage}; use smith_harness::protocol::ProtocolConnection; use smith_harness::runtime::{RuntimeConfig, RuntimeProvider, validate_catalog_model}; use smith_harness::trust::TrustStore; use smith_harness::wasm::{PluginEngine, PluginGeneration, PluginRegistry, SecretGrantConfig}; use smith_harness::{ AuthStore, CredentialKey, ProviderKind, RefreshOutcome, credential_key_env_var_present, credential_key_env_vars, }; use smith_rpc::{RpcState, handle_line}; use std::io::{BufRead, Read, Write}; use std::path::Path; use std::process::Command as ProcessCommand; use std::sync::Arc; use std::{fmt, io}; #[path = "login_cancellation.rs"] mod login_cancellation; /// Smith, a fast coding-agent runtime. #[derive(Debug, Parser)] #[command(name = "smith", version, about)] struct Cli { #[command(subcommand)] command: Command, } /// Interface mode. #[derive(Debug, Parser)] enum Command { /// Store API credentials or sign in to a subscription; never guess billing mode. #[command( about = "Store API credentials or sign in to a subscription; never guess billing mode" )] Login { /// Vendor billing connection: API credentials or subscription sign-in. #[arg(long, default_value = "openai-chatgpt-plan")] provider: ProviderArg, /// Subscription-only Google Cloud project used for Code Assist setup. #[arg(long)] project: Option, /// Subscription-only: reauthorize this exact saved registration; never register another client implicitly. #[arg(long)] profile: Option, /// Subscription-only trusted loopback issuer; uses a separate fixture-only profile namespace. #[arg(long)] fixture_issuer: Option, }, /// End one subscription session; retain profile identity for later sign-in. Logout { /// Explicit subscription billing connection. #[arg(long, default_value = "openai-chatgpt-plan")] provider: SubscriptionArg, /// Exact saved profile identity. #[arg(long)] profile: String, /// Explicit isolated loopback fixture namespace. #[arg(long)] fixture_issuer: Option, }, /// Manage stored provider credentials. Auth { #[command(subcommand)] action: AuthAction, }, /// Run one prompt without the TUI. Eval { /// Exact subscription profile; required for subscription connections. #[arg(long)] profile: Option, /// Explicit isolated loopback subscription fixture namespace. #[arg(long)] fixture_issuer: Option, /// Trusted credential-module package selected for this subscription only. #[arg(long, requires = "profile")] credential_module: Option, /// The prompt to run. prompt: String, /// Print the structured outcome as JSON. #[arg(long)] json: bool, /// Explicitly resume this existing session ID. #[arg(long)] session: Option, #[command(flatten)] selection: ExecutionProviderArgs, }, /// Inspect or explicitly refresh the offline model catalog. Catalog { #[command(subcommand)] action: CatalogAction, }, /// Inspect a plugin package without invoking its operational tools. Plugin { #[command(subcommand)] action: PluginAction, }, /// Attach read-only to a session, including one owned by another writer. Observe { /// Session identity to observe without provider or tool initialization. id: smith::id::SessionId, /// Optional explicit export target; created only on 'e', never overwritten. #[arg(long)] export: Option, }, /// Inspect stored sessions without acquiring a writer or provider. Sessions { #[command(subcommand)] action: SessionAction, }, /// Serve LF-delimited JSON-RPC on standard input and output. Rpc { /// Explicitly resume this existing session ID. #[arg(long)] session: Option, /// Inspect an existing session without provider, auth, or network setup. #[arg(long, requires = "session")] read_only: bool, #[command(flatten)] selection: ProviderArgs, }, } /// Shared provider declarations for every execution surface. #[derive(Debug, clap::Args)] struct ProviderArgs { /// Provider kind; required for real endpoints. #[arg(long, env = "SMITH_PROVIDER", hide_env_values = true)] provider: Option, /// Model id; required for real endpoints. #[arg(long, env = "SMITH_MODEL", hide_env_values = true)] model: Option, /// Endpoint base URL override. #[arg(long, env = "SMITH_BASE_URL", hide_env_values = true)] base_url: Option, /// Request streamed usage; explicit value replaces user and trusted project settings. #[arg(long, action = clap::ArgAction::Set)] include_usage: Option, /// Host-owned state for one qualified component tool: `name=advertised|hidden|disabled`. #[arg(long = "tool-policy", action = clap::ArgAction::Append)] tool_policy: Vec, /// Delegate a descendant directory: qualified-caller=qualified-target#directory. #[arg(long = "tool-delegation", action = clap::ArgAction::Append)] tool_delegation: Vec, } #[derive(Debug, clap::Args)] struct ExecutionProviderArgs { /// Use the scripted mock provider instead of a real endpoint. #[arg(long)] r#mock: bool, #[command(flatten)] connection: ProviderArgs, } /// Catalog operations. #[derive(Debug, Parser)] enum CatalogAction { /// Fetch, validate, cache, and publish a current models.dev snapshot. Refresh { /// Persistent cache path. CLI overrides `SMITH_CATALOG_CACHE`. #[arg(long, env = "SMITH_CATALOG_CACHE")] cache: Option, }, /// List offline catalog models grouped by executable connection without network access. Show { /// Persistent cache path. CLI overrides `SMITH_CATALOG_CACHE`. #[arg(long, env = "SMITH_CATALOG_CACHE")] cache: Option, /// Restrict output to one connection name. #[arg(long, value_enum)] provider: Option, /// Emit a structured listing. #[arg(long)] json: bool, }, /// Report effective offline catalog source and model count without network access. Status { /// Persistent cache path. CLI overrides `SMITH_CATALOG_CACHE`. #[arg(long, env = "SMITH_CATALOG_CACHE")] cache: Option, }, } /// Plugin package operations. #[derive(Debug, Parser)] enum PluginAction { /// Create a plugin package with a pinned world copy. Init { /// New package directory. package: std::path::PathBuf, /// Plugin name used in manifest and language project names. #[arg(long)] name: String, /// Guest language adapter. #[arg(long, value_enum, default_value_t = PluginLanguageArg::Rust)] language: PluginLanguageArg, }, /// Explicitly build a package through its selected language adapter. Build { /// Package directory containing its language project. package: std::path::PathBuf, }, /// Build then validate a package in the sealed plugin host. Test { /// Package directory containing plugin.kdl and plugin-test.json. package: std::path::PathBuf, /// Capability grant available to mocked guest calls. #[arg(long, value_enum)] grant: Vec, }, /// Validate, hash, and register a user package for live runtimes. Install { /// Package directory containing plugin.kdl and its artifact. package: std::path::PathBuf, /// Capability grant accepted at install time. #[arg(long, value_enum)] grant: Vec, /// Explicit HTTPS or literal-loopback HTTP origin for net-scope. #[arg(long = "net-origin")] net_origin: Vec, /// Guest credential-source id granted to this package. #[arg(long = "secret-source")] secret_source: Option, /// Auth-store provider selected for the secret source. #[arg(long = "secret-provider", value_enum)] secret_provider: Option, /// Explicit origin allowed to receive the exchanged secret. #[arg(long = "secret-origin")] secret_origin: Option, /// Explicit scope allowed for the exchanged secret. #[arg(long = "secret-scope", value_enum)] secret_scope: Vec, }, /// Register a canonical development source with precedence over installs. Link { /// Package directory containing plugin.kdl and its artifact. package: std::path::PathBuf, /// Capability grant accepted for this development link. #[arg(long, value_enum)] grant: Vec, /// Explicit HTTPS or literal-loopback HTTP origin for net-scope. #[arg(long = "net-origin")] net_origin: Vec, /// Guest credential-source id granted to this package. #[arg(long = "secret-source")] secret_source: Option, /// Auth-store provider selected for the secret source. #[arg(long = "secret-provider", value_enum)] secret_provider: Option, /// Explicit origin allowed to receive the exchanged secret. #[arg(long = "secret-origin")] secret_origin: Option, /// Explicit scope allowed for the exchanged secret. #[arg(long = "secret-scope", value_enum)] secret_scope: Vec, }, /// List installed packages and development links without loading artifacts. List, /// Remove every installed and development-link source for one plugin id. Remove { /// Plugin manifest id. id: String, }, /// Validate then publish the persisted package set to one runtime or every live runtime. Reload { /// Select one session runtime instead of every live runtime. #[arg(long)] session: Option, }, /// Watch, rebuild, validate, and publish one development link. Dev { /// Package directory containing plugin.kdl and its language project. package: std::path::PathBuf, /// Select one session runtime instead of every live runtime. #[arg(long)] session: Option, /// Capability grant accepted for this development link. #[arg(long, value_enum)] grant: Vec, /// Source scan interval in milliseconds. #[arg(long, default_value_t = 250, value_parser = clap::value_parser!(u64).range(10..=5_000))] watch_interval_ms: u64, }, /// Persist a canonical project package trust decision and its exact grants. Trust { /// Package directory to trust. package: std::path::PathBuf, /// Capability grant accepted at trust time. #[arg(long, value_enum)] grant: Vec, /// Explicit HTTPS or literal-loopback HTTP origin for net-scope. #[arg(long = "net-origin")] net_origin: Vec, /// Guest credential-source id granted to this package. #[arg(long = "secret-source")] secret_source: Option, /// Auth-store provider selected for the secret source. #[arg(long = "secret-provider", value_enum)] secret_provider: Option, /// Explicit origin allowed to receive the exchanged secret. #[arg(long = "secret-origin")] secret_origin: Option, /// Explicit scope allowed for the exchanged secret. #[arg(long = "secret-scope", value_enum)] secret_scope: Vec, }, /// Validate a trusted package's grants, world, artifact, and declarations. Check { /// Package directory containing plugin.kdl and its artifact. package: std::path::PathBuf, /// Trust this exact package path for this check only. #[arg(long)] trust: bool, /// Capability grant available while checking the package. #[arg(long, value_enum)] grant: Vec, }, } /// Capability grant accepted by plugin tooling. #[derive(Clone, Copy, Debug, ValueEnum)] enum CapabilityArg { /// Scoped network HTTP effect. NetScope, /// Credential exchange effect. SecretProxy, /// Bounded diagnostic logging effect. Log, /// Scoped workspace filesystem effects. Workspace, /// Supervised commands inherit host-user filesystem and network access. Process, } impl CapabilityArg { const fn capability(self) -> Capability { match self { Self::NetScope => Capability::NetScope, Self::SecretProxy => Capability::SecretProxy, Self::Log => Capability::Log, Self::Workspace => Capability::Workspace, Self::Process => Capability::Process, } } } fn grants_from_args(grants: Vec) -> Vec { grants.into_iter().map(CapabilityArg::capability).collect() } fn net_scopes_from_args(origins: &[String]) -> Result> { origins .iter() .map(|origin| NetScope::parse(origin)) .collect() } /// Guest secret scope accepted by the current HTTP-only proxy boundary. #[derive(Clone, Copy, Debug, ValueEnum)] enum SecretScopeArg { /// Substitute an exchanged reference only in an authorized HTTP request header. HttpRequest, } impl SecretScopeArg { const fn name(self) -> &'static str { match self { Self::HttpRequest => "http-request", } } } fn secret_grants_from_args( source: Option, provider: Option, origin: Option, scopes: Vec, ) -> Result> { match (source, provider, origin, scopes.is_empty()) { (None, None, None, true) => Ok(Vec::new()), (Some(source), Some(provider), Some(origin), false) => Ok(vec![SecretGrantConfig::new( source, NetScope::parse(&origin)?, scopes .into_iter() .map(SecretScopeArg::name) .map(str::to_string) .collect(), provider.credential_key()?, )?]), _ => Err(plugin_command_fault( "secret authority requires --secret-source, --secret-provider, --secret-origin, and --secret-scope", )), } } const fn package_source_name(source: PackageSource) -> &'static str { match source { PackageSource::Installed => "installed", PackageSource::DevLink => "linked", } } /// Read-only inspection operations. #[derive(Debug, Parser)] enum SessionAction { /// List session IDs and file sizes in stable ID order. List { #[arg(long)] json: bool, }, /// Read all recorded entries in physical order. Get { id: smith::id::SessionId, #[arg(long)] json: bool, }, /// Search literal case-sensitive UTF-8 substring across all recorded branches. /// Exit 1 when no match; exit 2 on error. Grep { pattern: String, #[arg(long)] json: bool, }, /// Durably queue user input without scheduling provider or tool execution. Submit { /// Existing session identity. id: smith::id::SessionId, /// Text input to queue. input: String, /// Session-scoped deduplication key. #[arg(long)] key: Option, }, /// Execute exactly one already admitted text-only turn; no tools advertised. Execute { /// Existing session identity. id: smith::id::SessionId, /// Durable submission identity. #[arg(value_parser = parse_entry_id)] submission_id: smith::id::EntryId, #[command(flatten)] selection: ExecutionProviderArgs, }, /// Inspect durable queued, running (recovery-required), or terminal state. Receipt { /// Existing session identity. id: smith::id::SessionId, /// Durable submission identity. #[arg(value_parser = parse_entry_id)] submission_id: smith::id::EntryId, }, } fn parse_entry_id(text: &str) -> std::result::Result { smith::id::proquint::decode(text) .map(smith::id::EntryId::from_u128) .map_err(|error| error.to_string()) } /// Credential operations. #[derive(Debug, Parser)] enum AuthAction { /// List OAuth profile metadata, never tokens or unverified account claims. Profiles { /// Explicit subscription billing connection. #[arg(long, default_value = "openai-chatgpt-plan")] provider: SubscriptionArg, /// Explicit loopback fixture namespace, never production profiles. #[arg(long)] fixture_issuer: Option, }, /// Store a credential read from standard input. Add { /// Provider the credential belongs to. #[arg(long)] provider: ProviderArg, }, /// List local credential sources; account access is not verified. List, /// Delete one stored credential. Remove { /// Provider whose credential is deleted. #[arg(long)] provider: ProviderArg, }, /// Check one local credential source without remote verification. Check { /// Provider whose credential is checked. #[arg(long)] provider: ProviderArg, }, } /// Provider names accepted on the command line. #[derive(Copy, Clone, Debug, Eq, PartialEq, ValueEnum)] enum ProviderArg { /// OpenAI-compatible endpoints. Openai, /// `ChatGPT` plan through Responses; requires explicit profile and model. OpenaiChatgptPlan, /// Claude subscription; explicit local profile, no API-key fallback. AnthropicClaudePlan, /// Google Gemini CLI subscription; no API-key fallback. GoogleGeminiCliPlan, /// Anthropic Messages API. Anthropic, /// Google Gemini API. Google, /// Metered Z.ai API connection. Zai, /// Z.ai Coding Plan connection; never falls back to metered API billing. ZaiCodingPlan, } #[derive(Clone, Copy, Debug, ValueEnum)] enum SubscriptionArg { #[value(name = "openai-chatgpt-plan")] OpenaiChatgpt, #[value(name = "anthropic-claude-plan")] AnthropicClaude, #[value(name = "google-gemini-cli-plan")] GoogleGeminiCli, } impl SubscriptionArg { const fn provider(self) -> SubscriptionProvider { match self { Self::OpenaiChatgpt => SubscriptionProvider::OpenAi, Self::AnthropicClaude => SubscriptionProvider::Anthropic, Self::GoogleGeminiCli => SubscriptionProvider::Google, } } } impl ProviderArg { const ALL: [Self; 5] = [ Self::Openai, Self::Anthropic, Self::Google, Self::Zai, Self::ZaiCodingPlan, ]; const fn subscription(self) -> Option { match self { Self::OpenaiChatgptPlan => Some(SubscriptionProvider::OpenAi), Self::AnthropicClaudePlan => Some(SubscriptionProvider::Anthropic), Self::GoogleGeminiCliPlan => Some(SubscriptionProvider::Google), _ => None, } } const fn connection_id(self) -> &'static str { match self { Self::Openai => "openai-compatible-api", Self::OpenaiChatgptPlan => "openai-chatgpt-plan", Self::AnthropicClaudePlan => "anthropic-claude-plan", Self::GoogleGeminiCliPlan => "google-gemini-cli-plan", Self::Anthropic => "anthropic-api", Self::Google => "google-api", Self::Zai => "zai-api", Self::ZaiCodingPlan => "zai-coding-plan", } } const fn kind(self) -> ProviderKind { match self { Self::Openai | Self::OpenaiChatgptPlan => ProviderKind::OpenAiCompatible, Self::Anthropic | Self::AnthropicClaudePlan => ProviderKind::Anthropic, Self::Google | Self::GoogleGeminiCliPlan => ProviderKind::Google, Self::Zai | Self::ZaiCodingPlan => ProviderKind::Zai, } } const fn zai_connection(self) -> Option { match self { Self::Zai => Some(ProtocolConnection::Api), Self::ZaiCodingPlan => Some(ProtocolConnection::CodingPlan), Self::Openai | Self::OpenaiChatgptPlan | Self::Anthropic | Self::AnthropicClaudePlan | Self::GoogleGeminiCliPlan | Self::Google => None, } } fn credential_key(self) -> Result { match self { Self::OpenaiChatgptPlan | Self::AnthropicClaudePlan | Self::GoogleGeminiCliPlan => { Err(plugin_command_fault( "subscription auth uses login/auth profiles, not API-key add/check/remove", )) } Self::ZaiCodingPlan => Ok(CredentialKey::ZaiCodingPlan), Self::Openai | Self::Anthropic | Self::Google | Self::Zai => { Ok(CredentialKey::Provider(self.kind())) } } } } /// Help-path work surface measured by the startup instruction ceiling. /// /// Counts come from the parsed command tree used by short help. #[derive(Clone, Copy, Debug, Eq, PartialEq)] pub struct HelpSurface { /// Constructed command nodes. pub command_nodes: u64, /// Argument placements after Clap propagated global arguments. pub argument_placements: u64, /// UTF-8 bytes rendered by root short help. pub rendered_bytes: u64, } /// Collect the actual root short-help surface without executing a command. /// /// This creates the same derived Clap tree as [`run`], parses `smith --help`, /// then examines its propagated tree. It is used only outside Callgrind. /// # Errors /// Returns an error if help parsing fails or a surface count exceeds `u64`. pub fn short_help_surface() -> std::result::Result { let (command, help) = root_short_help()?; let mut surface = HelpSurface { command_nodes: 0, argument_placements: 0, rendered_bytes: u64::try_from(help.len()) .map_err(|_| "root short-help length exceeds u64".to_string())?, }; inspect_help_surface(&command, &mut surface)?; Ok(surface) } /// Render actual root short help with selection environment values redacted. /// # Errors /// Returns an error if parsing does not produce the expected help response. pub fn short_help() -> std::result::Result { root_short_help().map(|(_, help)| help) } fn cli_command() -> clap::Command { Cli::command() .color(clap::ColorChoice::Never) .term_width(100) } fn root_short_help() -> std::result::Result<(clap::Command, String), String> { let mut command = cli_command(); let Err(error) = command.try_get_matches_from_mut(["smith", "--help"]) else { return Err("root short help unexpectedly parsed as a command".to_string()); }; if error.kind() != clap::error::ErrorKind::DisplayHelp { return Err(format!( "root short help returned {:?}, not DisplayHelp", error.kind() )); } Ok((command, error.to_string())) } fn inspect_help_surface( command: &clap::Command, surface: &mut HelpSurface, ) -> std::result::Result<(), String> { surface.command_nodes = surface .command_nodes .checked_add(1) .ok_or_else(|| "help command-node count overflows u64".to_string())?; let arguments = u64::try_from(command.get_arguments().count()) .map_err(|_| "help argument-placement count exceeds u64".to_string())?; surface.argument_placements = surface .argument_placements .checked_add(arguments) .ok_or_else(|| "help argument-placement count overflows u64".to_string())?; for child in command.get_subcommands() { inspect_help_surface(child, surface)?; } Ok(()) } /// Parse process arguments and run the selected Smith command. #[expect( clippy::too_many_lines, reason = "command dispatch keeps CLI argument ownership explicit" )] pub fn run() -> std::process::ExitCode { let matches = cli_command().get_matches(); let cli = match Cli::from_arg_matches(&matches) { Ok(cli) => cli, Err(error) => { error.exit(); } }; let inspection = matches!(&cli.command, Command::Sessions { action } if !matches!(action, SessionAction::Execute { .. })); let executing_admitted = matches!( &cli.command, Command::Sessions { action: SessionAction::Execute { .. } } ); let result = match cli.command { Command::Login { project, provider, fixture_issuer, profile, } => login( project.as_deref(), provider, fixture_issuer.as_deref(), profile.as_deref(), ) .map(|()| true), Command::Logout { provider, profile, fixture_issuer, } => oauth_logout(provider.provider(), &profile, fixture_issuer.as_deref()).map(|()| true), Command::Auth { action } => auth(&action).map(|()| true), Command::Catalog { action } => catalog(action).map(|()| true), Command::Plugin { action } => plugin(action).map(|()| true), Command::Sessions { action } => sessions(action), Command::Observe { id, export } => observe(id, export.as_ref()).map(|()| true), Command::Eval { profile, fixture_issuer, credential_module, prompt, json, session, selection: ExecutionProviderArgs { r#mock, connection: ProviderArgs { provider, model, base_url, include_usage, tool_policy, tool_delegation, }, }, } => selected_eval_provider( r#mock, provider, model.clone(), base_url, profile, fixture_issuer, credential_module, ) .and_then(|runtime_provider| { report_selection( provider, model.as_deref(), &subcommand_sources(&matches, "eval"), )?; eval( &prompt, json, &runtime_config( runtime_provider, session, include_usage, &tool_policy, &tool_delegation, )?, ) }) .map(|()| true), Command::Rpc { session, read_only, selection, } => rpc(session, read_only, selection).map(|()| true), }; match result { Ok(true) => std::process::ExitCode::SUCCESS, Err(smith::error::SmithError::Cancelled) if !executing_admitted => { std::process::ExitCode::SUCCESS } Ok(false) => std::process::ExitCode::FAILURE, Err(error) => { drop(stderr_line(format_args!("smith: {error}"))); std::process::ExitCode::from(if inspection { 2 } else { 1 }) } } } fn login( project: Option<&str>, provider: ProviderArg, fixture_issuer: Option<&str>, profile: Option<&str>, ) -> Result<()> { if let Some(provider) = provider.subscription() { return login_subscription(project, provider, fixture_issuer, profile); } if project.is_some() || fixture_issuer.is_some() || profile.is_some() { return Err(plugin_command_fault( "--profile/--fixture-issuer/--project are subscription-only and require a subscription provider", )); } auth(&AuthAction::Add { provider }) } fn login_subscription( project: Option<&str>, provider: SubscriptionProvider, fixture_issuer: Option<&str>, profile: Option<&str>, ) -> Result<()> { let mut cancellation = login_cancellation::LoginCancellation::install()?; let journal = oauth_journal()?; let profile = smith_harness::oauth::login::run( provider, &journal, fixture_issuer, profile, project, cancellation.take_receiver()?, || cancellation.finish(), )?; let display = match provider { SubscriptionProvider::OpenAi => "ChatGPT", SubscriptionProvider::Anthropic => "Claude", SubscriptionProvider::Google => "Google", }; stdout_line(format_args!("{display} profile: {profile}")) } fn oauth_logout( provider: SubscriptionProvider, profile: &str, fixture_issuer: Option<&str>, ) -> Result<()> { let status = smith_harness::oauth::login::end_session( provider, &oauth_journal()?, fixture_issuer, profile, )?; stdout_line(format_args!("{status}")) } fn oauth_journal() -> Result { session_dir().map(|directory| directory.join(format!("{}.smh", smith::id::SessionId::new()))) } fn stdout_line(arguments: fmt::Arguments<'_>) -> Result<()> { let mut stdout = io::stdout().lock(); stdout .write_fmt(format_args!("{arguments}\n")) .map_err(|error| session_stdout_error(&error)) } fn stderr_line(arguments: fmt::Arguments<'_>) -> io::Result<()> { let mut stderr = io::stderr().lock(); stderr.write_fmt(format_args!("{arguments}\n")) } fn cli_stderr_error(error: &io::Error) -> smith::error::SmithError { smith::error::SmithError::Provider { fault: smith::error::ProviderFault::Transient { message: format!("stderr write failed: {error}"), }, } } fn catalog(action: CatalogAction) -> Result<()> { let (cache, refresh, listing) = match action { CatalogAction::Refresh { cache } => (cache.unwrap_or_else(catalog_cache_path), true, None), CatalogAction::Show { cache, provider, json, } => ( cache.unwrap_or_else(catalog_cache_path), false, Some((provider, json)), ), CatalogAction::Status { cache } => (cache.unwrap_or_else(catalog_cache_path), false, None), }; let mut state = startup_catalog(&cache)?; if refresh { let outcome = refresh_models_dev( &mut state, &cache, &default_executor(), &smith::tool::CancelHandle::new(), )?; if !matches!(outcome, RefreshOutcome::Published { .. }) { return Err(smith::error::SmithError::Provider { fault: smith::error::ProviderFault::Transient { message: format!( "catalog refresh failed: {outcome:?}; retained offline snapshot" ), }, }); } } match listing { Some((provider, json)) => catalog_show(state.snapshot(), provider, json), None => catalog_status(state.snapshot()), } } fn catalog_status(snapshot: &smith_harness::CatalogSnapshot) -> Result<()> { stdout_line(format_args!( "catalog: {}; generation={}; models={}", snapshot.provenance.label(), snapshot.generation, snapshot.catalog.models.len() )) } fn catalog_show( snapshot: &smith_harness::CatalogSnapshot, provider: Option, json: bool, ) -> Result<()> { if provider.is_some_and(|provider| provider.subscription().is_some()) { return Err(plugin_command_fault( "subscription model entitlement requires an explicitly selected profile; no API billing fallback", )); } let connections = ProviderArg::ALL .into_iter() .filter(|connection| provider.is_none_or(|selected| selected == *connection)); if json { let providers: Vec<_> = connections .map(|connection| catalog_json_connection(snapshot, connection)) .collect(); return stdout_line(format_args!( "{}", serde_json::json!({ "provenance": snapshot.provenance.label(), "generation": snapshot.generation, "providers": providers, }) )); } stdout_line(format_args!( "catalog: {}; generation={}", snapshot.provenance.label(), snapshot.generation ))?; for connection in connections { let mut models: Vec<_> = snapshot .catalog .models .values() .filter(|model| model.provider == connection.kind()) .collect(); models.sort_unstable_by(|left, right| left.id.cmp(&right.id)); stdout_line(format_args!( "{} (connection={}, access=unknown):", connection.slug(), connection.connection_id() ))?; for model in models { stdout_line(format_args!( " {} [{}]", catalog_human_value(&model.id), catalog_human_capabilities(&model.capabilities) ))?; } } Ok(()) } fn catalog_json_connection( snapshot: &smith_harness::CatalogSnapshot, connection: ProviderArg, ) -> serde_json::Value { let mut models: Vec<_> = snapshot .catalog .models .values() .filter(|model| model.provider == connection.kind()) .collect(); models.sort_unstable_by(|left, right| left.id.cmp(&right.id)); let models: Vec<_> = models .into_iter() .map(|model| { serde_json::json!({ "id": model.id, "capabilities": catalog_json_capabilities(&model.capabilities), }) }) .collect(); serde_json::json!({ "provider": connection.slug(), "catalog_provider": connection.kind().slug(), "connection": connection.connection_id(), "execution_support": "supported", "account_access": "unknown", "models": models, }) } fn catalog_json_capabilities(capabilities: &smith_harness::ModelCapabilities) -> serde_json::Value { let supported: Vec<_> = catalog_supported_capabilities(capabilities).collect(); serde_json::json!({ "context_window": capabilities.context_window, "max_output_tokens": capabilities.output_tokens_max, "supported": supported, }) } fn catalog_human_value(value: &str) -> std::str::EscapeDefault<'_> { value.escape_default() } fn catalog_human_capabilities(capabilities: &smith_harness::ModelCapabilities) -> String { let mut values = vec![ format!("context={}", capabilities.context_window), format!("output={}", capabilities.output_tokens_max), ]; values.extend(catalog_supported_capabilities(capabilities).map(str::to_string)); values.join(", ") } fn catalog_supported_capabilities( capabilities: &smith_harness::ModelCapabilities, ) -> impl Iterator { [ ("images", capabilities.input_images), ("tools", capabilities.tool_use), ("thinking", capabilities.thinking), ("strict-tools", capabilities.strict_tool_input), ("cache", capabilities.cache_control), ] .into_iter() .filter_map(|(name, supported)| supported.then_some(name)) } #[expect( clippy::too_many_lines, reason = "one CLI command dispatcher keeps subcommand output and errors adjacent" )] fn plugin(action: PluginAction) -> Result<()> { match action { PluginAction::Init { package, name, language, } => { plugin_init(&package, &name, language)?; stdout_line(format_args!("{}: initialized", package.display()))?; } PluginAction::Build { package } => { plugin_build(&package)?; stdout_line(format_args!("{}: built", package.display()))?; } PluginAction::Test { package, grant } => { plugin_build(&package)?; smith_harness::plugins::test::run(&package, &grants_from_args(grant))?; stdout_line(format_args!("{}: test passed", package.display()))?; } PluginAction::Install { package, grant, net_origin, secret_source, secret_provider, secret_origin, secret_scope, } => { let engine = PluginEngine::new()?; let grants = grants_from_args(grant); let scopes = net_scopes_from_args(&net_origin)?; let secret_grants = secret_grants_from_args( secret_source, secret_provider, secret_origin, secret_scope, )?; if !scopes.is_empty() && !grants.contains(&Capability::NetScope) { return Err(plugin_command_fault( "--net-origin requires --grant net-scope", )); } let record = PackageRegistry::at_default().install_with_authority( &engine, &package, &grants, &scopes, &secret_grants, )?; stdout_line(format_args!("{}: installed", record.id()))?; } PluginAction::Link { package, grant, net_origin, secret_source, secret_provider, secret_origin, secret_scope, } => { let engine = PluginEngine::new()?; let grants = grants_from_args(grant); let scopes = net_scopes_from_args(&net_origin)?; let secret_grants = secret_grants_from_args( secret_source, secret_provider, secret_origin, secret_scope, )?; if !scopes.is_empty() && !grants.contains(&Capability::NetScope) { return Err(plugin_command_fault( "--net-origin requires --grant net-scope", )); } let record = PackageRegistry::at_default().link_with_authority( &engine, &package, &grants, &scopes, &secret_grants, )?; stdout_line(format_args!("{}: linked", record.id()))?; } PluginAction::List => { for record in PackageRegistry::at_default().list()? { stdout_line(format_args!( "{} {} {} {} {}", package_source_name(record.source()), record.id(), record.root().display(), record.manifest_sha256(), record.artifact_sha256() ))?; } } PluginAction::Remove { id } => { if !PackageRegistry::at_default().remove(&id)? { return Err(plugin_command_fault(format!( "plugin {id} is not registered" ))); } stdout_line(format_args!("{id}: removed"))?; } PluginAction::Reload { session } => { let engine = PluginEngine::new()?; let candidate = PackageRegistry::at_default().load(&engine, &AuthStore::at_default())?; let count = candidate.len(); let mut registry = PluginRegistry::new(); registry.publish_all(candidate)?; request_reload(session)?; stdout_line(format_args!("plugins: reloaded {count}"))?; } PluginAction::Dev { package, session, grant, watch_interval_ms, } => plugin_dev( &package, session.as_ref(), &grants_from_args(grant), std::time::Duration::from_millis(watch_interval_ms), )?, PluginAction::Trust { package, grant, net_origin, secret_source, secret_provider, secret_origin, secret_scope, } => { let grants = grants_from_args(grant); let scopes = net_scopes_from_args(&net_origin)?; let secret_grants = secret_grants_from_args( secret_source, secret_provider, secret_origin, secret_scope, )?; if !scopes.is_empty() && !grants.contains(&Capability::NetScope) { return Err(plugin_command_fault( "--net-origin requires --grant net-scope", )); } if !secret_grants.is_empty() && (!grants.contains(&Capability::NetScope) || !grants.contains(&Capability::SecretProxy)) { return Err(plugin_command_fault( "secret authority requires --grant net-scope and --grant secret-proxy", )); } TrustStore::at(smith::config::plugin_trust_dir()).grant_with_authority( &package, &grants, &scopes, &secret_grants, )?; stdout_line(format_args!("{}: trusted", package.display()))?; if grants.contains(&Capability::Process) { stdout_line(format_args!( "process grant accepted: commands inherit host-user filesystem and network access" ))?; } } PluginAction::Check { package, trust, grant, } => { let grants = grants_from_args(grant); let (grants, scopes) = if trust { (grants, Vec::new()) } else { let trust_store = TrustStore::at(smith::config::plugin_trust_dir()); let grants = trust_store.decision(&package)?.ok_or_else(|| { smith::error::SmithError::Provider { fault: smith::error::ProviderFault::Plugin { message: "project plugin is untrusted; trust the project with smith plugin trust before loading its package".to_string(), }, } })?; let scopes = trust_store .net_scopes(&package)? .ok_or_else(|| plugin_command_fault("project trust decision disappeared"))?; (grants, scopes) }; plugin_check(&package, &grants, scopes)?; } } Ok(()) } fn plugin_check( package_root: &Path, grants: &[Capability], net_scopes: Vec, ) -> Result<()> { let package = PluginPackage::discover(package_root, true)?; let engine = PluginEngine::new()?; let mut generation = PluginGeneration::load_package(&engine, package, grants)?; generation.configure_net_scopes(net_scopes); stdout_line(format_args!("{}: check passed", generation.manifest().id()))?; if grants.contains(&Capability::Process) { stdout_line(format_args!( "process grant active: commands inherit host-user filesystem and network access" ))?; } Ok(()) } fn plugin_build(package: &Path) -> Result<()> { PluginLanguage::detect(package)?.build(package) } /// Guest language selected when scaffolding a package. #[derive(Clone, Copy, Debug, ValueEnum)] enum PluginLanguageArg { /// Raw Rust `wit-bindgen` guest. Rust, /// TypeScript guest componentized through the pinned Jco toolchain. #[value(name = "typescript")] TypeScript, } /// Language-specific plugin build contract. enum PluginLanguage { Rust, TypeScript, } impl PluginLanguage { fn detect(package: &Path) -> Result { match ( package.join("Cargo.toml").is_file(), package.join("package.json").is_file(), ) { (true, false) => Ok(Self::Rust), (false, true) => Ok(Self::TypeScript), (true, true) => Err(plugin_command_fault( "multiple language adapters recognize this package; keep only Cargo.toml or package.json", )), (false, false) => Err(plugin_command_fault( "no language adapter recognizes this package; add Cargo.toml or package.json", )), } } fn build(self, package: &Path) -> Result<()> { match self { Self::Rust => build_rust_plugin(package), Self::TypeScript => build_typescript_plugin(package), } } } fn build_rust_plugin(package: &Path) -> Result<()> { let cargo_manifest = package.join("Cargo.toml"); run_plugin_adapter( ProcessCommand::new("cargo") .args(["build", "--manifest-path"]) .arg(cargo_manifest) .args(["--target", "wasm32-wasip2", "--locked"]), "Rust adapter build", ) } fn build_typescript_plugin(package: &Path) -> Result<()> { let target = package.join("target"); std::fs::create_dir_all(&target).map_err(|error| { plugin_command_fault(format!( "TypeScript adapter target creation failed: {error}" )) })?; run_plugin_adapter( ProcessCommand::new(plugin_tool("tsc")?) .args(["--project"]) .arg(package.join("tsconfig.json")), "TypeScript adapter type check", )?; let raw = target.join("plugin.raw.wasm"); run_plugin_adapter( ProcessCommand::new(plugin_tool("jco")?) .args(["componentize"]) .arg(target.join("plugin.js")) .args(["--wit"]) .arg(package.join("wit")) .args(["--world-name", "plugin-world", "--out"]) .arg(&raw) .args(["--disable", "all"]), "TypeScript adapter componentize", )?; normalize_typescript_component(&target, &raw) } fn plugin_tool(name: &str) -> Result { let root = std::env::var_os("SMITH_PLUGIN_TOOL_DIR").map_or_else( || { std::env::var_os("CARGO_TARGET_DIR") .map_or_else( || std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../target"), std::path::PathBuf::from, ) .join("tools") }, std::path::PathBuf::from, ); let path = match name { "jco" => root.join("jco/node_modules/.bin/jco"), "tsc" => root.join("jco/node_modules/.bin/tsc"), "wasm-tools" => root.join("bin/wasm-tools"), _ => return Err(plugin_command_fault("unknown plugin build tool")), }; if path.is_file() { Ok(path) } else { Err(plugin_command_fault(format!( "TypeScript adapter requires {}; run cargo x bootstrap from the Smith checkout", path.display() ))) } } /// Maximum WAT source emitted by the Jco normalization step. const TYPESCRIPT_WAT_BYTES_MAX: usize = 256 * 1024 * 1024; fn normalize_typescript_component(target: &Path, raw: &Path) -> Result<()> { let wat = target.join("plugin.normalized.wat"); let output = target.join("plugin.wasm"); run_plugin_adapter( ProcessCommand::new(plugin_tool("wasm-tools")?) .args(["print"]) .arg(raw) .args(["-o"]) .arg(&wat), "TypeScript adapter component inspection", )?; let source = read_typescript_wat(&wat)?; let (normalized, memories) = normalize_component_memories(&source)?; if memories == 0 { return Err(plugin_command_fault( "TypeScript adapter component has no core memory to normalize", )); } std::fs::write(&wat, normalized).map_err(|error| { plugin_command_fault(format!( "TypeScript adapter component normalization write failed: {error}" )) })?; run_plugin_adapter( ProcessCommand::new(plugin_tool("wasm-tools")?) .args(["parse"]) .arg(&wat) .args(["-o"]) .arg(&output), "TypeScript adapter component normalization", ) } fn read_typescript_wat(path: &Path) -> Result { let metadata = std::fs::metadata(path).map_err(|error| { plugin_command_fault(format!( "TypeScript adapter component inspection failed: {error}" )) })?; if metadata.len() > TYPESCRIPT_WAT_BYTES_MAX as u64 { return Err(plugin_command_fault(format!( "TypeScript adapter component inspection exceeds {TYPESCRIPT_WAT_BYTES_MAX} bytes" ))); } let capacity = usize::try_from(metadata.len()).map_err(|_| { plugin_command_fault("TypeScript adapter component inspection exceeds addressable memory") })?; let mut bytes = Vec::new(); bytes.try_reserve_exact(capacity).map_err(|_| { plugin_command_fault("TypeScript adapter component inspection allocation failed") })?; let file = std::fs::File::open(path).map_err(|error| { plugin_command_fault(format!( "TypeScript adapter component inspection failed: {error}" )) })?; #[expect( clippy::disallowed_methods, reason = "Take bounds TypeScript component inspection before UTF-8 decoding" )] file.take((TYPESCRIPT_WAT_BYTES_MAX + 1) as u64) .read_to_end(&mut bytes) .map_err(|error| { plugin_command_fault(format!( "TypeScript adapter component inspection failed: {error}" )) })?; if bytes.len() > TYPESCRIPT_WAT_BYTES_MAX { return Err(plugin_command_fault(format!( "TypeScript adapter component inspection exceeds {TYPESCRIPT_WAT_BYTES_MAX} bytes" ))); } String::from_utf8(bytes).map_err(|error| { plugin_command_fault(format!( "TypeScript adapter component inspection is not UTF-8: {error}" )) }) } fn normalize_component_memories(source: &str) -> Result<(String, usize)> { let mut normalized = String::with_capacity(source.len()); let mut memories = 0; for line in source.lines() { let trimmed = line.trim(); let mut fields = trimmed.split_ascii_whitespace(); let memory = fields.next(); let identifier = fields.next(); let limit = fields.next(); let pages = match (memory, identifier, limit, fields.next()) { (Some("(memory"), Some(_), Some(limit), None) if limit.ends_with(')') => { Some(limit.trim_end_matches(')')) } _ => None, }; if let Some(pages) = pages { pages.parse::().map_err(|error| { plugin_command_fault(format!( "TypeScript adapter component memory declaration is invalid: {error}" )) })?; let prefix = &line[..line.len() - 1]; normalized.push_str(prefix); normalized.push(' '); normalized.push_str(pages); normalized.push(')'); memories += 1; } else { normalized.push_str(line); } normalized.push('\n'); } Ok((normalized, memories)) } fn run_plugin_adapter(command: &mut ProcessCommand, stage: &str) -> Result<()> { let output = command .output() .map_err(|error| plugin_command_fault(format!("{stage} failed to start: {error}")))?; if output.status.success() { Ok(()) } else { Err(plugin_command_fault(format!( "{stage} failed: {}", String::from_utf8_lossy(&output.stderr).trim() ))) } } fn plugin_dev( package: &Path, session: Option<&smith::id::SessionId>, grants: &[Capability], watch_interval: std::time::Duration, ) -> Result<()> { let engine = PluginEngine::new()?; let registry = PackageRegistry::at_default(); plugin_build(package)?; let record = registry.link(&engine, package, grants)?; if let Err(error) = request_reload(session.copied()) { stderr_line(format_args!( "{}: candidate saved but runtime notification failed: {error}", record.id() )) .map_err(|error| cli_stderr_error(&error))?; } stdout_line(format_args!("{}: watching", record.id()))?; let mut snapshot = PackageSourceSnapshot::read(package)?; loop { std::thread::sleep(watch_interval); let next = PackageSourceSnapshot::read(package)?; if next == snapshot { continue; } snapshot = next; if let Err(error) = plugin_build(package) { stderr_line(format_args!( "{}: rebuild failed; active generation retained: {error}", package.display() )) .map_err(|error| cli_stderr_error(&error))?; continue; } let record = match registry.link(&engine, package, grants) { Ok(record) => record, Err(error) => { stderr_line(format_args!( "{}: candidate validation failed; active generation retained: {error}", package.display() )) .map_err(|error| cli_stderr_error(&error))?; continue; } }; if let Err(error) = request_reload(session.copied()) { stderr_line(format_args!( "{}: candidate saved but runtime notification failed: {error}", record.id() )) .map_err(|error| cli_stderr_error(&error))?; continue; } stdout_line(format_args!("{}: reloaded", record.id()))?; snapshot = PackageSourceSnapshot::read(package)?; } } #[derive(Eq, PartialEq)] struct PackageSourceSnapshot(Vec); #[derive(Eq, Ord, PartialEq, PartialOrd)] struct PackageSourceStamp { path: std::path::PathBuf, modified_ns: u128, bytes: u64, } impl PackageSourceSnapshot { fn read(package: &Path) -> Result { const WATCHED_ENTRIES_MAX: usize = 10_000; const WATCHED_DEPTH_MAX: usize = 64; let mut stamps = Vec::new(); let mut entries_seen = 0; collect_source_stamps( package, package, &mut stamps, &mut entries_seen, WATCHED_ENTRIES_MAX, WATCHED_DEPTH_MAX, )?; stamps.sort(); Ok(Self(stamps)) } } fn collect_source_stamps( root: &Path, directory: &Path, stamps: &mut Vec, entries_seen: &mut usize, entries_max: usize, depth_max: usize, ) -> Result<()> { for entry in std::fs::read_dir(directory).map_err(|error| { plugin_command_fault(format!("plugin source watch read failed: {error}")) })? { let entry = entry.map_err(|error| { plugin_command_fault(format!("plugin source watch entry failed: {error}")) })?; *entries_seen = entries_seen .checked_add(1) .ok_or_else(|| plugin_command_fault("plugin source watch entry count overflow"))?; if *entries_seen > entries_max { return Err(plugin_command_fault(format!( "plugin source watch exceeds {entries_max} entries" ))); } let name = entry.file_name(); if name == "target" || name == ".git" { continue; } let path = entry.path(); let file_type = entry.file_type().map_err(|error| { plugin_command_fault(format!("plugin source watch type failed: {error}")) })?; if file_type.is_dir() { if depth_max == 0 { return Err(plugin_command_fault( "plugin source watch exceeds directory depth limit", )); } collect_source_stamps( root, &path, stamps, entries_seen, entries_max, depth_max - 1, )?; continue; } if !file_type.is_file() { continue; } stamps .try_reserve(1) .map_err(|_| plugin_command_fault("plugin source watch allocation failed"))?; let metadata = entry.metadata().map_err(|error| { plugin_command_fault(format!("plugin source watch metadata failed: {error}")) })?; let modified_ns = metadata .modified() .map_err(|error| { plugin_command_fault(format!("plugin source watch timestamp failed: {error}")) })? .duration_since(std::time::UNIX_EPOCH) .unwrap_or_default() .as_nanos(); let path = path .strip_prefix(root) .map_err(|error| { plugin_command_fault(format!("plugin source watch path failed: {error}")) })? .to_path_buf(); stamps.push(PackageSourceStamp { path, modified_ns, bytes: metadata.len(), }); } Ok(()) } fn plugin_init(package: &Path, name: &str, language: PluginLanguageArg) -> Result<()> { let slug = plugin_slug(name)?; if package.exists() { return Err(plugin_command_fault( "refusing to initialize an existing path", )); } std::fs::create_dir_all(package.join("src")) .map_err(|error| plugin_command_fault(format!("package creation failed: {error}")))?; copy_directory( &std::path::PathBuf::from(env!("CARGO_MANIFEST_DIR")).join("../wit"), &package.join("wit"), )?; if matches!(language, PluginLanguageArg::TypeScript) { return plugin_init_typescript(package, name); } let crate_name = format!("smith-plugin-{slug}"); let artifact = format!( "target/wasm32-wasip2/debug/smith_plugin_{}.wasm", slug.replace('-', "_") ); std::fs::write(package.join("Cargo.toml"), format!("[package]\nname = \"{crate_name}\"\nversion = \"0.1.0\"\nedition = \"2024\"\nbuild = \"build.rs\"\n\n[lib]\ncrate-type = [\"cdylib\"]\n\n[dependencies]\nwit-bindgen = \"=0.62.0\"\n")) .map_err(|error| plugin_command_fault(format!("Cargo manifest write failed: {error}")))?; std::fs::write( package.join("plugin.kdl"), format!("id \"{name}\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"{artifact}\"\n"), ) .map_err(|error| plugin_command_fault(format!("plugin manifest write failed: {error}")))?; std::fs::write(package.join("build.rs"), "fn main() {\n if std::env::var_os(\"CARGO_CFG_TARGET_ARCH\").as_deref() != Some(\"wasm32\".as_ref()) { return; }\n println!(\"cargo::rustc-link-arg=--initial-memory=2097152\");\n println!(\"cargo::rustc-link-arg=--max-memory=2097152\");\n}\n") .map_err(|error| plugin_command_fault(format!("build script write failed: {error}")))?; std::fs::write( package.join("plugin-test.json"), "{\n \"invocations\": [{\n \"name\": \"fixture\",\n \"input_json\": \"{}\",\n \"expected_output\": \"{}\",\n \"effects\": []\n }]\n}\n", ) .map_err(|error| plugin_command_fault(format!("plugin fixture write failed: {error}")))?; std::fs::write(package.join("src/lib.rs"), "#![expect(missing_docs, reason = \"wit-bindgen generates the world surface\")]\n#![expect(clippy::pedantic, reason = \"wit-bindgen generates the world surface\")]\n\nwit_bindgen::generate!({ path: \"wit/smith-plugin.wit\", world: \"plugin-world\" });\n\nuse exports::smith::plugin::plugin::{Guest, ToolDeclaration};\nuse exports::smith::plugin::provider::{CatalogSnapshot, DecodeStep, Guest as ProviderGuest, ProviderRequest, ProviderSettings, RequestTemplate, SettingsProvenance};\nuse exports::smith::plugin::registration::{Guest as RegistrationGuest, Registrations};\n\nstruct Plugin;\n\nimpl RegistrationGuest for Plugin {\n fn declare() -> Registrations { Registrations { credential_sources: Vec::new(), providers: Vec::new(), models: Vec::new() } }\n}\n\nimpl ProviderGuest for Plugin {\n fn declare_settings() -> ProviderSettings { ProviderSettings { include_usage: false, subscription: false, provenance: SettingsProvenance::BuiltIn } }\n fn validate_settings(_settings: ProviderSettings) -> Result { Err(\"no provider codec\".to_string()) }\n fn build_request(_model: String, _request: ProviderRequest, _settings: ProviderSettings, _catalog: CatalogSnapshot) -> Result { Err(\"no provider codec\".to_string()) }\n fn decode_response(_state: Vec, _chunk: Vec, _finished: bool) -> Result { Err(\"no provider codec\".to_string()) }\n}\n\nimpl Guest for Plugin {\n fn declare_tools() -> Vec { vec![ToolDeclaration { name: \"fixture\".to_string(), description: \"Fixture echo tool.\".to_string(), input_schema_json: r#\"{\"type\":\"object\"}\"#.to_string() }] }\n fn invoke(name: String, input_json: String) -> Result { if name == \"fixture\" { Ok(input_json) } else { Err(format!(\"unknown tool: {name}\")) } }\n}\n\nexport!(Plugin);\n") .map_err(|error| plugin_command_fault(format!("guest source write failed: {error}")))?; let output = ProcessCommand::new("cargo") .args(["generate-lockfile", "--manifest-path"]) .arg(package.join("Cargo.toml")) .output() .map_err(|error| plugin_command_fault(format!("cargo adapter failed to start: {error}")))?; if !output.status.success() { return Err(plugin_command_fault(format!( "cargo adapter lockfile failed: {}", String::from_utf8_lossy(&output.stderr).trim() ))); } Ok(()) } fn plugin_init_typescript(package: &Path, name: &str) -> Result<()> { std::fs::write( package.join("package.json"), "{\n \"name\": \"smith-plugin\",\n \"private\": true,\n \"type\": \"module\"\n}\n", ) .map_err(|error| { plugin_command_fault(format!("TypeScript package manifest write failed: {error}")) })?; std::fs::write( package.join("tsconfig.json"), "{\n \"compilerOptions\": {\n \"target\": \"ES2022\",\n \"module\": \"NodeNext\",\n \"moduleResolution\": \"NodeNext\",\n \"rootDir\": \"src\",\n \"outDir\": \"target\",\n \"strict\": true\n },\n \"include\": [\"src/**/*.ts\"]\n}\n", ) .map_err(|error| plugin_command_fault(format!("TypeScript config write failed: {error}")))?; std::fs::write( package.join("plugin.kdl"), format!( "id \"{name}\"\nversion \"0.1.0\"\nworld \"0.1.0\"\nartifact \"target/plugin.wasm\"\n" ), ) .map_err(|error| plugin_command_fault(format!("plugin manifest write failed: {error}")))?; std::fs::write( package.join("plugin-test.json"), "{\n \"invocations\": [{\n \"name\": \"fixture\",\n \"input_json\": \"{}\",\n \"expected_output\": \"{}\",\n \"effects\": []\n }]\n}\n", ) .map_err(|error| plugin_command_fault(format!("plugin fixture write failed: {error}")))?; std::fs::write( package.join("src/plugin.ts"), "export const plugin = {\n declareTools() { return [{ name: \"fixture\", description: \"Fixture echo tool.\", inputSchemaJson: '{\\\"type\\\":\\\"object\\\"}' }]; },\n invoke(name: string, inputJson: string) { if (name !== \"fixture\") throw new Error(`unknown tool: ${name}`); return inputJson; },\n};\nexport const provider = {\n declareSettings() { return { includeUsage: false, subscription: false, provenance: { tag: \"built-in\" } }; },\n validateSettings() { throw new Error(\"no provider codec\"); },\n buildRequest() { throw new Error(\"no provider codec\"); },\n decodeResponse() { throw new Error(\"no provider codec\"); },\n};\nexport const registration = { declare() { return { credentialSources: [], providers: [], models: [] }; } };\n", ) .map_err(|error| plugin_command_fault(format!("TypeScript guest source write failed: {error}")))?; Ok(()) } fn plugin_slug(name: &str) -> Result { let slug: String = name .chars() .map(|character| { if character.is_ascii_alphanumeric() { character.to_ascii_lowercase() } else { '-' } }) .collect(); let slug = slug.trim_matches('-'); if slug.is_empty() { return Err(plugin_command_fault( "plugin name needs an ASCII letter or digit", )); } Ok(slug.to_string()) } fn copy_directory(source: &Path, destination: &Path) -> Result<()> { std::fs::create_dir_all(destination) .map_err(|error| plugin_command_fault(format!("WIT directory creation failed: {error}")))?; for entry in std::fs::read_dir(source) .map_err(|error| plugin_command_fault(format!("WIT directory read failed: {error}")))? { let entry = entry.map_err(|error| { plugin_command_fault(format!("WIT directory entry failed: {error}")) })?; let target = destination.join(entry.file_name()); if entry .file_type() .map_err(|error| plugin_command_fault(format!("WIT entry metadata failed: {error}")))? .is_dir() { copy_directory(&entry.path(), &target)?; } else { std::fs::copy(entry.path(), target) .map_err(|error| plugin_command_fault(format!("WIT copy failed: {error}")))?; } } Ok(()) } fn plugin_command_fault(message: impl Into) -> smith::error::SmithError { smith::error::SmithError::Provider { fault: smith::error::ProviderFault::Plugin { message: message.into(), }, } } fn auth(action: &AuthAction) -> Result<()> { if let AuthAction::Add { provider } | AuthAction::Remove { provider } | AuthAction::Check { provider } = action { provider.credential_key()?; } let store = AuthStore::at_default(); match action { AuthAction::Profiles { provider, fixture_issuer, } => { let profiles = smith_harness::oauth::login::profile_store_for( provider.provider(), fixture_issuer.as_deref(), )? .list() .map_err(plugin_command_fault)?; let listing = serde_json::to_string(&profiles) .map_err(|_| plugin_command_fault("OAuth metadata encoding failed"))?; stdout_line(format_args!("{listing}"))?; } AuthAction::Add { provider } => { let mut stdin = std::io::stdin().lock(); let line = read_stdin_line(&mut stdin, AUTH_SECRET_BYTES_MAX) .map_err(|error| auth_stdin_error(&error))?; drop(stdin); let secret = match line { StdinLine::Line(line) => line, StdinLine::Eof => String::new(), }; if secret.is_empty() { return Err(smith::error::SmithError::Provider { fault: smith::error::ProviderFault::Authentication { message: "refusing to store an empty credential".to_string(), }, }); } let key = provider.credential_key()?; store.save(key, &secret)?; stdout_line(format_args!("{}: stored", key.slug()))?; } AuthAction::List => { let stored = store.list()?; for key in CredentialKey::ALL { if stored.contains(&key) { stdout_line(format_args!( "{}: store (not verified; offline)", key.slug() ))?; } if let Some(var) = credential_key_env_var_present(key) { stdout_line(format_args!( "{}: env:{var} (not verified; offline)", key.slug() ))?; } } } AuthAction::Remove { provider } => { let key = provider.credential_key()?; if store.remove(key)? { stdout_line(format_args!("{}: removed", key.slug()))?; } else { return Err(smith::error::SmithError::Provider { fault: smith::error::ProviderFault::Authentication { message: format!("no stored credential for {}", key.slug()), }, }); } } AuthAction::Check { provider } => { let key = provider.credential_key()?; if store.load(key)?.is_some() { stdout_line(format_args!("{}: store", key.slug()))?; } else if let Some(var) = credential_key_env_var_present(key) { stdout_line(format_args!("{}: env:{var}", key.slug()))?; } else { return Err(smith::error::SmithError::Provider { fault: smith::error::ProviderFault::Authentication { message: format!( "no credential for {} (tried store, env {})", key.slug(), credential_key_env_vars(key).join(", ") ), }, }); } } } Ok(()) } /// Which surface supplied each selection option, for provenance reports. #[derive(Clone, Copy, Debug, PartialEq, Eq)] enum OptionSource { /// An explicit command-line flag. Cli, /// A `SMITH_` environment variable. Env, /// Nothing supplied a value. Unset, } fn source_of(matches: &clap::ArgMatches, field: &str) -> OptionSource { match matches.value_source(field) { Some(clap::parser::ValueSource::CommandLine) => OptionSource::Cli, Some(clap::parser::ValueSource::EnvVariable) => OptionSource::Env, _ => OptionSource::Unset, } } fn subcommand_sources(matches: &clap::ArgMatches, name: &str) -> SelectionSources { let sub = matches.subcommand_matches(name); SelectionSources { provider: sub.map_or(OptionSource::Unset, |m| source_of(m, "provider")), model: sub.map_or(OptionSource::Unset, |m| source_of(m, "model")), base_url: sub.map_or(OptionSource::Unset, |m| source_of(m, "base_url")), } } /// Provenance of each selection option. struct SelectionSources { provider: OptionSource, model: OptionSource, base_url: OptionSource, } impl SelectionSources { fn describe(&self, provider: ProviderArg, model: &str) -> String { let provider = provider.slug(); format!( "provider={provider}({}) model={model}({}) base-url({})", self.provider.tag(), self.model.tag(), self.base_url.tag() ) } } impl OptionSource { const fn tag(self) -> &'static str { match self { Self::Cli => "cli", Self::Env => "env", Self::Unset => "unset", } } } impl ProviderArg { const fn slug(self) -> &'static str { match self { Self::Openai => "openai", Self::OpenaiChatgptPlan => "openai-chatgpt-plan", Self::AnthropicClaudePlan => "anthropic-claude-plan", Self::GoogleGeminiCliPlan => "google-gemini-cli-plan", Self::Anthropic => "anthropic", Self::Google => "google", Self::Zai => "zai", Self::ZaiCodingPlan => "zai-coding-plan", } } } fn real_provider( provider: Option, model: Option, base_url: Option, ) -> Result { let Some(provider) = provider else { return Err(smith::error::SmithError::Provider { fault: smith::error::ProviderFault::Authentication { message: "no provider selected (tried --provider/SMITH_PROVIDER)".to_string(), }, }); }; let Some(model) = model else { return Err(smith::error::SmithError::Provider { fault: smith::error::ProviderFault::Authentication { message: format!( "no model selected for {} (tried --model/SMITH_MODEL)", provider.slug() ), }, }); }; if provider.subscription().is_some() { return Err(plugin_command_fault( "subscription requires eval --profile ID; no API-key fallback", )); } if let Some(connection) = provider.zai_connection() { return Ok(RuntimeProvider::Zai { artifact: std::env::var_os("SMITH_ZAI_PLUGIN").map(std::path::PathBuf::from), base_url: base_url.unwrap_or_else(|| "https://api.z.ai".to_string()), connection, model, }); } Ok(RuntimeProvider::real(provider.kind(), base_url, model)) } fn selected_eval_provider( mock: bool, provider: Option, model: Option, base_url: Option, profile: Option, fixture_issuer: Option, credential_module: Option, ) -> Result { if let Some(subscription) = provider.and_then(ProviderArg::subscription) { if mock || base_url.is_some() { return Err(plugin_command_fault( "subscription cannot use --mock or --base-url; fixtures require --fixture-issuer", )); } let profile = profile.ok_or_else(|| { plugin_command_fault( "subscription requires --profile ID; no implicit account or API-key fallback", ) })?; let model = model.ok_or_else(|| { plugin_command_fault("subscription requires --model; no unverified default model") })?; let credential = smith_harness::oauth::source::SubscriptionCredential::for_provider( subscription, profile, fixture_issuer, )?; let credential = match credential_module { Some(module) => credential.with_module_override(module)?, None => credential, }; return Ok(match subscription { SubscriptionProvider::Anthropic => { RuntimeProvider::AnthropicClaudePlan { credential, model } } SubscriptionProvider::Google => { RuntimeProvider::GoogleGeminiCliPlan { credential, model } } SubscriptionProvider::OpenAi => { RuntimeProvider::OpenAiChatGptPlan { credential, model } } }); } if profile.is_some() || fixture_issuer.is_some() || credential_module.is_some() { return Err(plugin_command_fault( "--profile/--fixture-issuer/--credential-module require a subscription provider", )); } selected_provider(mock, provider, model, base_url) } fn selected_provider( mock: bool, provider: Option, model: Option, base_url: Option, ) -> Result { if mock { return Ok(RuntimeProvider::Mock(vec![smith_harness::mock_text_reply( "mock provider: no model configured", )])); } real_provider(provider, model, base_url) } fn report_selection( provider: Option, model: Option<&str>, sources: &SelectionSources, ) -> Result<()> { if let Some(provider) = provider && let Some(model) = model { stderr_line(format_args!("smith: {}", sources.describe(provider, model))) .map_err(|error| cli_stderr_error(&error))?; } Ok(()) } fn eval(prompt: &str, json: bool, config: &RuntimeConfig) -> Result<()> { let outcome = { let _turn = smith_alloc::enter(smith_alloc::Scope::Turn); smith_harness::runtime::execute_prompt(config, prompt) }?; if json { stdout_line(format_args!( "{}", serde_json::json!({ "text": outcome.text, "reason": format!("{:?}", outcome.reason), "cost": outcome.cost.map(|cost| serde_json::json!({ "input_tokens": cost.input_tokens, "output_tokens": cost.output_tokens, })), "cost_complete": outcome.cost_complete, }) ))?; } else { stdout_line(format_args!("{}", outcome.text))?; } Ok(()) } /// Largest credential accepted from standard input, matching the auth store. const AUTH_SECRET_BYTES_MAX: usize = 64 * 1024; /// Largest JSON-RPC request line, matching Smith's default frame policy. const RPC_INPUT_LINE_BYTES_MAX: usize = 1024 * 1024; /// Lines queued from stdin while the RPC loop drains responses. const RPC_INPUT_QUEUE_LINES: usize = 64; #[derive(Debug)] enum StdinLine { Line(String), Eof, } /// Read one UTF-8 line without allocating beyond `bytes_max`. fn read_stdin_line(reader: &mut impl BufRead, bytes_max: usize) -> std::io::Result { let mut bytes = Vec::new(); loop { let buffer = reader.fill_buf()?; if buffer.is_empty() { return if bytes.is_empty() { Ok(StdinLine::Eof) } else { String::from_utf8(bytes) .map(StdinLine::Line) .map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error)) }; } let line_end = buffer.iter().position(|byte| *byte == b'\n'); let text = &buffer[..line_end.unwrap_or(buffer.len())]; if bytes.len().saturating_add(text.len()) > bytes_max { return Err(std::io::Error::new( std::io::ErrorKind::InvalidData, format!("standard input line exceeds {bytes_max} bytes"), )); } let consumed_bytes = text.len() + usize::from(line_end.is_some()); bytes.extend_from_slice(text); reader.consume(consumed_bytes); if line_end.is_some() { if bytes.last() == Some(&b'\r') { bytes.pop(); } return String::from_utf8(bytes) .map(StdinLine::Line) .map_err(|error| std::io::Error::new(std::io::ErrorKind::InvalidData, error)); } } } fn auth_stdin_error(error: &std::io::Error) -> smith::error::SmithError { let message = if error.kind() == std::io::ErrorKind::InvalidData && error.to_string() == format!("standard input line exceeds {AUTH_SECRET_BYTES_MAX} bytes") { format!( "credential input exceeds {AUTH_SECRET_BYTES_MAX} bytes; provide one credential no larger than the auth-store limit" ) } else { error.to_string() }; smith::error::SmithError::Session { code: smith::error::SessionCode::AuthRead, message, } } fn rpc_stdin_error(error: &std::io::Error) -> smith::error::SmithError { let message = if error.kind() == std::io::ErrorKind::InvalidData && error.to_string() == format!("standard input line exceeds {RPC_INPUT_LINE_BYTES_MAX} bytes") { format!( "JSON-RPC request exceeds {RPC_INPUT_LINE_BYTES_MAX} bytes; split the request into smaller requests" ) } else { error.to_string() }; smith::error::SmithError::Session { code: smith::error::SessionCode::RpcStdin, message, } } #[expect( clippy::large_types_passed_by_value, reason = "Copy session ID enters runtime configuration without cloning" )] fn rpc( session: Option, read_only: bool, selection: ProviderArgs, ) -> Result<()> { let ProviderArgs { provider, model, base_url, include_usage, tool_policy, tool_delegation, } = selection; let mut state = if read_only { let id = session.ok_or_else(|| smith::error::SmithError::Config { field: "session".into(), message: "--read-only requires --session".into(), })?; let path = session_path( &std::path::PathBuf::from(smith::config::Config::default_valid().session_dir) .join("run"), id, true, )?; RpcState::inspection(Arc::new(ReadOnlyControl::open(&path)?)) } else { let runtime_provider = match provider { Some(provider) => real_provider(Some(provider), model, base_url)?, None => RuntimeProvider::Mock(vec![smith_harness::mock_text_reply( "rpc mock provider ready", )]), }; let config = runtime_config( runtime_provider, session, include_usage, &tool_policy, &tool_delegation, )?; let (control, executor) = writer_backend(config)?; RpcState::new(Arc::new(control), executor) }; let (input_tx, input_rx) = std::sync::mpsc::sync_channel(RPC_INPUT_QUEUE_LINES); std::thread::spawn(move || { { let mut stdin = std::io::stdin().lock(); loop { let line = match read_stdin_line(&mut stdin, RPC_INPUT_LINE_BYTES_MAX) { Ok(StdinLine::Line(line)) => Ok(line), Ok(StdinLine::Eof) => break, Err(error) => Err(error), }; let errored = line.is_err(); if input_tx.send(Some(line)).is_err() || errored { return; } } drop(stdin); } // The consumer may close after stdin reaches EOF. let _end_send_result = input_tx.send(None); }); let mut stdout = std::io::stdout(); let mut input_closed = false; loop { match input_rx.recv_timeout(std::time::Duration::from_millis(10)) { Ok(Some(Ok(line))) => { for response in handle_line(&mut state, &line) { stdout .write_all(response.as_bytes()) .map_err(rpc_stdout_error)?; } } Ok(Some(Err(error))) => return Err(rpc_stdin_error(&error)), Ok(None) | Err(std::sync::mpsc::RecvTimeoutError::Disconnected) => { input_closed = true; } Err(std::sync::mpsc::RecvTimeoutError::Timeout) => {} } for response in state.drain_lines() { stdout .write_all(response.as_bytes()) .map_err(rpc_stdout_error)?; } stdout.flush().map_err(rpc_stdout_error)?; if input_closed && state.is_settled() { for response in state.drain_lines() { stdout .write_all(response.as_bytes()) .map_err(rpc_stdout_error)?; } return Ok(()); } } } fn rpc_stdout_error(error: std::io::Error) -> smith::error::SmithError { let message = error.to_string(); drop(error); smith::error::SmithError::Session { code: smith::error::SessionCode::RpcStdout, message, } } fn observe(id: smith::id::SessionId, export: Option<&std::path::PathBuf>) -> Result<()> { let dir = session_dir()?; let path = session_path(&dir, id, true)?; smith_harness::observer::run(id, path, export) } fn sessions(action: SessionAction) -> Result { use smith_harness::inspection; let dir = std::path::PathBuf::from(smith::config::Config::default_valid().session_dir).join("run"); let mut stdout = std::io::stdout().lock(); match action { SessionAction::List { json } => { // Proquint text needs no JSON escaping, so both forms stream // through Display without an intermediate string. inspection::list(&dir, |summary| { let (id, bytes) = (summary.id, summary.bytes); if json { writeln!(stdout, "{{\"session\":\"{id}\",\"bytes\":{bytes}}}") } else { writeln!(stdout, "{id} {bytes} bytes") } .map_err(|e| session_stdout_error(&e)) })?; Ok(true) } SessionAction::Get { id, json } => { let path = dir.join(format!("{id}.smh")); inspection::entries(&path, |entry, content| { inspection::output(&mut stdout, id, entry, content, json, true) .map_err(|e| session_stdout_error(&e)) })?; Ok(true) } SessionAction::Grep { pattern, json } => { let mut found = false; inspection::list(&dir, |summary| { let id = summary.id; let path = dir.join(format!("{id}.smh")); inspection::entries(&path, |entry, content| { if inspection::contains(content, &pattern) { found = true; inspection::output(&mut stdout, id, entry, content, json, false) .map_err(|e| session_stdout_error(&e))?; } Ok(()) }) })?; Ok(found) } SessionAction::Submit { id, input, key } => { let path = session_path(&dir, id, true)?; let receipt = smith_harness::storage::admit( &path, &smith::message::Message::with_text(smith::message::Role::User, input), key.as_deref(), )?; output_admission_receipt(&mut stdout, &receipt, true)?; Ok(true) } SessionAction::Execute { id, submission_id, selection, } => { let provider = selected_provider( selection.r#mock, selection.connection.provider, selection.connection.model, selection.connection.base_url, )?; let config = runtime_config( provider, Some(id), selection.connection.include_usage, &selection.connection.tool_policy, &selection.connection.tool_delegation, )?; smith_harness::runtime::execute_admitted(&config, submission_id)?; let receipt = inspection::receipt(&config.session_path, submission_id)? .ok_or_else(|| plugin_command_fault("settled submission receipt missing"))?; output_admission_receipt(&mut stdout, &receipt, false)?; Ok(true) } SessionAction::Receipt { id, submission_id } => { let path = session_path(&dir, id, true)?; let receipt = inspection::receipt(&path, submission_id)?.ok_or_else(|| { smith::error::SmithError::Session { code: smith::error::SessionCode::SessionNotFound, message: format!("submission {submission_id} does not exist in session {id}"), } })?; output_admission_receipt(&mut stdout, &receipt, false)?; Ok(true) } } } fn output_admission_receipt( stdout: &mut impl Write, receipt: &smith_harness::storage::AdmissionReceipt, acknowledged: bool, ) -> Result<()> { let destination = receipt .destination .map_or_else(|| "null".to_owned(), |id| format!("\"{id}\"")); let boundary = if acknowledged { "\"durability\":\"acknowledged\"" } else { "\"visibility\":\"visible\"" }; let dir = session_dir()?; let status = smith_harness::inspection::work_status( &dir.join(format!("{}.smh", receipt.session_id)), receipt.submission_id, )?; let (state, detail) = match status { Some(smith_harness::storage::WorkStatus::Queued) => ("queued", ""), Some(smith_harness::storage::WorkStatus::Running) => { ("running", ",\"recovery_required\":true") } Some(smith_harness::storage::WorkStatus::Terminal(reason)) => ( "terminal", match reason { None => ",\"outcome\":\"failed\"", Some(smith::stream::StopReason::Abort) => ",\"outcome\":\"cancelled\"", Some(_) => ",\"outcome\":\"completed\"", }, ), None => return Err(plugin_command_fault("submission receipt missing")), }; let terminal = if let Some(smith_harness::storage::WorkStatus::Terminal(reason)) = status { let output = smith_harness::inspection::work_output( &dir.join(format!("{}.smh", receipt.session_id)), receipt.submission_id, )?; let output = output.map_or_else(|| "null".to_owned(), |id| format!("\"{id}\"")); let reason = reason.map_or_else(|| "null".to_owned(), |reason| format!("\"{reason:?}\"")); format!(",\"output\":{output},\"stop_reason\":{reason}") } else { String::new() }; writeln!( stdout, "{{\"session\":\"{}\",\"submission\":\"{}\",\"destination\":{destination},\"state\":\"{state}\"{detail}{terminal},{boundary}}}", receipt.session_id, receipt.submission_id, ) .map_err(|error| session_stdout_error(&error)) } fn session_stdout_error(error: &std::io::Error) -> smith::error::SmithError { if error.kind() == std::io::ErrorKind::BrokenPipe { smith::error::SmithError::Cancelled } else { smith::error::SmithError::Session { code: smith::error::SessionCode::SessionStdout, message: error.to_string(), } } } fn catalog_cache_path() -> std::path::PathBuf { std::env::var_os("SMITH_CATALOG_CACHE") .map_or_else(smith::config::catalog_cache_path, std::path::PathBuf::from) } #[expect( clippy::large_types_passed_by_value, reason = "Copy session ID is consumed once to form the runtime path" )] fn runtime_config( provider: RuntimeProvider, session: Option, include_usage: Option, tool_policy: &[String], tool_delegation: &[String], ) -> Result { let selected_session = session.unwrap_or_default(); let catalog_snapshot = if provider.requires_catalog_validation() { let catalog = startup_catalog(&catalog_cache_path())?; validate_catalog_model(&catalog.snapshot().catalog, &provider)?; Some(catalog.snapshot().clone()) } else { None }; let dir = session_dir()?; let workdir = std::env::current_dir().map_err(|error| smith::error::SmithError::Config { field: "workdir".into(), message: format!( "cannot resolve invocation directory: {error}; start Smith from an accessible directory" ), })?; let (provider_settings, ignored_project) = smith_harness::connection_settings::resolve( &smith::config::plugin_registry_dir().with_file_name("provider-settings.kdl"), &workdir, &TrustStore::at(smith::config::plugin_trust_dir()), include_usage, )?; if ignored_project && !matches!(provider, RuntimeProvider::Mock(_)) { stderr_line(format_args!("untrusted project provider settings ignored; use smith plugin trust to admit project configuration")).map_err(|error| cli_stderr_error(&error))?; } Ok(RuntimeConfig { session_path: session_path(&dir, selected_session, session.is_some())?, provider, workdir, provider_settings, api_key: None, auth_dir: smith::config::auth_dir(), catalog_snapshot, coding_tools_enabled: true, plugin_control_path: Some(smith::config::plugin_control_socket_path(selected_session)), plugin_registry_dir: None, tool_policy: smith_harness::wasm::ToolPolicy::from_specs(tool_policy)?, composition_grants: smith_harness::wasm::CompositionGrants::from_specs(tool_delegation)?, }) } fn session_path( dir: &std::path::Path, session: smith::id::SessionId, selected: bool, ) -> Result { let path = dir.join(format!("{session}.smh")); if selected && !path.is_file() { return Err(smith::error::SmithError::Session { code: smith::error::SessionCode::SessionNotFound, message: format!("session does not exist: {}", path.display()), }); } Ok(path) } fn session_dir() -> Result { let config = smith::config::Config::default_valid(); create_session_dir(std::path::PathBuf::from(config.session_dir).join("run")) } fn create_session_dir(dir: std::path::PathBuf) -> Result { std::fs::create_dir_all(&dir).map_err(|error| smith::error::SmithError::Storage { code: smith::error::StorageCode::RuntimeDir, operation: smith::error::StorageOperation::CreateDirAll, path: dir.clone(), message: error.to_string(), publication: None, })?; Ok(dir) } #[cfg(test)] mod tests { use super::*; #[test] fn short_help_surface_uses_the_production_command_factory() { let surface = short_help_surface().expect("root short help is a Clap display-help error"); let mut command = cli_command(); let error = command .try_get_matches_from_mut(["smith", "--help"]) .expect_err("root help exits through Clap DisplayHelp"); assert_eq!(error.kind(), clap::error::ErrorKind::DisplayHelp); assert_eq!(surface.rendered_bytes, error.to_string().len() as u64); assert!(surface.command_nodes > 1); assert!(surface.argument_placements >= surface.command_nodes); } #[test] fn typescript_component_normalization_makes_memory_limits_fixed() { let source = "(component\n (core module $main\n (memory (;0;) 145)\n )\n)\n"; let (normalized, memories) = normalize_component_memories(source).expect("memory syntax"); assert_eq!(memories, 1); assert!(normalized.contains("(memory (;0;) 145 145)")); } #[test] fn bounded_stdin_line_distinguishes_eof_limit_newline_and_utf8() { let at_limit = b"four\n"; assert!(matches!( read_stdin_line(&mut &at_limit[..], 4), Ok(StdinLine::Line(line)) if line == "four" )); let over_limit = b"fives"; assert!(read_stdin_line(&mut &over_limit[..], 4).is_err()); let no_newline = b"four"; assert!(matches!( read_stdin_line(&mut &no_newline[..], 4), Ok(StdinLine::Line(line)) if line == "four" )); assert!(matches!( read_stdin_line(&mut &b""[..], 4), Ok(StdinLine::Eof) )); assert_eq!( read_stdin_line(&mut &b"\xff\n"[..], 4) .expect_err("invalid UTF-8 is rejected") .kind(), std::io::ErrorKind::InvalidData ); } #[test] fn session_directory_creation_reports_storage_path_and_operation() { let root = std::env::temp_dir().join(format!("smith_cli_session_dir_{}", std::process::id())); let _ = std::fs::remove_dir_all(&root); assert!(std::fs::write(&root, "block directory creation").is_ok()); let attempted = root.join("run"); let error = create_session_dir(attempted.clone()).expect_err("file blocks directory"); assert_eq!(error.code(), "RUNTIME_DIR"); assert!( error .to_string() .contains("storage [RUNTIME_DIR] create_dir_all") ); match &error { smith::error::SmithError::Storage { code, operation, path, .. } => { assert_eq!(*code, smith::error::StorageCode::RuntimeDir); assert_eq!(operation.as_str(), "create_dir_all"); assert_eq!(path, &attempted); } other => panic!("expected storage error, got {other:?}"), } let serialized = serde_json::to_value(&error).expect("serialize error"); assert_eq!(serialized["Storage"]["code"], "RUNTIME_DIR"); assert_eq!( serialized["Storage"]["path"], attempted.to_string_lossy().as_ref() ); assert!(std::fs::remove_file(root).is_ok()); } }