Summary: 230 instances, 166 unique

Text	Count
FileSystemSandboxKind::Unrestricted | FileSystemSandboxKind::ExternalSandbox => {	1
let approval_policy = if shared.dangerously_bypass_approvals_and_sandbox {	1
.mut_arg("dangerously_bypass_approvals_and_sandbox", |arg| {	1
SandboxPolicy::ExternalSandbox { network_access } => {	1
assert!(interactive.dangerously_bypass_approvals_and_sandbox);	1
SandboxPolicy::ExternalSandbox { .. } => true,	1
SandboxPolicy::ExternalSandbox { .. } => Self::External,	1
fn resume_merges_dangerously_bypass_flag() {	1
alias = "not-so-yolo",	1
SandboxModeRequirement::DangerFullAccess => PermissionProfile::Disabled,	1
"CODEX_SANDBOX_ENV_VAR",	1
candidate: "DangerFullAccess".into(),	4
dangerously_bypass_approvals_and_sandbox,	4
CoreSandboxMode::DangerFullAccess => SandboxMode::DangerFullAccess,	1
query: Some("CODEX_SANDBOX_ENV_VAR".to_string()),	2
*root_dangerously_bypass_approvals_and_sandbox;	1
SandboxPolicy::ExternalSandbox { network_access } => {	1
pub const CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR: &str = "CODEX_SANDBOX_NETWORK_DISABLED";	1
&vec_str(&["grep", "-R", "CODEX_SANDBOX_ENV_VAR", "-n", "."]),	1
conflicts_with_all = ["sandbox_mode", "dangerously_bypass_approvals_and_sandbox"]	1
let sandbox_mode = if interactive.dangerously_bypass_approvals_and_sandbox {	1
sandbox_policy: SandboxPolicy::DangerFullAccess,	3
SandboxModeRequirement::DangerFullAccess | SandboxModeRequirement::ExternalSandbox => {	1
use codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;	1
FileSystemSandboxKind::ExternalSandbox => return None,	1
pub dangerously_bypass_approvals_and_sandbox: bool,	1
cmd: "grep -R CODEX_SANDBOX_ENV_VAR -n core/src/spawn.rs".to_string(),	1
let sandbox_mode = if dangerously_bypass_approvals_and_sandbox {	1
return (SandboxMode::DangerFullAccess, None);	1
SandboxPolicy::ExternalSandbox {	1
let v2_policy = SandboxPolicy::ExternalSandbox {	1
dangerously_bypass_approvals_and_sandbox: root_dangerously_bypass_approvals_and_sandbox,	1
SandboxPolicyDeserialize::ExternalSandbox { network_access } => {	1
dangerously_bypass_approvals_and_sandbox,	2
Some(SandboxMode::DangerFullAccess)	1
SandboxMode::DangerFullAccess,	2
Self::Disabled => Ok(SandboxPolicy::DangerFullAccess),	1
SandboxPolicy::ExternalSandbox { .. } => {	1
codex_protocol::protocol::SandboxPolicy::ExternalSandbox {	1
FileSystemSandboxKind::ExternalSandbox	1
"the legacy ExternalSandbox projection must not hide a split unrestricted filesystem policy"	1
ExternalSandbox,	3
ExternalSandbox {	3
SandboxPolicy::DangerFullAccess	2
CoreSandboxModeRequirement::DangerFullAccess => Some(SandboxMode::DangerFullAccess),	1
"--dangerously-bypass-approvals-and-sandbox",	1
"danger-full-access" => Ok(SandboxPolicy::DangerFullAccess),	1
SandboxPolicy::DangerFullAccess	1
FileSystemSandboxKind::ExternalSandbox => SandboxPolicy::ExternalSandbox {	1
SandboxPolicy::ExternalSandbox {	2
PermissionProfile::from_legacy_sandbox_policy(&SandboxPolicy::DangerFullAccess);	1
SandboxModeCliArg::DangerFullAccess => SandboxMode::DangerFullAccess,	1
*dangerously_bypass_approvals_and_sandbox =	1
vec!["--dangerously-bypass-approvals-and-sandbox"],	1
SandboxPolicy::ExternalSandbox {	1
SandboxModeRequirement::DangerFullAccess | SandboxModeRequirement::ExternalSandbox	1
root=DangerFullAccessSandboxPolicy(type="dangerFullAccess"),	1
SandboxModeCliArg::DangerFullAccess.into()	1
SandboxMode::DangerFullAccess,	1
CoreSandboxModeRequirement::ExternalSandbox => None,	1
PermissionProfile::Disabled => SandboxModeRequirement::DangerFullAccess,	1
// would normally grant full network access (for example, DangerFullAccess).	1
CodexToolCallSandboxMode::DangerFullAccess => SandboxMode::DangerFullAccess,	1
("danger.txt", SandboxPolicy::DangerFullAccess),	1
let sandbox_policy = SandboxPolicy::ExternalSandbox {	1
codex_app_server_protocol::SandboxMode::DangerFullAccess => PermissionProfile::Disabled,	1
SandboxModeRequirement::DangerFullAccess => "danger-full-access".to_string(),	1
codex_protocol::protocol::SandboxPolicy::DangerFullAccess => {	1
FileSystemSandboxKind::ExternalSandbox => SandboxEnforcement::External,	1
SandboxPolicy::ExternalSandbox { .. } => Vec::new(),	1
SandboxPolicy::DangerFullAccess => FileSystemSandboxPolicy::unrestricted(),	1
self.dangerously_bypass_approvals_and_sandbox =	1
SandboxPolicy::DangerFullAccess	2
let sandbox_mode = if shared.dangerously_bypass_approvals_and_sandbox {	1
Some(codex_app_server_protocol::SandboxMode::DangerFullAccess)	2
"`--dangerously-bypass-hook-trust` is enabled. Enabled hooks may run without review for this invocation."	1
Some(SandboxMode::DangerFullAccess),	1
codex_app_server_protocol::SandboxPolicy::DangerFullAccess	1
candidate: "ExternalSandbox".into(),	1
SandboxModeRequirement::DangerFullAccess,	1
FileSystemSandboxKind::Unrestricted | FileSystemSandboxKind::ExternalSandbox => {	3
codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR	15
&codex_app_server_protocol::SandboxPolicy::DangerFullAccess,	1
FileSystemSandboxKind::Unrestricted | FileSystemSandboxKind::ExternalSandbox => true,	2
SandboxMode::DangerFullAccess => messages.danger_full_access.as_deref(),	1
"--dangerously-bypass-hook-trust",	1
SandboxModeRequirement::DangerFullAccess	1
FileSystemSandboxKind::ExternalSandbox => unreachable!(	1
SandboxMode::DangerFullAccess => &*SANDBOX_MODE_DANGER_FULL_ACCESS_TEMPLATE,	1
let enabled = SandboxPolicy::ExternalSandbox {	1
sandbox: SandboxPolicy::DangerFullAccess,	1
Ok(SandboxPolicy::ExternalSandbox { network_access })	1
codex_protocol::protocol::SandboxPolicy::ExternalSandbox {	1
let summary = summarize_sandbox_policy(&SandboxPolicy::ExternalSandbox {	2
sandbox_policy: SandboxPolicy::DangerFullAccess,	1
SandboxPolicy::DangerFullAccess,	1
&& !dangerously_bypass_approvals_and_sandbox	1
== SandboxModeRequirement::DangerFullAccess	1
use crate::spawn::CODEX_SANDBOX_ENV_VAR;	1
if std::env::var(codex_core::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR).is_ok() {	15
sandbox: v2::SandboxPolicy::DangerFullAccess,	1
cmd: "grep -R CODEX_SANDBOX_ENV_VAR -n .".to_string(),	1
let restricted = SandboxPolicy::ExternalSandbox {	1
SandboxMode::DangerFullAccess => PermissionProfile::Disabled,	1
Self::External { network } => Ok(SandboxPolicy::ExternalSandbox {	1
CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR.to_string(),	1
SandboxModeRequirement::ExternalSandbox => "external-sandbox".to_string(),	1
SandboxPolicy::DangerFullAccess => true,	2
/// CODEX_SANDBOX_NETWORK_DISABLED=1 is added to the environment of the spawned	1
["codex", "resume", "--dangerously-bypass-hook-trust"].as_ref(),	1
// When --yolo (dangerously_bypass_approvals_and_sandbox) is set, also skip the git repo check	1
SandboxMode::DangerFullAccess => CoreSandboxMode::DangerFullAccess,	1
SandboxPolicy::ExternalSandbox { network_access } => network_access.is_enabled(),	1
SandboxPolicy::ExternalSandbox {	2
FileSystemSandboxKind::Unrestricted | FileSystemSandboxKind::ExternalSandbox => {	1
"external-sandbox" => Ok(SandboxPolicy::ExternalSandbox {	1
long = "dangerously-bypass-approvals-and-sandbox",	1
| SandboxPolicy::ExternalSandbox { .. }	1
kind: FileSystemSandboxKind::ExternalSandbox,	1
SandboxModeRequirement::DangerFullAccess,	1
|| subcommand.dangerously_bypass_approvals_and_sandbox;	1
SandboxModeRequirement::ExternalSandbox => PermissionProfile::External {	1
SandboxPolicy::DangerFullAccess => SandboxMode::DangerFullAccess,	1
cmd.mut_arg("dangerously_bypass_approvals_and_sandbox", |arg| {	1
SandboxPolicy::DangerFullAccess => {	1
let approval_policy = if interactive.dangerously_bypass_approvals_and_sandbox {	1
codex_protocol::protocol::SandboxPolicy::ExternalSandbox { network_access } => {	1
SandboxModeRequirement::ExternalSandbox,	1
SandboxPolicyDeserialize::DangerFullAccess => Ok(SandboxPolicy::DangerFullAccess),	1
SandboxPolicy::DangerFullAccess => Vec::new(),	1
codex_protocol::protocol::SandboxPolicy::DangerFullAccess	2
FileSystemSandboxKind::ExternalSandbox => Self::External {	1
Some(codex_protocol::config_types::SandboxMode::DangerFullAccess)	2
SandboxModeRequirement::DangerFullAccess	1
assert_eq!(overrides.sandbox_mode, Some(SandboxMode::DangerFullAccess));	1
alias = "yolo",	1
"--dangerously-bypass-approvals-and-sandbox",	1
SandboxPolicy::DangerFullAccess => Self::Disabled,	1
let (sandbox_mode, approval_policy) = if cli.dangerously_bypass_approvals_and_sandbox {	1
| SandboxModeRequirement::ExternalSandbox => {	1
#[arg(long = "dangerously-bypass-hook-trust", default_value_t = false)]	1
use crate::spawn::CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR;	1
return Err(PermissionIntersectionError::ExternalSandbox);	1
SandboxPolicy::DangerFullAccess	1
dangerously_bypass_approvals_and_sandbox: bool,	1
DangerFullAccess,	8
pub const CODEX_SANDBOX_ENV_VAR: &str = "CODEX_SANDBOX";	1
.then_some(codex_app_server_protocol::SandboxMode::DangerFullAccess)	2
"`--dangerously-bypass-hook-trust` is enabled. Enabled hooks may run without review for this invocation."	1
PermissionProfile::External { .. } => SandboxModeRequirement::ExternalSandbox,	1
assert!(!help.contains("--not-so-yolo"), "{help}");	1
SandboxPolicy::ExternalSandbox { .. } => FileSystemSandboxPolicy::external_sandbox(),	1
codex_protocol::protocol::SandboxPolicy::ExternalSandbox { .. }	1
use codex_core::spawn::CODEX_SANDBOX_ENV_VAR;	1
FileSystemSandboxKind::Unrestricted | FileSystemSandboxKind::ExternalSandbox => false,	1
|| self.dangerously_bypass_approvals_and_sandbox;	1
env.insert(CODEX_SANDBOX_ENV_VAR.to_string(), "seatbelt".to_string());	1
env_map.insert(CODEX_SANDBOX_ENV_VAR.to_string(), "seatbelt".to_string());	1
SandboxPolicy::DangerFullAccess => "danger-full-access".to_string(),	1
DangerFullAccessSandboxPolicy,	1
sandbox_policy: v2::SandboxPolicy::DangerFullAccess,	1
cmd.env(CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR, "1");	2
/// `CODEX_SANDBOX_NETWORK_DISABLED_ENV_VAR` environment variable.	1
dangerously_bypass_approvals_and_sandbox;	1
for flag in ["--approve-for-me", "--not-so-yolo"] {	1
SandboxMode::DangerFullAccess => SandboxModeRequirement::DangerFullAccess,	1
