Struct GlobalArgs 

pub struct GlobalArgs {

    pub cwd: PathBuf,
    pub manifest_path: String,
    pub api_url: String,
    pub api_token: Option<String>,
    pub org: Option<String>,
    pub proxy_url: String,
    pub ecosystems: Option<Vec<String>>,
    pub download_mode: String,
    pub offline: bool,
    pub global: bool,
    pub global_prefix: Option<PathBuf>,
    pub json: bool,
    pub verbose: bool,
    pub silent: bool,
    pub dry_run: bool,
    pub yes: bool,
    pub lock_timeout: Option<u64>,
    pub break_lock: bool,
    pub debug: bool,
    pub no_telemetry: bool,
}

Arguments inherited by every subcommand via #[command(flatten)].

Every global flag is parseable on every subcommand. Commands that don’t use a given flag ignore it silently — e.g. list --global parses fine and the global field is unused at runtime.

Fields

cwd: PathBuf

Working directory.

manifest_path: String

Path to patch manifest file (resolved relative to –cwd).

api_url: String

Socket API URL (authenticated endpoint).

api_token: Option<String>

Socket API token. Absence selects the public patch proxy.

org: Option<String>

Organization slug. Auto-resolved when omitted and a token is set.

proxy_url: String

Public proxy URL used when no API token is set.

ecosystems: Option<Vec<String>>

Restrict to these ecosystems (comma-separated).

download_mode: String

Which kind of patch artifact to download when local files are missing. diff (default) fetches the smallest delta archive; package fetches a full per-package tarball; file falls back to legacy per-file blobs.

offline: bool

Strict airgap: never contact the network. Operations that need remote data fail loudly when this is set.

global: bool

Operate on globally-installed packages.

global_prefix: Option<PathBuf>

Override the path used to discover globally-installed packages.

json: bool

Emit machine-readable JSON output.

verbose: bool

Show extra detail in human-readable output.

silent: bool

Suppress non-error output.

dry_run: bool

Preview the operation without making any mutations.

yes: bool

Skip interactive prompts.

lock_timeout: Option<u64>

Seconds to wait for <.socket>/apply.lock before giving up. Default (None) and 0 both mean a single non-blocking try — failing immediately if another process holds the lock. A positive value retries with a 100 ms backoff until the lock frees or the budget elapses. Only meaningful for the mutating subcommands (apply, rollback, repair, remove); other commands accept it silently.

break_lock: bool

Force-remove <.socket>/apply.lock before attempting acquisition. Use when you are certain no other socket-patch process is running (e.g. a previous run crashed in a way that stripped the OS lock but left the file). Emits a lock_broken warning event in the JSON envelope so the action is auditable. Only meaningful for mutating subcommands; other commands accept it silently.

debug: bool

Emit verbose debug logs to stderr.

no_telemetry: bool

Disable anonymous usage telemetry.

Implementations

impl GlobalArgs

pub fn resolved_manifest_path(&self) -> PathBuf

Resolve manifest_path against cwd. See socket_patch_core::manifest::operations::resolve_manifest_path.

pub fn api_client_overrides(&self) -> ApiClientEnvOverrides

Build ApiClientEnvOverrides from the CLI flags.

api_token and org are forwarded as Some(_) only when set. api_url and proxy_url are forwarded only when non-empty; GlobalArgs::default() leaves both empty so integration tests that mutate env vars after constructing args still get env-var resolution from get_api_client_with_overrides. In production clap always populates them with either the CLI value, the env value, or the clap-declared default — all non-empty — so the resolved value still flows through.

Trait Implementations

impl Args for GlobalArgs

fn group_id() -> Option<Id>

Report the ArgGroup::id for this set of arguments

fn augment_args<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate Self via FromArgMatches::from_arg_matches_mut

fn augment_args_for_update<'b>(__clap_app: Command) -> Command

Append to Command so it can instantiate self via FromArgMatches::update_from_arg_matches_mut

impl Clone for GlobalArgs

fn clone(&self) -> GlobalArgs

Returns a duplicate of the value.

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

Performs copy-assignment from source.

impl Debug for GlobalArgs

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

Formats the value using the given formatter.

impl Default for GlobalArgs

fn default() -> Self

Defaults intended for test struct literals (e.g. ..GlobalArgs::default()).

In production every field is populated by clap (with the default_value = ".." attribute providing the documented defaults when neither CLI flag nor env var is set), so this Default is only reached from tests building GlobalArgs directly.

api_url and proxy_url are intentionally empty here (not the production default URLs). That lets tests set SOCKET_API_URL / SOCKET_PROXY_URL via std::env::set_var after constructing the args struct and have those env vars flow through to the API client — api_client_overrides skips empty values so the underlying get_api_client_with_overrides falls back to env-var resolution.

impl FromArgMatches for GlobalArgs

fn from_arg_matches(__clap_arg_matches: &ArgMatches) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn from_arg_matches_mut( __clap_arg_matches: &mut ArgMatches, ) -> Result<Self, Error>

Instantiate Self from ArgMatches, parsing the arguments as needed.

fn update_from_arg_matches( &mut self, __clap_arg_matches: &ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.

fn update_from_arg_matches_mut( &mut self, __clap_arg_matches: &mut ArgMatches, ) -> Result<(), Error>

Assign values from ArgMatches to self.