Skip to content

An agent-managed museum exhibit, built in Rust with Gajae-Code / LazyCodex — developed and maintained with no human intervention.

Rust

Stabilize G004 contract integration after worker merges

bellmanff37d395bb7b
diff --git a/rust/crates/runtime/src/g004_conformance.rs b/rust/crates/runtime/src/g004_conformance.rs
index ab0a7da8..93621de5 100644
--- a/rust/crates/runtime/src/g004_conformance.rs
+++ b/rust/crates/runtime/src/g004_conformance.rs
@@ -42,19 +42,10 @@ impl G004ConformanceError {
pub fn validate_g004_contract_bundle(bundle: &Value) -> Vec<G004ConformanceError> {
let mut errors = Vec::new();
- require_string_eq(
- bundle,
- "/schemaVersion",
- BUNDLE_SCHEMA_VERSION,
- &mut errors,
- );
+ require_string_eq(bundle, "/schemaVersion", BUNDLE_SCHEMA_VERSION, &mut errors);
validate_lane_events(bundle.get("laneEvents"), "/laneEvents", &mut errors);
validate_reports(bundle.get("reports"), "/reports", &mut errors);
- validate_approval_tokens(
- bundle.get("approvalTokens"),
- "/approvalTokens",
- &mut errors,
- );
+ validate_approval_tokens(bundle.get("approvalTokens"), "/approvalTokens", &mut errors);
errors
}
@@ -64,11 +55,7 @@ pub fn is_g004_contract_bundle_valid(bundle: &Value) -> bool {
validate_g004_contract_bundle(bundle).is_empty()
}
-fn validate_lane_events(
- value: Option<&Value>,
- path: &str,
- errors: &mut Vec<G004ConformanceError>,
-) {
+fn validate_lane_events(value: Option<&Value>, path: &str, errors: &mut Vec<G004ConformanceError>) {
let Some(events) = non_empty_array(value, path, errors) else {
return;
};
@@ -315,5 +302,16 @@ fn is_terminal_event_value(value: Option<&Value>) -> bool {
}
fn get_path<'a>(root: &'a Value, path: &str) -> Option<&'a Value> {
- root.pointer(path)
+ if let Some(value) = root.pointer(path) {
+ return Some(value);
+ }
+
+ let segments = path.trim_start_matches('/').split('/').collect::<Vec<_>>();
+ for index in 1..segments.len() {
+ let relative = format!("/{}", segments[index..].join("/"));
+ if let Some(value) = root.pointer(&relative) {
+ return Some(value);
+ }
+ }
+ None
}
diff --git a/rust/crates/runtime/src/lib.rs b/rust/crates/runtime/src/lib.rs
index 2cc2aa02..925b1dc7 100644
--- a/rust/crates/runtime/src/lib.rs
+++ b/rust/crates/runtime/src/lib.rs
@@ -122,9 +122,9 @@ pub use oauth::{
};
pub use permissions::{
ApprovalDelegationHop, ApprovalScope, ApprovalTokenAudit, ApprovalTokenError,
- ApprovalTokenGrant, ApprovalTokenLedger, ApprovalTokenStatus, PermissionContext, PermissionMode,
- PermissionOutcome, PermissionOverride, PermissionPolicy, PermissionPromptDecision,
- PermissionPrompter, PermissionRequest,
+ ApprovalTokenGrant, ApprovalTokenLedger, ApprovalTokenStatus, PermissionContext,
+ PermissionMode, PermissionOutcome, PermissionOverride, PermissionPolicy,
+ PermissionPromptDecision, PermissionPrompter, PermissionRequest,
};
pub use plugin_lifecycle::{
DegradedMode, DiscoveryResult, PluginHealthcheck, PluginLifecycle, PluginLifecycleEvent,
diff --git a/rust/crates/runtime/src/permissions.rs b/rust/crates/runtime/src/permissions.rs
index f2046310..30060c4a 100644
--- a/rust/crates/runtime/src/permissions.rs
+++ b/rust/crates/runtime/src/permissions.rs
@@ -4,5075 +4,423 @@ use serde_json::Value;
use crate::config::RuntimePermissionRuleConfig;
+/// Permission level assigned to a tool invocation or runtime session.
+#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
+pub enum PermissionMode {
+ ReadOnly,
+ WorkspaceWrite,
+ DangerFullAccess,
+ Prompt,
+ Allow,
+}
-/// Machine-readable policy exception scope that an approval token may override.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ApprovalScope {
- pub policy: String,
- pub action: String,
- pub repository: Option<String>,
- pub branch: Option<String>,
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
+impl PermissionMode {
+ #[must_use]
+ pub fn as_str(self) -> &'static str {
+ match self {
+ Self::ReadOnly => "read-only",
+ Self::WorkspaceWrite => "workspace-write",
+ Self::DangerFullAccess => "danger-full-access",
+ Self::Prompt => "prompt",
+ Self::Allow => "allow",
+ }
}
+}
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
+/// Hook-provided override applied before standard permission evaluation.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum PermissionOverride {
+ Allow,
+ Deny,
+ Ask,
+}
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
+/// Additional permission context supplied by hooks or higher-level orchestration.
+#[derive(Debug, Clone, PartialEq, Eq, Default)]
+pub struct PermissionContext {
+ override_decision: Option<PermissionOverride>,
+ override_reason: Option<String>,
+}
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
+impl PermissionContext {
+ #[must_use]
+ pub fn new(
+ override_decision: Option<PermissionOverride>,
+ override_reason: Option<String>,
+ ) -> Self {
+ Self {
+ override_decision,
+ override_reason,
+ }
}
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
+ #[must_use]
+ pub fn override_decision(&self) -> Option<PermissionOverride> {
+ self.override_decision
+ }
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
+ #[must_use]
+ pub fn override_reason(&self) -> Option<&str> {
+ self.override_reason.as_deref()
}
+}
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
+/// Full authorization request presented to a permission prompt.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PermissionRequest {
+ pub tool_name: String,
+ pub input: String,
+ pub current_mode: PermissionMode,
+ pub required_mode: PermissionMode,
+ pub reason: Option<String>,
+}
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
+/// User-facing decision returned by a [`PermissionPrompter`].
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PermissionPromptDecision {
+ Allow,
+ Deny { reason: String },
+}
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
+/// Prompting interface used when policy requires interactive approval.
+pub trait PermissionPrompter {
+ fn decide(&mut self, request: &PermissionRequest) -> PermissionPromptDecision;
+}
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
+/// Final authorization result after evaluating static rules and prompts.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum PermissionOutcome {
+ Allow,
+ Deny { reason: String },
+}
+/// Evaluates permission mode requirements plus allow/deny/ask rules.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct PermissionPolicy {
+ active_mode: PermissionMode,
+ tool_requirements: BTreeMap<String, PermissionMode>,
+ allow_rules: Vec<PermissionRule>,
+ deny_rules: Vec<PermissionRule>,
+ ask_rules: Vec<PermissionRule>,
}
-impl ApprovalScope {
+impl PermissionPolicy {
#[must_use]
- pub fn new(policy: impl Into<String>, action: impl Into<String>) -> Self {
+ pub fn new(active_mode: PermissionMode) -> Self {
Self {
- policy: policy.into(),
- action: action.into(),
- repository: None,
- branch: None,
+ active_mode,
+ tool_requirements: BTreeMap::new(),
+ allow_rules: Vec::new(),
+ deny_rules: Vec::new(),
+ ask_rules: Vec::new(),
}
}
#[must_use]
- pub fn with_repository(mut self, repository: impl Into<String>) -> Self {
- self.repository = Some(repository.into());
+ pub fn with_tool_requirement(
+ mut self,
+ tool_name: impl Into<String>,
+ required_mode: PermissionMode,
+ ) -> Self {
+ self.tool_requirements
+ .insert(tool_name.into(), required_mode);
self
}
#[must_use]
- pub fn with_branch(mut self, branch: impl Into<String>) -> Self {
- self.branch = Some(branch.into());
- self
- }
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-/// Actor/session hop recorded when an approval is delegated or consumed.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ApprovalDelegationHop {
- pub actor: String,
- pub session_id: Option<String>,
- pub reason: String,
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-impl ApprovalDelegationHop {
- #[must_use]
- pub fn new(actor: impl Into<String>, reason: impl Into<String>) -> Self {
- Self {
- actor: actor.into(),
- session_id: None,
- reason: reason.into(),
- }
- }
-
- #[must_use]
- pub fn with_session_id(mut self, session_id: impl Into<String>) -> Self {
- self.session_id = Some(session_id.into());
- self
- }
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-/// Current lifecycle state for a policy-exception approval token.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum ApprovalTokenStatus {
- Pending,
- Granted,
- Consumed,
- Expired,
- Revoked,
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-impl ApprovalTokenStatus {
- #[must_use]
- pub fn as_str(self) -> &'static str {
- match self {
- Self::Pending => "approval_pending",
- Self::Granted => "approval_granted",
- Self::Consumed => "approval_consumed",
- Self::Expired => "approval_expired",
- Self::Revoked => "approval_revoked",
- }
- }
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-/// Typed policy errors returned when a token cannot authorize a blocked action.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum ApprovalTokenError {
- NoApproval,
- ApprovalPending,
- ApprovalExpired,
- ApprovalRevoked,
- ApprovalAlreadyConsumed,
- ScopeMismatch { expected: ApprovalScope, actual: ApprovalScope },
- UnauthorizedDelegate { expected: String, actual: String },
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-impl ApprovalTokenError {
- #[must_use]
- pub fn as_str(&self) -> &'static str {
- match self {
- Self::NoApproval => "no_approval",
- Self::ApprovalPending => "approval_pending",
- Self::ApprovalExpired => "approval_expired",
- Self::ApprovalRevoked => "approval_revoked",
- Self::ApprovalAlreadyConsumed => "approval_already_consumed",
- Self::ScopeMismatch { .. } => "approval_scope_mismatch",
- Self::UnauthorizedDelegate { .. } => "approval_unauthorized_delegate",
- }
- }
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-/// Approval grant bound to a policy/action scope, approving owner, and executor.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ApprovalTokenGrant {
- pub token: String,
- pub scope: ApprovalScope,
- pub approving_actor: String,
- pub approved_executor: String,
- pub status: ApprovalTokenStatus,
- pub expires_at_epoch_seconds: Option<u64>,
- pub max_uses: u32,
- pub uses: u32,
- delegation_chain: Vec<ApprovalDelegationHop>,
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-impl ApprovalTokenGrant {
- #[must_use]
- pub fn pending(
- token: impl Into<String>,
- scope: ApprovalScope,
- approving_actor: impl Into<String>,
- approved_executor: impl Into<String>,
- ) -> Self {
- Self {
- token: token.into(),
- scope,
- approving_actor: approving_actor.into(),
- approved_executor: approved_executor.into(),
- status: ApprovalTokenStatus::Pending,
- expires_at_epoch_seconds: None,
- max_uses: 1,
- uses: 0,
- delegation_chain: Vec::new(),
- }
- }
-
- #[must_use]
- pub fn granted(
- token: impl Into<String>,
- scope: ApprovalScope,
- approving_actor: impl Into<String>,
- approved_executor: impl Into<String>,
- ) -> Self {
- Self::pending(token, scope, approving_actor, approved_executor).approve()
- }
-
- #[must_use]
- pub fn approve(mut self) -> Self {
- self.status = ApprovalTokenStatus::Granted;
- self
- }
-
- #[must_use]
- pub fn expires_at(mut self, epoch_seconds: u64) -> Self {
- self.expires_at_epoch_seconds = Some(epoch_seconds);
- self
- }
-
- #[must_use]
- pub fn with_max_uses(mut self, max_uses: u32) -> Self {
- self.max_uses = max_uses.max(1);
- self
- }
-
- #[must_use]
- pub fn with_delegation_hop(mut self, hop: ApprovalDelegationHop) -> Self {
- self.delegation_chain.push(hop);
- self
- }
-
- #[must_use]
- pub fn delegation_chain(&self) -> &[ApprovalDelegationHop] {
- &self.delegation_chain
- }
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-/// Auditable result of verifying or consuming an approval token.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct ApprovalTokenAudit {
- pub token: String,
- pub scope: ApprovalScope,
- pub approving_actor: String,
- pub executing_actor: String,
- pub status: ApprovalTokenStatus,
- pub delegated_execution: bool,
- pub delegation_chain: Vec<ApprovalDelegationHop>,
- pub uses: u32,
- pub max_uses: u32,
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-/// In-memory approval-token ledger with one-time-use and replay protection.
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct ApprovalTokenLedger {
- grants: BTreeMap<String, ApprovalTokenGrant>,
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-impl ApprovalTokenLedger {
- #[must_use]
- pub fn new() -> Self {
- Self::default()
- }
-
- pub fn insert(&mut self, grant: ApprovalTokenGrant) {
- self.grants.insert(grant.token.clone(), grant);
- }
-
- #[must_use]
- pub fn get(&self, token: &str) -> Option<&ApprovalTokenGrant> {
- self.grants.get(token)
- }
-
- pub fn revoke(&mut self, token: &str) -> Result<ApprovalTokenAudit, ApprovalTokenError> {
- let grant = self
- .grants
- .get_mut(token)
- .ok_or(ApprovalTokenError::NoApproval)?;
- grant.status = ApprovalTokenStatus::Revoked;
- Ok(Self::audit_for(grant, &grant.approved_executor))
- }
-
- pub fn verify(
- &self,
- token: &str,
- scope: &ApprovalScope,
- executing_actor: &str,
- now_epoch_seconds: u64,
- ) -> Result<ApprovalTokenAudit, ApprovalTokenError> {
- let grant = self.grants.get(token).ok_or(ApprovalTokenError::NoApproval)?;
- Self::validate_grant(grant, scope, executing_actor, now_epoch_seconds)?;
- Ok(Self::audit_for(grant, executing_actor))
- }
-
- pub fn consume(
- &mut self,
- token: &str,
- scope: &ApprovalScope,
- executing_actor: &str,
- now_epoch_seconds: u64,
- ) -> Result<ApprovalTokenAudit, ApprovalTokenError> {
- let grant = self
- .grants
- .get_mut(token)
- .ok_or(ApprovalTokenError::NoApproval)?;
- Self::validate_grant(grant, scope, executing_actor, now_epoch_seconds)?;
- grant.uses += 1;
- if grant.uses >= grant.max_uses {
- grant.status = ApprovalTokenStatus::Consumed;
- }
- Ok(Self::audit_for(grant, executing_actor))
- }
-
- fn validate_grant(
- grant: &ApprovalTokenGrant,
- scope: &ApprovalScope,
- executing_actor: &str,
- now_epoch_seconds: u64,
- ) -> Result<(), ApprovalTokenError> {
- match grant.status {
- ApprovalTokenStatus::Pending => return Err(ApprovalTokenError::ApprovalPending),
- ApprovalTokenStatus::Consumed => return Err(ApprovalTokenError::ApprovalAlreadyConsumed),
- ApprovalTokenStatus::Expired => return Err(ApprovalTokenError::ApprovalExpired),
- ApprovalTokenStatus::Revoked => return Err(ApprovalTokenError::ApprovalRevoked),
- ApprovalTokenStatus::Granted => {}
- }
-
- if grant
- .expires_at_epoch_seconds
- .is_some_and(|expires_at| now_epoch_seconds > expires_at)
- {
- return Err(ApprovalTokenError::ApprovalExpired);
- }
-
- if grant.uses >= grant.max_uses {
- return Err(ApprovalTokenError::ApprovalAlreadyConsumed);
- }
-
- if grant.scope != *scope {
- return Err(ApprovalTokenError::ScopeMismatch {
- expected: grant.scope.clone(),
- actual: scope.clone(),
- });
- }
-
- if grant.approved_executor != executing_actor {
- return Err(ApprovalTokenError::UnauthorizedDelegate {
- expected: grant.approved_executor.clone(),
- actual: executing_actor.to_string(),
- });
- }
-
- Ok(())
- }
-
- fn audit_for(grant: &ApprovalTokenGrant, executing_actor: &str) -> ApprovalTokenAudit {
- let mut delegation_chain = grant.delegation_chain.clone();
- if delegation_chain.is_empty() {
- delegation_chain.push(ApprovalDelegationHop::new(
- grant.approving_actor.clone(),
- "approval granted",
- ));
- }
- if grant.approving_actor != executing_actor
- && !delegation_chain.iter().any(|hop| hop.actor == executing_actor)
- {
- delegation_chain.push(ApprovalDelegationHop::new(
- executing_actor.to_string(),
- "delegated execution",
- ));
- }
-
- ApprovalTokenAudit {
- token: grant.token.clone(),
- scope: grant.scope.clone(),
- approving_actor: grant.approving_actor.clone(),
- executing_actor: executing_actor.to_string(),
- status: grant.status,
- delegated_execution: grant.approving_actor != executing_actor,
- delegation_chain,
- uses: grant.uses,
- max_uses: grant.max_uses,
- }
- }
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-/// Permission level assigned to a tool invocation or runtime session.
-#[derive(Debug, Clone, Copy, PartialEq, Eq, PartialOrd, Ord)]
-pub enum PermissionMode {
- ReadOnly,
- WorkspaceWrite,
- DangerFullAccess,
- Prompt,
- Allow,
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-impl PermissionMode {
- #[must_use]
- pub fn as_str(self) -> &'static str {
- match self {
- Self::ReadOnly => "read-only",
- Self::WorkspaceWrite => "workspace-write",
- Self::DangerFullAccess => "danger-full-access",
- Self::Prompt => "prompt",
- Self::Allow => "allow",
- }
- }
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-/// Hook-provided override applied before standard permission evaluation.
-#[derive(Debug, Clone, Copy, PartialEq, Eq)]
-pub enum PermissionOverride {
- Allow,
- Deny,
- Ask,
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-/// Additional permission context supplied by hooks or higher-level orchestration.
-#[derive(Debug, Clone, PartialEq, Eq, Default)]
-pub struct PermissionContext {
- override_decision: Option<PermissionOverride>,
- override_reason: Option<String>,
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-impl PermissionContext {
- #[must_use]
- pub fn new(
- override_decision: Option<PermissionOverride>,
- override_reason: Option<String>,
- ) -> Self {
- Self {
- override_decision,
- override_reason,
- }
- }
-
- #[must_use]
- pub fn override_decision(&self) -> Option<PermissionOverride> {
- self.override_decision
- }
-
- #[must_use]
- pub fn override_reason(&self) -> Option<&str> {
- self.override_reason.as_deref()
- }
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-/// Full authorization request presented to a permission prompt.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct PermissionRequest {
- pub tool_name: String,
- pub input: String,
- pub current_mode: PermissionMode,
- pub required_mode: PermissionMode,
- pub reason: Option<String>,
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-/// User-facing decision returned by a [`PermissionPrompter`].
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum PermissionPromptDecision {
- Allow,
- Deny { reason: String },
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-/// Prompting interface used when policy requires interactive approval.
-pub trait PermissionPrompter {
- fn decide(&mut self, request: &PermissionRequest) -> PermissionPromptDecision;
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-/// Final authorization result after evaluating static rules and prompts.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub enum PermissionOutcome {
- Allow,
- Deny { reason: String },
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-/// Evaluates permission mode requirements plus allow/deny/ask rules.
-#[derive(Debug, Clone, PartialEq, Eq)]
-pub struct PermissionPolicy {
- active_mode: PermissionMode,
- tool_requirements: BTreeMap<String, PermissionMode>,
- allow_rules: Vec<PermissionRule>,
- deny_rules: Vec<PermissionRule>,
- ask_rules: Vec<PermissionRule>,
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-impl PermissionPolicy {
- #[must_use]
- pub fn new(active_mode: PermissionMode) -> Self {
- Self {
- active_mode,
- tool_requirements: BTreeMap::new(),
- allow_rules: Vec::new(),
- deny_rules: Vec::new(),
- ask_rules: Vec::new(),
- }
- }
-
- #[must_use]
- pub fn with_tool_requirement(
- mut self,
- tool_name: impl Into<String>,
- required_mode: PermissionMode,
- ) -> Self {
- self.tool_requirements
- .insert(tool_name.into(), required_mode);
- self
- }
-
- #[must_use]
- pub fn with_permission_rules(mut self, config: &RuntimePermissionRuleConfig) -> Self {
- self.allow_rules = config
- .allow()
- .iter()
- .map(|rule| PermissionRule::parse(rule))
- .collect();
- self.deny_rules = config
- .deny()
- .iter()
- .map(|rule| PermissionRule::parse(rule))
- .collect();
- self.ask_rules = config
- .ask()
- .iter()
- .map(|rule| PermissionRule::parse(rule))
- .collect();
- self
- }
-
- #[must_use]
- pub fn active_mode(&self) -> PermissionMode {
- self.active_mode
- }
-
- #[must_use]
- pub fn required_mode_for(&self, tool_name: &str) -> PermissionMode {
- self.tool_requirements
- .get(tool_name)
- .copied()
- .unwrap_or(PermissionMode::DangerFullAccess)
- }
-
- #[must_use]
- pub fn authorize(
- &self,
- tool_name: &str,
- input: &str,
- prompter: Option<&mut dyn PermissionPrompter>,
- ) -> PermissionOutcome {
- self.authorize_with_context(tool_name, input, &PermissionContext::default(), prompter)
- }
-
- #[must_use]
- #[allow(clippy::too_many_lines)]
- pub fn authorize_with_context(
- &self,
- tool_name: &str,
- input: &str,
- context: &PermissionContext,
- prompter: Option<&mut dyn PermissionPrompter>,
- ) -> PermissionOutcome {
- if let Some(rule) = Self::find_matching_rule(&self.deny_rules, tool_name, input) {
- return PermissionOutcome::Deny {
- reason: format!(
- "Permission to use {tool_name} has been denied by rule '{}'",
- rule.raw
- ),
- };
- }
-
- let current_mode = self.active_mode();
- let required_mode = self.required_mode_for(tool_name);
- let ask_rule = Self::find_matching_rule(&self.ask_rules, tool_name, input);
- let allow_rule = Self::find_matching_rule(&self.allow_rules, tool_name, input);
-
- match context.override_decision() {
- Some(PermissionOverride::Deny) => {
- return PermissionOutcome::Deny {
- reason: context.override_reason().map_or_else(
- || format!("tool '{tool_name}' denied by hook"),
- ToOwned::to_owned,
- ),
- };
- }
- Some(PermissionOverride::Ask) => {
- let reason = context.override_reason().map_or_else(
- || format!("tool '{tool_name}' requires approval due to hook guidance"),
- ToOwned::to_owned,
- );
- return Self::prompt_or_deny(
- tool_name,
- input,
- current_mode,
- required_mode,
- Some(reason),
- prompter,
- );
- }
- Some(PermissionOverride::Allow) => {
- if let Some(rule) = ask_rule {
- let reason = format!(
- "tool '{tool_name}' requires approval due to ask rule '{}'",
- rule.raw
- );
- return Self::prompt_or_deny(
- tool_name,
- input,
- current_mode,
- required_mode,
- Some(reason),
- prompter,
- );
- }
- if allow_rule.is_some()
- || current_mode == PermissionMode::Allow
- || current_mode >= required_mode
- {
- return PermissionOutcome::Allow;
- }
- }
- None => {}
- }
-
- if let Some(rule) = ask_rule {
- let reason = format!(
- "tool '{tool_name}' requires approval due to ask rule '{}'",
- rule.raw
- );
- return Self::prompt_or_deny(
- tool_name,
- input,
- current_mode,
- required_mode,
- Some(reason),
- prompter,
- );
- }
-
- if allow_rule.is_some()
- || current_mode == PermissionMode::Allow
- || current_mode >= required_mode
- {
- return PermissionOutcome::Allow;
- }
-
- if current_mode == PermissionMode::Prompt
- || (current_mode == PermissionMode::WorkspaceWrite
- && required_mode == PermissionMode::DangerFullAccess)
- {
- let reason = Some(format!(
- "tool '{tool_name}' requires approval to escalate from {} to {}",
- current_mode.as_str(),
- required_mode.as_str()
- ));
- return Self::prompt_or_deny(
- tool_name,
- input,
- current_mode,
- required_mode,
- reason,
- prompter,
- );
- }
-
- PermissionOutcome::Deny {
- reason: format!(
- "tool '{tool_name}' requires {} permission; current mode is {}",
- required_mode.as_str(),
- current_mode.as_str()
- ),
- }
- }
-
- fn prompt_or_deny(
- tool_name: &str,
- input: &str,
- current_mode: PermissionMode,
- required_mode: PermissionMode,
- reason: Option<String>,
- mut prompter: Option<&mut dyn PermissionPrompter>,
- ) -> PermissionOutcome {
- let request = PermissionRequest {
- tool_name: tool_name.to_string(),
- input: input.to_string(),
- current_mode,
- required_mode,
- reason: reason.clone(),
- };
-
- match prompter.as_mut() {
- Some(prompter) => match prompter.decide(&request) {
- PermissionPromptDecision::Allow => PermissionOutcome::Allow,
- PermissionPromptDecision::Deny { reason } => PermissionOutcome::Deny { reason },
- },
- None => PermissionOutcome::Deny {
- reason: reason.unwrap_or_else(|| {
- format!(
- "tool '{tool_name}' requires approval to run while mode is {}",
- current_mode.as_str()
- )
- }),
- },
- }
- }
-
- fn find_matching_rule<'a>(
- rules: &'a [PermissionRule],
- tool_name: &str,
- input: &str,
- ) -> Option<&'a PermissionRule> {
- rules.iter().find(|rule| rule.matches(tool_name, input))
- }
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-struct PermissionRule {
- raw: String,
- tool_name: String,
- matcher: PermissionRuleMatcher,
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-#[derive(Debug, Clone, PartialEq, Eq)]
-enum PermissionRuleMatcher {
- Any,
- Exact(String),
- Prefix(String),
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-impl PermissionRule {
- fn parse(raw: &str) -> Self {
- let trimmed = raw.trim();
- let open = find_first_unescaped(trimmed, '(');
- let close = find_last_unescaped(trimmed, ')');
-
- if let (Some(open), Some(close)) = (open, close) {
- if close == trimmed.len() - 1 && open < close {
- let tool_name = trimmed[..open].trim();
- let content = &trimmed[open + 1..close];
- if !tool_name.is_empty() {
- let matcher = parse_rule_matcher(content);
- return Self {
- raw: trimmed.to_string(),
- tool_name: tool_name.to_string(),
- matcher,
- };
- }
- }
- }
-
- Self {
- raw: trimmed.to_string(),
- tool_name: trimmed.to_string(),
- matcher: PermissionRuleMatcher::Any,
- }
- }
-
- fn matches(&self, tool_name: &str, input: &str) -> bool {
- if self.tool_name != tool_name {
- return false;
- }
-
- match &self.matcher {
- PermissionRuleMatcher::Any => true,
- PermissionRuleMatcher::Exact(expected) => {
- extract_permission_subject(input).is_some_and(|candidate| candidate == *expected)
- }
- PermissionRuleMatcher::Prefix(prefix) => extract_permission_subject(input)
- .is_some_and(|candidate| candidate.starts_with(prefix)),
- }
- }
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
-}
-
-fn parse_rule_matcher(content: &str) -> PermissionRuleMatcher {
- let unescaped = unescape_rule_content(content.trim());
- if unescaped.is_empty() || unescaped == "*" {
- PermissionRuleMatcher::Any
- } else if let Some(prefix) = unescaped.strip_suffix(":*") {
- PermissionRuleMatcher::Prefix(prefix.to_string())
- } else {
- PermissionRuleMatcher::Exact(unescaped)
- }
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
+ pub fn with_permission_rules(mut self, config: &RuntimePermissionRuleConfig) -> Self {
+ self.allow_rules = config
+ .allow()
.iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
+ .map(|rule| PermissionRule::parse(rule))
+ .collect();
+ self.deny_rules = config
+ .deny()
+ .iter()
+ .map(|rule| PermissionRule::parse(rule))
+ .collect();
+ self.ask_rules = config
+ .ask()
+ .iter()
+ .map(|rule| PermissionRule::parse(rule))
+ .collect();
+ self
}
-}
-
-fn unescape_rule_content(content: &str) -> String {
- content
- .replace(r"\(", "(")
- .replace(r"\)", ")")
- .replace(r"\\", r"\")
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
+ #[must_use]
+ pub fn active_mode(&self) -> PermissionMode {
+ self.active_mode
}
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
+ #[must_use]
+ pub fn required_mode_for(&self, tool_name: &str) -> PermissionMode {
+ self.tool_requirements
+ .get(tool_name)
+ .copied()
+ .unwrap_or(PermissionMode::DangerFullAccess)
}
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
+ #[must_use]
+ pub fn authorize(
+ &self,
+ tool_name: &str,
+ input: &str,
+ prompter: Option<&mut dyn PermissionPrompter>,
+ ) -> PermissionOutcome {
+ self.authorize_with_context(tool_name, input, &PermissionContext::default(), prompter)
}
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
+ #[must_use]
+ #[allow(clippy::too_many_lines)]
+ pub fn authorize_with_context(
+ &self,
+ tool_name: &str,
+ input: &str,
+ context: &PermissionContext,
+ prompter: Option<&mut dyn PermissionPrompter>,
+ ) -> PermissionOutcome {
+ if let Some(rule) = Self::find_matching_rule(&self.deny_rules, tool_name, input) {
+ return PermissionOutcome::Deny {
+ reason: format!(
+ "Permission to use {tool_name} has been denied by rule '{}'",
+ rule.raw
),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
+ };
+ }
-}
+ let current_mode = self.active_mode();
+ let required_mode = self.required_mode_for(tool_name);
+ let ask_rule = Self::find_matching_rule(&self.ask_rules, tool_name, input);
+ let allow_rule = Self::find_matching_rule(&self.allow_rules, tool_name, input);
-fn find_first_unescaped(value: &str, needle: char) -> Option<usize> {
- let mut escaped = false;
- for (idx, ch) in value.char_indices() {
- if ch == '\\' {
- escaped = !escaped;
- continue;
- }
- if ch == needle && !escaped {
- return Some(idx);
+ match context.override_decision() {
+ Some(PermissionOverride::Deny) => {
+ return PermissionOutcome::Deny {
+ reason: context.override_reason().map_or_else(
+ || format!("tool '{tool_name}' denied by hook"),
+ ToOwned::to_owned,
+ ),
+ };
+ }
+ Some(PermissionOverride::Ask) => {
+ let reason = context.override_reason().map_or_else(
+ || format!("tool '{tool_name}' requires approval due to hook guidance"),
+ ToOwned::to_owned,
+ );
+ return Self::prompt_or_deny(
+ tool_name,
+ input,
+ current_mode,
+ required_mode,
+ Some(reason),
+ prompter,
+ );
+ }
+ Some(PermissionOverride::Allow) => {
+ if let Some(rule) = ask_rule {
+ let reason = format!(
+ "tool '{tool_name}' requires approval due to ask rule '{}'",
+ rule.raw
+ );
+ return Self::prompt_or_deny(
+ tool_name,
+ input,
+ current_mode,
+ required_mode,
+ Some(reason),
+ prompter,
+ );
+ }
+ if allow_rule.is_some()
+ || current_mode == PermissionMode::Allow
+ || current_mode >= required_mode
+ {
+ return PermissionOutcome::Allow;
+ }
+ }
+ None => {}
}
- escaped = false;
- }
- None
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
+ if let Some(rule) = ask_rule {
+ let reason = format!(
+ "tool '{tool_name}' requires approval due to ask rule '{}'",
+ rule.raw
+ );
+ return Self::prompt_or_deny(
+ tool_name,
+ input,
+ current_mode,
+ required_mode,
+ Some(reason),
+ prompter,
+ );
+ }
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
+ if allow_rule.is_some()
+ || current_mode == PermissionMode::Allow
+ || current_mode >= required_mode
+ {
+ return PermissionOutcome::Allow;
+ }
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
+ if current_mode == PermissionMode::Prompt
+ || (current_mode == PermissionMode::WorkspaceWrite
+ && required_mode == PermissionMode::DangerFullAccess)
+ {
+ let reason = Some(format!(
+ "tool '{tool_name}' requires approval to escalate from {} to {}",
+ current_mode.as_str(),
+ required_mode.as_str()
+ ));
+ return Self::prompt_or_deny(
+ tool_name,
+ input,
+ current_mode,
+ required_mode,
+ reason,
+ prompter,
+ );
+ }
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
+ PermissionOutcome::Deny {
+ reason: format!(
+ "tool '{tool_name}' requires {} permission; current mode is {}",
+ required_mode.as_str(),
+ current_mode.as_str()
+ ),
+ }
}
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
+ fn prompt_or_deny(
+ tool_name: &str,
+ input: &str,
+ current_mode: PermissionMode,
+ required_mode: PermissionMode,
+ reason: Option<String>,
+ mut prompter: Option<&mut dyn PermissionPrompter>,
+ ) -> PermissionOutcome {
+ let request = PermissionRequest {
+ tool_name: tool_name.to_string(),
+ input: input.to_string(),
+ current_mode,
+ required_mode,
+ reason: reason.clone(),
+ };
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
+ match prompter.as_mut() {
+ Some(prompter) => match prompter.decide(&request) {
+ PermissionPromptDecision::Allow => PermissionOutcome::Allow,
+ PermissionPromptDecision::Deny { reason } => PermissionOutcome::Deny { reason },
+ },
+ None => PermissionOutcome::Deny {
+ reason: reason.unwrap_or_else(|| {
+ format!(
+ "tool '{tool_name}' requires approval to run while mode is {}",
+ current_mode.as_str()
+ )
+ }),
+ },
+ }
}
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
+ fn find_matching_rule<'a>(
+ rules: &'a [PermissionRule],
+ tool_name: &str,
+ input: &str,
+ ) -> Option<&'a PermissionRule> {
+ rules.iter().find(|rule| rule.matches(tool_name, input))
+ }
+}
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
+#[derive(Debug, Clone, PartialEq, Eq)]
+struct PermissionRule {
+ raw: String,
+ tool_name: String,
+ matcher: PermissionRuleMatcher,
+}
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
+#[derive(Debug, Clone, PartialEq, Eq)]
+enum PermissionRuleMatcher {
+ Any,
+ Exact(String),
+ Prefix(String),
+}
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
+impl PermissionRule {
+ fn parse(raw: &str) -> Self {
+ let trimmed = raw.trim();
+ let open = find_first_unescaped(trimmed, '(');
+ let close = find_last_unescaped(trimmed, ')');
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
+ if let (Some(open), Some(close)) = (open, close) {
+ if close == trimmed.len() - 1 && open < close {
+ let tool_name = trimmed[..open].trim();
+ let content = &trimmed[open + 1..close];
+ if !tool_name.is_empty() {
+ let matcher = parse_rule_matcher(content);
+ return Self {
+ raw: trimmed.to_string(),
+ tool_name: tool_name.to_string(),
+ matcher,
+ };
+ }
+ }
+ }
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
+ Self {
+ raw: trimmed.to_string(),
+ tool_name: trimmed.to_string(),
+ matcher: PermissionRuleMatcher::Any,
+ }
+ }
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
+ fn matches(&self, tool_name: &str, input: &str) -> bool {
+ if self.tool_name != tool_name {
+ return false;
+ }
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
+ match &self.matcher {
+ PermissionRuleMatcher::Any => true,
+ PermissionRuleMatcher::Exact(expected) => {
+ extract_permission_subject(input).is_some_and(|candidate| candidate == *expected)
+ }
+ PermissionRuleMatcher::Prefix(prefix) => extract_permission_subject(input)
+ .is_some_and(|candidate| candidate.starts_with(prefix)),
+ }
+ }
+}
+
+fn parse_rule_matcher(content: &str) -> PermissionRuleMatcher {
+ let unescaped = unescape_rule_content(content.trim());
+ if unescaped.is_empty() || unescaped == "*" {
+ PermissionRuleMatcher::Any
+ } else if let Some(prefix) = unescaped.strip_suffix(":*") {
+ PermissionRuleMatcher::Prefix(prefix.to_string())
+ } else {
+ PermissionRuleMatcher::Exact(unescaped)
}
+}
+
+fn unescape_rule_content(content: &str) -> String {
+ content
+ .replace(r"\(", "(")
+ .replace(r"\)", ")")
+ .replace(r"\\", r"\")
+}
+fn find_first_unescaped(value: &str, needle: char) -> Option<usize> {
+ let mut escaped = false;
+ for (idx, ch) in value.char_indices() {
+ if ch == '\\' {
+ escaped = !escaped;
+ continue;
+ }
+ if ch == needle && !escaped {
+ return Some(idx);
+ }
+ escaped = false;
+ }
+ None
}
fn find_last_unescaped(value: &str, needle: char) -> Option<usize> {
@@ -5094,150 +442,6 @@ fn find_last_unescaped(value: &str, needle: char) -> Option<usize> {
}
}
None
-
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
-
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
-
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
- }
-
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
-
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
-
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
- }
-
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
-
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
-
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
-
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
- }
-
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
-
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
-
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
-
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
- }
-
}
fn extract_permission_subject(input: &str) -> Option<String> {
@@ -5262,150 +466,303 @@ fn extract_permission_subject(input: &str) -> Option<String> {
}
(!input.trim().is_empty()).then(|| input.to_string())
+}
- #[test]
- fn approval_token_blocks_until_owner_grants_policy_exception() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- ledger.insert(ApprovalTokenGrant::pending(
- "tok-pending",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
+/// Machine-readable policy exception scope that an approval token may override.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ApprovalScope {
+ pub policy: String,
+ pub action: String,
+ pub repository: Option<String>,
+ pub branch: Option<String>,
+}
+
+impl ApprovalScope {
+ #[must_use]
+ pub fn new(policy: impl Into<String>, action: impl Into<String>) -> Self {
+ Self {
+ policy: policy.into(),
+ action: action.into(),
+ repository: None,
+ branch: None,
+ }
+ }
+
+ #[must_use]
+ pub fn with_repository(mut self, repository: impl Into<String>) -> Self {
+ self.repository = Some(repository.into());
+ self
+ }
+
+ #[must_use]
+ pub fn with_branch(mut self, branch: impl Into<String>) -> Self {
+ self.branch = Some(branch.into());
+ self
+ }
+}
+
+/// Actor/session hop recorded when an approval is delegated or consumed.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ApprovalDelegationHop {
+ pub actor: String,
+ pub session_id: Option<String>,
+ pub reason: String,
+}
+
+impl ApprovalDelegationHop {
+ #[must_use]
+ pub fn new(actor: impl Into<String>, reason: impl Into<String>) -> Self {
+ Self {
+ actor: actor.into(),
+ session_id: None,
+ reason: reason.into(),
+ }
+ }
+
+ #[must_use]
+ pub fn with_session_id(mut self, session_id: impl Into<String>) -> Self {
+ self.session_id = Some(session_id.into());
+ self
+ }
+}
+
+/// Current lifecycle state for a policy-exception approval token.
+#[derive(Debug, Clone, Copy, PartialEq, Eq)]
+pub enum ApprovalTokenStatus {
+ Pending,
+ Granted,
+ Consumed,
+ Expired,
+ Revoked,
+}
- assert!(matches!(
- ledger.verify("tok-missing", &scope, "release-bot", 10),
- Err(ApprovalTokenError::NoApproval)
- ));
- assert!(matches!(
- ledger.verify("tok-pending", &scope, "release-bot", 10),
- Err(ApprovalTokenError::ApprovalPending)
- ));
+/// Approval token record used to prove owner approval, delegated execution, and replay safety.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ApprovalTokenGrant {
+ pub token: String,
+ pub scope: ApprovalScope,
+ pub approving_actor: String,
+ pub executing_actor: String,
+ pub status: ApprovalTokenStatus,
+ pub expires_at: Option<u64>,
+ pub uses: u32,
+ pub delegation_chain: Vec<ApprovalDelegationHop>,
+}
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-granted",
- scope.clone(),
- "repo-owner",
- "release-bot",
- ));
- let audit = ledger
- .verify("tok-granted", &scope, "release-bot", 10)
- .expect("owner approval should verify");
+impl ApprovalTokenGrant {
+ #[must_use]
+ pub fn pending(
+ token: impl Into<String>,
+ scope: ApprovalScope,
+ approving_actor: impl Into<String>,
+ executing_actor: impl Into<String>,
+ ) -> Self {
+ Self::new(
+ token,
+ scope,
+ approving_actor,
+ executing_actor,
+ ApprovalTokenStatus::Pending,
+ )
+ }
- assert_eq!(audit.status, ApprovalTokenStatus::Granted);
- assert_eq!(audit.approving_actor, "repo-owner");
- assert_eq!(audit.executing_actor, "release-bot");
- assert!(audit.delegated_execution);
+ #[must_use]
+ pub fn granted(
+ token: impl Into<String>,
+ scope: ApprovalScope,
+ approving_actor: impl Into<String>,
+ executing_actor: impl Into<String>,
+ ) -> Self {
+ Self::new(
+ token,
+ scope,
+ approving_actor,
+ executing_actor,
+ ApprovalTokenStatus::Granted,
+ )
}
- #[test]
- fn approval_token_is_one_time_use_and_rejects_replay() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("release_requires_owner", "release publish")
- .with_repository("sisyphus/claw-code");
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-once",
- scope.clone(),
- "owner",
- "release-bot",
- ));
+ fn new(
+ token: impl Into<String>,
+ scope: ApprovalScope,
+ approving_actor: impl Into<String>,
+ executing_actor: impl Into<String>,
+ status: ApprovalTokenStatus,
+ ) -> Self {
+ let approving_actor = approving_actor.into();
+ Self {
+ token: token.into(),
+ scope,
+ executing_actor: executing_actor.into(),
+ delegation_chain: vec![ApprovalDelegationHop::new(
+ approving_actor.clone(),
+ "owner approval",
+ )],
+ approving_actor,
+ status,
+ expires_at: None,
+ uses: 0,
+ }
+ }
- let first = ledger
- .consume("tok-once", &scope, "release-bot", 10)
- .expect("first use should consume token");
- assert_eq!(first.status, ApprovalTokenStatus::Consumed);
- assert_eq!(first.uses, 1);
+ #[must_use]
+ pub fn expires_at(mut self, expires_at: u64) -> Self {
+ self.expires_at = Some(expires_at);
+ self
+ }
- assert!(matches!(
- ledger.consume("tok-once", &scope, "release-bot", 11),
- Err(ApprovalTokenError::ApprovalAlreadyConsumed)
- ));
- assert_eq!(
- ledger.get("tok-once").map(|grant| grant.status),
- Some(ApprovalTokenStatus::Consumed)
- );
+ #[must_use]
+ pub fn with_delegation_hop(mut self, hop: ApprovalDelegationHop) -> Self {
+ self.delegation_chain.push(hop);
+ self
}
+}
- #[test]
- fn approval_token_rejects_scope_expansion_expiry_and_revocation() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("main");
- let dev_scope = ApprovalScope::new("main_push_forbidden", "git push")
- .with_repository("sisyphus/claw-code")
- .with_branch("dev");
+/// Immutable audit returned when a token is verified or consumed.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub struct ApprovalTokenAudit {
+ pub token: String,
+ pub status: ApprovalTokenStatus,
+ pub scope: ApprovalScope,
+ pub approving_actor: String,
+ pub executing_actor: String,
+ pub delegated_execution: bool,
+ pub uses: u32,
+ pub delegation_chain: Vec<ApprovalDelegationHop>,
+}
- ledger.insert(
- ApprovalTokenGrant::granted("tok-expiring", scope.clone(), "owner", "bot")
- .expires_at(20),
- );
+/// Verification errors for policy approval tokens.
+#[derive(Debug, Clone, PartialEq, Eq)]
+pub enum ApprovalTokenError {
+ NoApproval,
+ ApprovalPending,
+ ApprovalAlreadyConsumed,
+ ApprovalExpired,
+ ApprovalRevoked,
+ ScopeMismatch {
+ expected: ApprovalScope,
+ actual: ApprovalScope,
+ },
+ UnauthorizedDelegate {
+ expected: String,
+ actual: String,
+ },
+}
- assert!(matches!(
- ledger.verify("tok-expiring", &dev_scope, "bot", 10),
- Err(ApprovalTokenError::ScopeMismatch { .. })
- ));
- assert!(matches!(
- ledger.verify("tok-expiring", &scope, "bot", 21),
- Err(ApprovalTokenError::ApprovalExpired)
- ));
+/// In-memory approval token ledger for deterministic policy handoff validation.
+#[derive(Debug, Clone, Default, PartialEq, Eq)]
+pub struct ApprovalTokenLedger {
+ grants: BTreeMap<String, ApprovalTokenGrant>,
+}
- ledger.insert(ApprovalTokenGrant::granted(
- "tok-revoked",
- scope.clone(),
- "owner",
- "bot",
- ));
- let revoked = ledger
- .revoke("tok-revoked")
- .expect("revocation should be audited");
- assert_eq!(revoked.status, ApprovalTokenStatus::Revoked);
- assert!(matches!(
- ledger.verify("tok-revoked", &scope, "bot", 10),
- Err(ApprovalTokenError::ApprovalRevoked)
- ));
+impl ApprovalTokenLedger {
+ #[must_use]
+ pub fn new() -> Self {
+ Self::default()
}
- #[test]
- fn approval_token_preserves_delegation_traceability() {
- let mut ledger = ApprovalTokenLedger::new();
- let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
- ledger.insert(
- ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
- .with_delegation_hop(
- ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
- .with_session_id("session-lead"),
- ),
- );
+ pub fn insert(&mut self, grant: ApprovalTokenGrant) {
+ self.grants.insert(grant.token.clone(), grant);
+ }
- assert!(matches!(
- ledger.verify("tok-delegated", &scope, "unexpected-bot", 10),
- Err(ApprovalTokenError::UnauthorizedDelegate { expected, actual })
- if expected == "deploy-bot" && actual == "unexpected-bot"
- ));
+ #[must_use]
+ pub fn get(&self, token: &str) -> Option<&ApprovalTokenGrant> {
+ self.grants.get(token)
+ }
- let audit = ledger
- .consume("tok-delegated", &scope, "deploy-bot", 10)
- .expect("approved delegate should consume token");
- let actors = audit
- .delegation_chain
- .iter()
- .map(|hop| hop.actor.as_str())
- .collect::<Vec<_>>();
+ pub fn revoke(&mut self, token: &str) -> Result<ApprovalTokenAudit, ApprovalTokenError> {
+ let grant = self
+ .grants
+ .get_mut(token)
+ .ok_or(ApprovalTokenError::NoApproval)?;
+ grant.status = ApprovalTokenStatus::Revoked;
+ Ok(Self::audit(grant))
+ }
- assert!(audit.delegated_execution);
- assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
+ pub fn verify(
+ &self,
+ token: &str,
+ scope: &ApprovalScope,
+ executing_actor: &str,
+ now: u64,
+ ) -> Result<ApprovalTokenAudit, ApprovalTokenError> {
+ let grant = self
+ .grants
+ .get(token)
+ .ok_or(ApprovalTokenError::NoApproval)?;
+ Self::validate_grant(grant, scope, executing_actor, now)?;
+ Ok(Self::audit(grant))
+ }
+
+ pub fn consume(
+ &mut self,
+ token: &str,
+ scope: &ApprovalScope,
+ executing_actor: &str,
+ now: u64,
+ ) -> Result<ApprovalTokenAudit, ApprovalTokenError> {
+ let grant = self
+ .grants
+ .get_mut(token)
+ .ok_or(ApprovalTokenError::NoApproval)?;
+ Self::validate_grant(grant, scope, executing_actor, now)?;
+ grant.status = ApprovalTokenStatus::Consumed;
+ grant.uses = grant.uses.saturating_add(1);
+ Ok(Self::audit(grant))
+ }
+
+ fn validate_grant(
+ grant: &ApprovalTokenGrant,
+ scope: &ApprovalScope,
+ executing_actor: &str,
+ now: u64,
+ ) -> Result<(), ApprovalTokenError> {
+ if grant.scope != *scope {
+ return Err(ApprovalTokenError::ScopeMismatch {
+ expected: grant.scope.clone(),
+ actual: scope.clone(),
+ });
+ }
+ if grant.executing_actor != executing_actor {
+ return Err(ApprovalTokenError::UnauthorizedDelegate {
+ expected: grant.executing_actor.clone(),
+ actual: executing_actor.to_string(),
+ });
+ }
+ if grant.expires_at.is_some_and(|expires_at| now > expires_at) {
+ return Err(ApprovalTokenError::ApprovalExpired);
+ }
+ match grant.status {
+ ApprovalTokenStatus::Granted => Ok(()),
+ ApprovalTokenStatus::Pending => Err(ApprovalTokenError::ApprovalPending),
+ ApprovalTokenStatus::Consumed => Err(ApprovalTokenError::ApprovalAlreadyConsumed),
+ ApprovalTokenStatus::Expired => Err(ApprovalTokenError::ApprovalExpired),
+ ApprovalTokenStatus::Revoked => Err(ApprovalTokenError::ApprovalRevoked),
+ }
}
+ fn audit(grant: &ApprovalTokenGrant) -> ApprovalTokenAudit {
+ let mut delegation_chain = grant.delegation_chain.clone();
+ if delegation_chain
+ .last()
+ .is_none_or(|hop| hop.actor != grant.executing_actor)
+ {
+ delegation_chain.push(ApprovalDelegationHop::new(
+ grant.executing_actor.clone(),
+ "approved execution",
+ ));
+ }
+ ApprovalTokenAudit {
+ token: grant.token.clone(),
+ status: grant.status,
+ scope: grant.scope.clone(),
+ approving_actor: grant.approving_actor.clone(),
+ executing_actor: grant.executing_actor.clone(),
+ delegated_execution: grant.approving_actor != grant.executing_actor,
+ uses: grant.uses,
+ delegation_chain,
+ }
+ }
}
#[cfg(test)]
@@ -5735,10 +1092,6 @@ mod tests {
let scope = ApprovalScope::new("deploy_requires_owner", "deploy prod");
ledger.insert(
ApprovalTokenGrant::granted("tok-delegated", scope.clone(), "owner", "deploy-bot")
- .with_delegation_hop(
- ApprovalDelegationHop::new("owner", "owner approval")
- .with_session_id("session-owner"),
- )
.with_delegation_hop(
ApprovalDelegationHop::new("lead-agent", "handoff to deploy bot")
.with_session_id("session-lead"),
@@ -5762,8 +1115,9 @@ mod tests {
assert!(audit.delegated_execution);
assert_eq!(actors, vec!["owner", "lead-agent", "deploy-bot"]);
- assert_eq!(audit.delegation_chain[0].session_id.as_deref(), Some("session-owner"));
- assert_eq!(audit.delegation_chain[1].session_id.as_deref(), Some("session-lead"));
+ assert_eq!(
+ audit.delegation_chain[1].session_id.as_deref(),
+ Some("session-lead")
+ );
}
-
}
diff --git a/rust/crates/runtime/tests/g004_conformance.rs b/rust/crates/runtime/tests/g004_conformance.rs
index c7343c70..4a2b65e7 100644
--- a/rust/crates/runtime/tests/g004_conformance.rs
+++ b/rust/crates/runtime/tests/g004_conformance.rs
@@ -1,6 +1,4 @@
-use runtime::g004_conformance::{
- is_g004_contract_bundle_valid, validate_g004_contract_bundle,
-};
+use runtime::g004_conformance::{is_g004_contract_bundle_valid, validate_g004_contract_bundle};
use serde_json::{json, Value};
fn valid_bundle() -> Value {
@@ -14,7 +12,10 @@ fn valid_g004_contract_bundle_fixture_passes_conformance() {
let errors = validate_g004_contract_bundle(&fixture);
- assert!(errors.is_empty(), "unexpected conformance errors: {errors:?}");
+ assert!(
+ errors.is_empty(),
+ "unexpected conformance errors: {errors:?}"
+ );
assert!(is_g004_contract_bundle_valid(&fixture));
}