Skip to content

armgit / macro

Public Imported from GitHub
0

Macro is a unified workspace for teams: email, chat, docs, tasks, agents, calls, and CRM — @-linked together with shared AI memory.

feat(auth): record whether a user credential is a Macro API JWT (#8535)

Wolf Mermelstein4a6d5edae94a
diff --git a/crates/agent_harness/src/inbound/repositories/test.rs b/crates/agent_harness/src/inbound/repositories/test.rs
index 87cfe05769..118bf70b6a 100644
--- a/crates/agent_harness/src/inbound/repositories/test.rs
+++ b/crates/agent_harness/src/inbound/repositories/test.rs
@@ -31,6 +31,15 @@ impl MacroAuthorizationService for TestAuthorizationService {
})
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
_provided_key: &str,
diff --git a/crates/agent_harness/src/inbound/runtime_gateway/test.rs b/crates/agent_harness/src/inbound/runtime_gateway/test.rs
index 40acaab52e..3ae2fb1c0b 100644
--- a/crates/agent_harness/src/inbound/runtime_gateway/test.rs
+++ b/crates/agent_harness/src/inbound/runtime_gateway/test.rs
@@ -23,13 +23,19 @@ const HARNESS_TOKEN: &str = "mhns_self_test";
struct FakeJwtValidator;
impl JwtValidator for FakeJwtValidator {
- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
- Ok(ValidatedIdentity {
- agent_id: None,
- user_id: jwt.to_string(),
- fusion_user_id: "fusion-user".to_string(),
- organization_id: None,
- permissions: None,
+ fn validate_credential(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: jwt.to_string(),
+ fusion_user_id: "fusion-user".to_string(),
+ organization_id: None,
+ permissions: None,
+ },
})
}
}
@@ -57,6 +63,7 @@ impl HarnessAuthorizer for SelfHarnessAuthorizer {
user_id: user_id.clone(),
},
acting_user: MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::Harness,
agent_id: None,
macro_user_id,
user_context: model_user::UserContext {
diff --git a/crates/agent_session/src/inbound/axum_router/test.rs b/crates/agent_session/src/inbound/axum_router/test.rs
index 7a9412a577..bded5efcbb 100644
--- a/crates/agent_session/src/inbound/axum_router/test.rs
+++ b/crates/agent_session/src/inbound/axum_router/test.rs
@@ -98,13 +98,19 @@ const TEAM_ID: Uuid = Uuid::from_u128(0x7EA3);
struct FakeJwtValidator;
impl JwtValidator for FakeJwtValidator {
- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
- Ok(ValidatedIdentity {
- agent_id: None,
- user_id: jwt.to_string(),
- fusion_user_id: "fusion-user".to_string(),
- organization_id: None,
- permissions: None,
+ fn validate_credential(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: jwt.to_string(),
+ fusion_user_id: "fusion-user".to_string(),
+ organization_id: None,
+ permissions: None,
+ },
})
}
}
@@ -128,6 +134,7 @@ impl BotAuthorizer for SelfBotAuthorizer {
let macro_user_id = MacroUserIdStr::try_from(user_id.clone())
.map_err(|_| Report::new(MacroAuthorizationError::ActingUserNotAuthorized))?;
Some(MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::Bot,
agent_id: None,
macro_user_id,
user_context: model_user::UserContext {
@@ -175,6 +182,7 @@ impl HarnessAuthorizer for SelfHarnessAuthorizer {
user_id: user_id.clone(),
},
acting_user: MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::Harness,
agent_id: None,
macro_user_id,
user_context: model_user::UserContext {
diff --git a/crates/agent_session/src/inbound/coding_agents/test.rs b/crates/agent_session/src/inbound/coding_agents/test.rs
index 98a7d2920f..c84464e978 100644
--- a/crates/agent_session/src/inbound/coding_agents/test.rs
+++ b/crates/agent_session/src/inbound/coding_agents/test.rs
@@ -17,13 +17,19 @@ const KEY: &str = "coding-test-internal-key";
struct UserCredentials;
impl JwtValidator for UserCredentials {
- fn validate(&self, _: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
- Ok(ValidatedIdentity {
- agent_id: None,
- user_id: USER.into(),
- fusion_user_id: "fusion-owner".into(),
- organization_id: None,
- permissions: None,
+ fn validate_credential(
+ &self,
+ _: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: USER.into(),
+ fusion_user_id: "fusion-owner".into(),
+ organization_id: None,
+ permissions: None,
+ },
})
}
}
diff --git a/crates/agent_session/src/inbound/routine_sessions/test.rs b/crates/agent_session/src/inbound/routine_sessions/test.rs
index 39e27a83e2..c439d51f0d 100644
--- a/crates/agent_session/src/inbound/routine_sessions/test.rs
+++ b/crates/agent_session/src/inbound/routine_sessions/test.rs
@@ -25,13 +25,19 @@ const OPERATIONS: [&str; 5] = ["validate", "prepare", "prompt", "status", "cance
struct Credentials;
impl JwtValidator for Credentials {
- fn validate(&self, _: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
- Ok(ValidatedIdentity {
- agent_id: None,
- user_id: OWNER.into(),
- fusion_user_id: "fusion-owner".into(),
- organization_id: None,
- permissions: None,
+ fn validate_credential(
+ &self,
+ _: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: OWNER.into(),
+ fusion_user_id: "fusion-owner".into(),
+ organization_id: None,
+ permissions: None,
+ },
})
}
}
@@ -66,6 +72,7 @@ impl HarnessAuthorizer for Credentials {
user_id: OWNER.into(),
},
acting_user: MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::Harness,
agent_id: None,
macro_user_id: MacroUserIdStr::try_from(OWNER).unwrap(),
user_context: model_user::UserContext {
diff --git a/crates/ai_projections/src/inbound/axum_router/test.rs b/crates/ai_projections/src/inbound/axum_router/test.rs
index af07a6129c..95f077a5c1 100644
--- a/crates/ai_projections/src/inbound/axum_router/test.rs
+++ b/crates/ai_projections/src/inbound/axum_router/test.rs
@@ -39,6 +39,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
Ok(test_user_context())
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
_provided_key: &str,
diff --git a/crates/ai_tools/src/test/booking_links.rs b/crates/ai_tools/src/test/booking_links.rs
index ddd43d1e3c..f7b0c44515 100644
--- a/crates/ai_tools/src/test/booking_links.rs
+++ b/crates/ai_tools/src/test/booking_links.rs
@@ -36,6 +36,15 @@ impl MacroAuthorizationService for NoAuth {
async fn authorize(&self, _: &str) -> Result<UserContext, Report<MacroAuthorizationError>> {
Err(Report::new(MacroAuthorizationError::InvalidCredentials))
}
+
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
async fn authorize_internal(
&self,
_: &str,
diff --git a/crates/bots/src/inbound/axum_router/tests.rs b/crates/bots/src/inbound/axum_router/tests.rs
index c17af61382..0ebfe618aa 100644
--- a/crates/bots/src/inbound/axum_router/tests.rs
+++ b/crates/bots/src/inbound/axum_router/tests.rs
@@ -419,17 +419,23 @@ impl EntityAccessService for TestAccessService {
struct FakeJwtValidator;
impl JwtValidator for FakeJwtValidator {
- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
+ fn validate_credential(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
if jwt == INVALID_BEARER_TOKEN {
return Err(Report::new(MacroAuthorizationError::InvalidCredentials));
}
- Ok(ValidatedIdentity {
- agent_id: None,
- user_id: jwt.to_string(),
- fusion_user_id: "fusion-user".to_string(),
- organization_id: None,
- permissions: None,
+ Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: jwt.to_string(),
+ fusion_user_id: "fusion-user".to_string(),
+ organization_id: None,
+ permissions: None,
+ },
})
}
}
diff --git a/crates/bots/src/inbound/channel_webhook_router/tests.rs b/crates/bots/src/inbound/channel_webhook_router/tests.rs
index 33c89321be..f51140cbe2 100644
--- a/crates/bots/src/inbound/channel_webhook_router/tests.rs
+++ b/crates/bots/src/inbound/channel_webhook_router/tests.rs
@@ -733,13 +733,19 @@ impl BotAuthorizer for TestBotAuthorizer {
struct FakeJwtValidator;
impl JwtValidator for FakeJwtValidator {
- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
- Ok(ValidatedIdentity {
- agent_id: None,
- user_id: jwt.to_string(),
- fusion_user_id: "fusion-user".to_string(),
- organization_id: None,
- permissions: None,
+ fn validate_credential(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: jwt.to_string(),
+ fusion_user_id: "fusion-user".to_string(),
+ organization_id: None,
+ permissions: None,
+ },
})
}
}
@@ -823,6 +829,7 @@ fn bot_authentication_with_acting_user(bot_id: BotId) -> BotAuthentication {
bot_scope: BotScope::User,
team_id: None,
acting_user: Some(MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::Bot,
agent_id: None,
macro_user_id: MacroUserIdStr::parse_from_str("macro|[email protected]").unwrap(),
user_context: Default::default(),
diff --git a/crates/calendar_scheduling/src/domain/service/test/http_administration.rs b/crates/calendar_scheduling/src/domain/service/test/http_administration.rs
index 070dfa22e6..7d6b058a1b 100644
--- a/crates/calendar_scheduling/src/domain/service/test/http_administration.rs
+++ b/crates/calendar_scheduling/src/domain/service/test/http_administration.rs
@@ -20,6 +20,15 @@ impl MacroAuthorizationService for Identity {
async fn authorize(&self, _: &str) -> Result<UserContext, Report<MacroAuthorizationError>> {
Err(Report::new(MacroAuthorizationError::InvalidCredentials))
}
+
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
async fn authorize_internal(
&self,
key: &str,
diff --git a/crates/calendar_scheduling/src/inbound/router/test.rs b/crates/calendar_scheduling/src/inbound/router/test.rs
index cb74a298e5..c282d8f84f 100644
--- a/crates/calendar_scheduling/src/inbound/router/test.rs
+++ b/crates/calendar_scheduling/src/inbound/router/test.rs
@@ -25,6 +25,15 @@ impl MacroAuthorizationService for Identity {
..Default::default()
})
}
+
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
async fn authorize_internal(
&self,
_: &str,
diff --git a/crates/channels/src/inbound/axum_router/test.rs b/crates/channels/src/inbound/axum_router/test.rs
index 7748b27aa9..1e88456385 100644
--- a/crates/channels/src/inbound/axum_router/test.rs
+++ b/crates/channels/src/inbound/axum_router/test.rs
@@ -706,7 +706,10 @@ impl FakeJwtValidator {
}
impl JwtValidator for FakeJwtValidator {
- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
+ fn validate_credential(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
self.validation_count.fetch_add(1, Ordering::SeqCst);
let organization_id = match jwt {
@@ -716,12 +719,15 @@ impl JwtValidator for FakeJwtValidator {
_ => return Err(Report::new(MacroAuthorizationError::InvalidCredentials)),
};
- Ok(ValidatedIdentity {
- agent_id: None,
- user_id: TEST_USER_ID.to_string(),
- fusion_user_id: "test-fusion-user".to_string(),
- organization_id,
- permissions: None,
+ Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: TEST_USER_ID.to_string(),
+ fusion_user_id: "test-fusion-user".to_string(),
+ organization_id,
+ permissions: None,
+ },
})
}
}
diff --git a/crates/channels/src/inbound/list_router/test.rs b/crates/channels/src/inbound/list_router/test.rs
index c51199ffed..a017b47a19 100644
--- a/crates/channels/src/inbound/list_router/test.rs
+++ b/crates/channels/src/inbound/list_router/test.rs
@@ -111,14 +111,20 @@ impl ChannelListService for FakeChannelListService {
struct FakeJwtValidator;
impl JwtValidator for FakeJwtValidator {
- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
+ fn validate_credential(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
match jwt {
- VALID_BEARER_TOKEN => Ok(ValidatedIdentity {
- agent_id: None,
- user_id: BEARER_USER_ID.to_string(),
- fusion_user_id: "fusion-user-id".to_string(),
- organization_id: None,
- permissions: None,
+ VALID_BEARER_TOKEN => Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: BEARER_USER_ID.to_string(),
+ fusion_user_id: "fusion-user-id".to_string(),
+ organization_id: None,
+ permissions: None,
+ },
}),
EXPIRED_BEARER_TOKEN => Err(Report::new(MacroAuthorizationError::CredentialsExpired)),
_ => Err(Report::new(MacroAuthorizationError::InvalidCredentials)),
diff --git a/crates/chat/src/inbound/test.rs b/crates/chat/src/inbound/test.rs
index 9f6e8b75c7..f370977a09 100644
--- a/crates/chat/src/inbound/test.rs
+++ b/crates/chat/src/inbound/test.rs
@@ -517,6 +517,18 @@ impl MacroAuthorizationService for FakeAuthorizationService {
})
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> std::result::Result<
+ macro_authorization::ValidatedCredential,
+ Report<MacroAuthorizationError>,
+ > {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
_provided_key: &str,
@@ -543,6 +555,7 @@ impl MacroAuthorizationService for FakeAuthorizationService {
acting_user: acting_user
.and_then(|claims| claims.user_id)
.map(|user_id| MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::Bot,
agent_id: None,
macro_user_id: MacroUserIdStr::try_from(user_id.clone())
.expect("test user id should be valid"),
diff --git a/crates/complete_graph/src/schema/test.rs b/crates/complete_graph/src/schema/test.rs
index 13b618e0a7..73614dcbf2 100644
--- a/crates/complete_graph/src/schema/test.rs
+++ b/crates/complete_graph/src/schema/test.rs
@@ -1265,6 +1265,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
}
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
provided_key: &str,
diff --git a/crates/contacts/src/inbound/http/test.rs b/crates/contacts/src/inbound/http/test.rs
index a1b5b9ae6f..6fd0f42583 100644
--- a/crates/contacts/src/inbound/http/test.rs
+++ b/crates/contacts/src/inbound/http/test.rs
@@ -63,7 +63,10 @@ impl FakeJwtValidator {
}
impl JwtValidator for FakeJwtValidator {
- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
+ fn validate_credential(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
self.validation_count.fetch_add(1, Ordering::SeqCst);
let user_id = match jwt {
@@ -73,12 +76,15 @@ impl JwtValidator for FakeJwtValidator {
_ => return Err(Report::new(MacroAuthorizationError::InvalidCredentials)),
};
- Ok(ValidatedIdentity {
- agent_id: None,
- user_id: user_id.to_string(),
- fusion_user_id: "fusion-user-id".to_string(),
- permissions: None,
- organization_id: None,
+ Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: user_id.to_string(),
+ fusion_user_id: "fusion-user-id".to_string(),
+ permissions: None,
+ organization_id: None,
+ },
})
}
}
diff --git a/crates/crm/src/inbound/axum_extractors/test.rs b/crates/crm/src/inbound/axum_extractors/test.rs
index 2ad34fd123..d60e24dd89 100644
--- a/crates/crm/src/inbound/axum_extractors/test.rs
+++ b/crates/crm/src/inbound/axum_extractors/test.rs
@@ -56,14 +56,20 @@ const TEAM_ID: &str = "55555555-5555-4555-8555-555555555555";
struct FakeJwtValidator;
impl JwtValidator for FakeJwtValidator {
- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
+ fn validate_credential(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
match jwt {
- VALID_TOKEN => Ok(ValidatedIdentity {
- agent_id: None,
- user_id: USER_ID.to_string(),
- fusion_user_id: "test-fusion-user".to_string(),
- organization_id: None,
- permissions: None,
+ VALID_TOKEN => Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: USER_ID.to_string(),
+ fusion_user_id: "test-fusion-user".to_string(),
+ organization_id: None,
+ permissions: None,
+ },
}),
"expired" => Err(Report::new(MacroAuthorizationError::CredentialsExpired)),
_ => Err(Report::new(MacroAuthorizationError::InvalidCredentials)),
diff --git a/crates/crm/tests/pipelines.rs b/crates/crm/tests/pipelines.rs
index d9cad85d57..26b96955b4 100644
--- a/crates/crm/tests/pipelines.rs
+++ b/crates/crm/tests/pipelines.rs
@@ -727,21 +727,27 @@ async fn http_creation_listing_schema_and_records_use_pipeline_access(pool: PgPo
#[derive(Clone)]
struct Token;
impl JwtValidator for Token {
- fn validate(
+ fn validate_credential(
&self,
jwt: &str,
- ) -> Result<ValidatedIdentity, rootcause::Report<MacroAuthorizationError>> {
+ ) -> Result<
+ macro_authorization::ValidatedCredential,
+ rootcause::Report<MacroAuthorizationError>,
+ > {
if jwt != "owner" && jwt != "outsider" {
return Err(rootcause::Report::new(
MacroAuthorizationError::InvalidCredentials,
));
}
- Ok(ValidatedIdentity {
- agent_id: None,
- user_id: if jwt == "owner" { OWNER } else { OUTSIDER }.into(),
- fusion_user_id: "test-fusion-user".into(),
- organization_id: None,
- permissions: None,
+ Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: if jwt == "owner" { OWNER } else { OUTSIDER }.into(),
+ fusion_user_id: "test-fusion-user".into(),
+ organization_id: None,
+ permissions: None,
+ },
})
}
}
diff --git a/crates/databases/src/inbound/axum_router/test/fakes.rs b/crates/databases/src/inbound/axum_router/test/fakes.rs
index 832ba1d51e..b1b1f8e8d3 100644
--- a/crates/databases/src/inbound/axum_router/test/fakes.rs
+++ b/crates/databases/src/inbound/axum_router/test/fakes.rs
@@ -42,14 +42,20 @@ const USER: &str = "macro|[email protected]";
struct ValidToken;
impl JwtValidator for ValidToken {
- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
+ fn validate_credential(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
match jwt {
- "valid" => Ok(ValidatedIdentity {
- agent_id: None,
- user_id: USER.to_string(),
- fusion_user_id: "fusion-ops-router".to_string(),
- organization_id: None,
- permissions: None,
+ "valid" => Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: USER.to_string(),
+ fusion_user_id: "fusion-ops-router".to_string(),
+ organization_id: None,
+ permissions: None,
+ },
}),
_ => Err(Report::new(MacroAuthorizationError::InvalidCredentials)),
}
diff --git a/crates/databases_sql/src/service/test/http.rs b/crates/databases_sql/src/service/test/http.rs
index e8522a94a4..e2f74890d6 100644
--- a/crates/databases_sql/src/service/test/http.rs
+++ b/crates/databases_sql/src/service/test/http.rs
@@ -16,10 +16,11 @@ use tower::ServiceExt;
struct Token;
impl JwtValidator for Token {
- fn validate(
+ fn validate_credential(
&self,
jwt: &str,
- ) -> Result<ValidatedIdentity, rootcause::Report<MacroAuthorizationError>> {
+ ) -> Result<macro_authorization::ValidatedCredential, rootcause::Report<MacroAuthorizationError>>
+ {
let user_id = match jwt {
"owner" => OWNER,
"viewer" => VIEWER,
@@ -29,12 +30,15 @@ impl JwtValidator for Token {
));
}
};
- Ok(ValidatedIdentity {
- agent_id: None,
- user_id: user_id.into(),
- fusion_user_id: "fusion-sql-test".into(),
- organization_id: None,
- permissions: None,
+ Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: user_id.into(),
+ fusion_user_id: "fusion-sql-test".into(),
+ organization_id: None,
+ permissions: None,
+ },
})
}
}
diff --git a/crates/dictation/src/inbound/axum_router/test.rs b/crates/dictation/src/inbound/axum_router/test.rs
index a4f2227df9..e4d869ab6e 100644
--- a/crates/dictation/src/inbound/axum_router/test.rs
+++ b/crates/dictation/src/inbound/axum_router/test.rs
@@ -118,6 +118,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
})
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
provided_key: &str,
diff --git a/crates/documents/src/inbound/axum_router/tests.rs b/crates/documents/src/inbound/axum_router/tests.rs
index 4ef1d8f700..d165421b8c 100644
--- a/crates/documents/src/inbound/axum_router/tests.rs
+++ b/crates/documents/src/inbound/axum_router/tests.rs
@@ -863,6 +863,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
Ok(user_context(JWT_USER_ID))
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
provided_key: &str,
@@ -901,6 +910,7 @@ impl MacroAuthorizationService for FakeAuthorizationService {
acting_user: acting_user
.and_then(|claims| claims.user_id)
.map(|user_id| MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::Bot,
agent_id: None,
macro_user_id: user(&user_id),
user_context: user_context(&user_id),
diff --git a/crates/entity_access/src/inbound/axum_extractors/call/test.rs b/crates/entity_access/src/inbound/axum_extractors/call/test.rs
index f985114ce1..4d5ccfcafd 100644
--- a/crates/entity_access/src/inbound/axum_extractors/call/test.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/call/test.rs
@@ -292,6 +292,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
}
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_bot(
&self,
token: &str,
diff --git a/crates/entity_access/src/inbound/axum_extractors/channel/test.rs b/crates/entity_access/src/inbound/axum_extractors/channel/test.rs
index c1d4baf287..125f61e3e1 100644
--- a/crates/entity_access/src/inbound/axum_extractors/channel/test.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/channel/test.rs
@@ -231,6 +231,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
}
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_bot(
&self,
token: &str,
diff --git a/crates/entity_access/src/inbound/axum_extractors/chat/test.rs b/crates/entity_access/src/inbound/axum_extractors/chat/test.rs
index d79a27ba52..ce2f4d7ec3 100644
--- a/crates/entity_access/src/inbound/axum_extractors/chat/test.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/chat/test.rs
@@ -56,6 +56,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
}
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_bot(
&self,
token: &str,
diff --git a/crates/entity_access/src/inbound/axum_extractors/document/test.rs b/crates/entity_access/src/inbound/axum_extractors/document/test.rs
index 5d0badce0c..129324c2d5 100644
--- a/crates/entity_access/src/inbound/axum_extractors/document/test.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/document/test.rs
@@ -65,6 +65,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
}
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_bot(
&self,
token: &str,
diff --git a/crates/entity_access/src/inbound/axum_extractors/entity_permission/test.rs b/crates/entity_access/src/inbound/axum_extractors/entity_permission/test.rs
index cc58ba8ada..225f6f4305 100644
--- a/crates/entity_access/src/inbound/axum_extractors/entity_permission/test.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/entity_permission/test.rs
@@ -257,6 +257,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
}
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_bot(
&self,
token: &str,
diff --git a/crates/entity_access/src/inbound/axum_extractors/initiative/test.rs b/crates/entity_access/src/inbound/axum_extractors/initiative/test.rs
index 3ba3ce9f28..14afd60f69 100644
--- a/crates/entity_access/src/inbound/axum_extractors/initiative/test.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/initiative/test.rs
@@ -85,6 +85,7 @@ async fn response_body(response: axum::response::Response) -> String {
fn user_authentication(user_id: &str) -> MacroUserAuthentication {
MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::Session,
agent_id: None,
macro_user_id: MacroUserIdStr::try_from(user_id.to_string()).expect("valid user id"),
user_context: UserContext {
diff --git a/crates/entity_access/src/inbound/axum_extractors/principal/test.rs b/crates/entity_access/src/inbound/axum_extractors/principal/test.rs
index 7f89f95274..d80cac7d85 100644
--- a/crates/entity_access/src/inbound/axum_extractors/principal/test.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/principal/test.rs
@@ -17,6 +17,7 @@ async fn signed_agent_uses_owner_scope_and_preserves_both_identities() {
let agent_id = bot_id::MACRO_NEW_BOT_ID;
let owner = "macro|[email protected]".to_string().try_into().unwrap();
let principal = MacroAuthorization::User(MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::MacroApiJwt,
agent_id: Some(agent_id),
macro_user_id: owner,
user_context: UserContext {
@@ -58,6 +59,7 @@ async fn signed_agent_uses_owner_scope_and_preserves_both_identities() {
async fn signed_agent_cannot_send_without_owner_access() {
let service = FakeEntityAccessService::new(None);
let principal = MacroAuthorization::User(MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::MacroApiJwt,
agent_id: Some(bot_id::MACRO_NEW_BOT_ID),
macro_user_id: "macro|[email protected]".to_string().try_into().unwrap(),
user_context: UserContext {
@@ -83,6 +85,7 @@ async fn signed_agent_cannot_send_without_owner_access() {
async fn signed_agent_does_not_change_caller_identity_for_existing_messages() {
let service = FakeEntityAccessService::new(Some(AccessLevel::Edit));
let principal = MacroAuthorization::User(MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::MacroApiJwt,
agent_id: Some(bot_id::MACRO_NEW_BOT_ID),
macro_user_id: "macro|[email protected]".to_string().try_into().unwrap(),
user_context: UserContext {
diff --git a/crates/entity_access/src/inbound/axum_extractors/project/test.rs b/crates/entity_access/src/inbound/axum_extractors/project/test.rs
index 80d823aab4..2ee5ec08fb 100644
--- a/crates/entity_access/src/inbound/axum_extractors/project/test.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/project/test.rs
@@ -225,6 +225,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
}
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_bot(
&self,
token: &str,
diff --git a/crates/entity_access/src/inbound/axum_extractors/team/test.rs b/crates/entity_access/src/inbound/axum_extractors/team/test.rs
index e144c7b680..6c630b36cb 100644
--- a/crates/entity_access/src/inbound/axum_extractors/team/test.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/team/test.rs
@@ -250,6 +250,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
}
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_bot(
&self,
token: &str,
diff --git a/crates/entity_access/src/inbound/axum_extractors/test_support.rs b/crates/entity_access/src/inbound/axum_extractors/test_support.rs
index e73017736a..8013c6b362 100644
--- a/crates/entity_access/src/inbound/axum_extractors/test_support.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/test_support.rs
@@ -241,6 +241,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
}
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_bot(
&self,
token: &str,
@@ -281,6 +290,7 @@ pub(super) fn user_scoped_bot_authentication() -> BotAuthentication {
bot_scope: BotScope::User,
team_id: None,
acting_user: Some(MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::Bot,
agent_id: None,
macro_user_id: MacroUserIdStr::try_from(BOT_ACTING_USER_ID.to_string())
.expect("valid bot acting user id"),
diff --git a/crates/entity_access/src/inbound/axum_extractors/thread/test.rs b/crates/entity_access/src/inbound/axum_extractors/thread/test.rs
index 514d9cd585..75152d3370 100644
--- a/crates/entity_access/src/inbound/axum_extractors/thread/test.rs
+++ b/crates/entity_access/src/inbound/axum_extractors/thread/test.rs
@@ -60,6 +60,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
}
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_bot(
&self,
token: &str,
diff --git a/crates/entity_registry/entity_registry/src/domain/creation_principal/test.rs b/crates/entity_registry/entity_registry/src/domain/creation_principal/test.rs
index 15215f4f3d..4bf76f26d0 100644
--- a/crates/entity_registry/entity_registry/src/domain/creation_principal/test.rs
+++ b/crates/entity_registry/entity_registry/src/domain/creation_principal/test.rs
@@ -17,6 +17,7 @@ fn user_id() -> MacroUserIdStr<'static> {
fn user() -> MacroUserAuthentication {
MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::Session,
agent_id: None,
macro_user_id: user_id(),
user_context: Default::default(),
diff --git a/crates/favorites/src/inbound/axum_router/test.rs b/crates/favorites/src/inbound/axum_router/test.rs
index d947b8235d..15eba53e7d 100644
--- a/crates/favorites/src/inbound/axum_router/test.rs
+++ b/crates/favorites/src/inbound/axum_router/test.rs
@@ -35,6 +35,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
})
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
_provided_key: &str,
diff --git a/crates/foreign_entity/src/inbound/axum_router/tests.rs b/crates/foreign_entity/src/inbound/axum_router/tests.rs
index b72400f8c4..b7d2bf06ba 100644
--- a/crates/foreign_entity/src/inbound/axum_router/tests.rs
+++ b/crates/foreign_entity/src/inbound/axum_router/tests.rs
@@ -318,6 +318,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
unreachable!("internal requests should not authorize user credentials")
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
provided_key: &str,
diff --git a/crates/forms/src/inbound/axum_router/test/fakes.rs b/crates/forms/src/inbound/axum_router/test/fakes.rs
index 23da59f633..33d4e46c66 100644
--- a/crates/forms/src/inbound/axum_router/test/fakes.rs
+++ b/crates/forms/src/inbound/axum_router/test/fakes.rs
@@ -40,18 +40,24 @@ pub(super) const ROW: RowId = RowId::from_uuid(Uuid::from_u128(0x40));
pub(super) struct Tokens;
impl JwtValidator for Tokens {
- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
+ fn validate_credential(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
let user_id = match jwt {
"owner" => OWNER,
"respondent" => RESPONDENT,
_ => return Err(Report::new(MacroAuthorizationError::InvalidCredentials)),
};
- Ok(ValidatedIdentity {
- agent_id: None,
- user_id: user_id.to_string(),
- fusion_user_id: format!("fusion-{jwt}"),
- organization_id: None,
- permissions: None,
+ Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: user_id.to_string(),
+ fusion_user_id: format!("fusion-{jwt}"),
+ organization_id: None,
+ permissions: None,
+ },
})
}
}
diff --git a/crates/github/src/inbound/github_sync_router/test.rs b/crates/github/src/inbound/github_sync_router/test.rs
index 861ff7c09f..48ebb3a468 100644
--- a/crates/github/src/inbound/github_sync_router/test.rs
+++ b/crates/github/src/inbound/github_sync_router/test.rs
@@ -51,6 +51,15 @@ impl MacroAuthorizationService for TestAuthorizationService {
})
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
_provided_key: &str,
diff --git a/crates/graphql_common/src/authorization/test.rs b/crates/graphql_common/src/authorization/test.rs
index 16294ee0e9..b590e3fb8a 100644
--- a/crates/graphql_common/src/authorization/test.rs
+++ b/crates/graphql_common/src/authorization/test.rs
@@ -49,6 +49,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
})
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_bot(
&self,
token: &str,
diff --git a/crates/gtm_invite/src/inbound/axum_router/test.rs b/crates/gtm_invite/src/inbound/axum_router/test.rs
index 64ff068e10..6d1b36396b 100644
--- a/crates/gtm_invite/src/inbound/axum_router/test.rs
+++ b/crates/gtm_invite/src/inbound/axum_router/test.rs
@@ -50,6 +50,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
}
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
_provided_key: &str,
diff --git a/crates/import/src/inbound/axum_router/test.rs b/crates/import/src/inbound/axum_router/test.rs
index 6a728a70cf..af37e7a607 100644
--- a/crates/import/src/inbound/axum_router/test.rs
+++ b/crates/import/src/inbound/axum_router/test.rs
@@ -32,6 +32,18 @@ impl MacroAuthorizationService for FakeAuthorization {
})
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> std::result::Result<
+ macro_authorization::ValidatedCredential,
+ Report<MacroAuthorizationError>,
+ > {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
_provided_key: &str,
diff --git a/crates/initiative/src/inbound/axum_router/test.rs b/crates/initiative/src/inbound/axum_router/test.rs
index 71d9e0ee92..e18e107772 100644
--- a/crates/initiative/src/inbound/axum_router/test.rs
+++ b/crates/initiative/src/inbound/axum_router/test.rs
@@ -112,6 +112,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
Ok(user_context())
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
_provided_key: &str,
diff --git a/crates/macro_authorization/AGENTS.md b/crates/macro_authorization/AGENTS.md
index e91df4e1c8..a494c33f83 100644
--- a/crates/macro_authorization/AGENTS.md
+++ b/crates/macro_authorization/AGENTS.md
@@ -48,7 +48,18 @@ by policy.
- `cargo test -p macro_authorization` (`SQLX_OFFLINE` unset).
-`authorize_identity` retains signed agent attribution on user authentication. It
+`ValidatedIdentity` contains identity facts; `ValidatedCredential` and
+`MacroUserAuthentication` additionally carry `CredentialOrigin` (session, Macro API
+JWT, user API key, or the acting user of a bot, harness or internal caller), set
+where the credential is verified. Every `JwtValidator` implements
+`validate_credential` (`validate` derives from it) and every
+`MacroAuthorizationService` implements `authorize_identity`; neither has a default
+that assumes a session. Session-only fakes use `ValidatedCredential::session`. The
+production `MacroAuthJwtValidator` derives origin from the verified token enum in
+one decode.
+Personal-session-only capabilities match `origin == Session` (and no agent
+attribution) instead of sniffing request headers. `authorize_identity` retains
+verified origin and signed agent attribution on user authentication. It
does not turn a user credential into bot authority or change endpoint policies.
## Gotchas
diff --git a/crates/macro_authorization/src/domain/bot_authorizer.rs b/crates/macro_authorization/src/domain/bot_authorizer.rs
index 2b44039338..dfbbe3508e 100644
--- a/crates/macro_authorization/src/domain/bot_authorizer.rs
+++ b/crates/macro_authorization/src/domain/bot_authorizer.rs
@@ -10,7 +10,7 @@ use rootcause::Report;
use super::{
models::{
BotActingUserClaims, BotAuthentication, BotAuthorizationOwner, BotScope,
- BotTokenAuthorization, MacroAuthorizationError, MacroUserAuthentication,
+ BotTokenAuthorization, CredentialOrigin, MacroAuthorizationError, MacroUserAuthentication,
ResolvedBotActingUser,
},
ports::{BotAuthorizationRepo, BotAuthorizer},
@@ -153,6 +153,7 @@ where
fn user_authentication(acting_user: ResolvedBotActingUser) -> MacroUserAuthentication {
let user_id = acting_user.macro_user_id.as_ref().to_owned();
MacroUserAuthentication {
+ origin: CredentialOrigin::Bot,
agent_id: None,
macro_user_id: acting_user.macro_user_id,
user_context: UserContext {
diff --git a/crates/macro_authorization/src/domain/harness_authorizer.rs b/crates/macro_authorization/src/domain/harness_authorizer.rs
index 8d255e45a1..bbfebc43e9 100644
--- a/crates/macro_authorization/src/domain/harness_authorizer.rs
+++ b/crates/macro_authorization/src/domain/harness_authorizer.rs
@@ -8,8 +8,9 @@ use rootcause::Report;
use super::{
models::{
- HarnessAuthentication, HarnessAuthorizationOwner, HarnessTokenAuthorization,
- MacroAuthorizationError, MacroUserAuthentication, ResolvedBotActingUser,
+ CredentialOrigin, HarnessAuthentication, HarnessAuthorizationOwner,
+ HarnessTokenAuthorization, MacroAuthorizationError, MacroUserAuthentication,
+ ResolvedBotActingUser,
},
ports::{HarnessAuthorizationRepo, HarnessAuthorizer},
};
@@ -110,6 +111,7 @@ where
fn user_authentication(acting_user: ResolvedBotActingUser) -> MacroUserAuthentication {
let user_id = acting_user.macro_user_id.as_ref().to_owned();
MacroUserAuthentication {
+ origin: CredentialOrigin::Harness,
agent_id: None,
macro_user_id: acting_user.macro_user_id,
user_context: UserContext {
diff --git a/crates/macro_authorization/src/domain/models.rs b/crates/macro_authorization/src/domain/models.rs
index 0801603f4e..b0e5c86704 100644
--- a/crates/macro_authorization/src/domain/models.rs
+++ b/crates/macro_authorization/src/domain/models.rs
@@ -13,6 +13,8 @@ use uuid::Uuid;
/// A user identity that has been authenticated or verified for a bot.
#[derive(Clone, Debug)]
pub struct MacroUserAuthentication {
+ /// The kind of credential that established this user.
+ pub origin: CredentialOrigin,
/// Signed agent attribution for user-authorized SDK messages, not a bot credential.
pub agent_id: Option<BotId>,
/// The user's parsed Macro identifier.
@@ -21,6 +23,25 @@ pub struct MacroUserAuthentication {
pub user_context: UserContext,
}
+/// The kind of credential that authenticated a user, set where the credential
+/// is verified. Policies that need a person's own session match on it rather
+/// than on request hints.
+#[derive(Clone, Copy, Debug, Eq, PartialEq)]
+pub enum CredentialOrigin {
+ /// A personal session JWT.
+ Session,
+ /// A verified Macro API JWT (SDK, MCP), with or without agent attribution.
+ MacroApiJwt,
+ /// A user API key.
+ UserApiKey,
+ /// The acting user of a verified bot credential.
+ Bot,
+ /// The acting user of a verified harness credential.
+ Harness,
+ /// The acting user claimed by a verified internal service caller.
+ Internal,
+}
+
/// The access scope selected for a bot-authorized request.
#[derive(Clone, Copy, Debug, Eq, PartialEq)]
pub enum BotScope {
@@ -267,6 +288,31 @@ pub struct ValidatedIdentity {
pub permissions: Option<HashSet<String>>,
}
+/// A validated identity together with its cryptographically established origin.
+#[derive(Clone, Debug, Eq, PartialEq)]
+pub struct ValidatedCredential {
+ /// Identity established by credential validation.
+ pub identity: ValidatedIdentity,
+ /// The kind of credential that was verified.
+ pub origin: CredentialOrigin,
+}
+
+impl ValidatedCredential {
+ /// A personal session for this user context, with no agent attribution.
+ pub fn session(context: UserContext) -> Self {
+ Self {
+ origin: CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: context.user_id,
+ fusion_user_id: context.fusion_user_id,
+ organization_id: context.organization_id,
+ permissions: context.permissions,
+ },
+ }
+ }
+}
+
/// Errors returned when a credential cannot authorize a caller.
///
/// The variants deliberately omit validation implementation details so callers
diff --git a/crates/macro_authorization/src/domain/models/test.rs b/crates/macro_authorization/src/domain/models/test.rs
index 95f16dbb49..da78445e6d 100644
--- a/crates/macro_authorization/src/domain/models/test.rs
+++ b/crates/macro_authorization/src/domain/models/test.rs
@@ -14,6 +14,7 @@ const TEAM_ID: Uuid = Uuid::from_u128(3);
fn user_authentication() -> MacroUserAuthentication {
MacroUserAuthentication {
+ origin: crate::CredentialOrigin::Session,
agent_id: None,
macro_user_id: MacroUserIdStr::try_from("macro|[email protected]".to_string())
.expect("valid Macro user id"),
diff --git a/crates/macro_authorization/src/domain/ports.rs b/crates/macro_authorization/src/domain/ports.rs
index ebb3211d65..0878db8828 100644
--- a/crates/macro_authorization/src/domain/ports.rs
+++ b/crates/macro_authorization/src/domain/ports.rs
@@ -6,7 +6,7 @@ use rootcause::Report;
use super::models::{
BotActingUserClaims, BotAuthentication, BotScope, BotTokenAuthorization, HarnessAuthentication,
HarnessTokenAuthorization, InternalIdentityClaims, MacroAuthorizationError, ResolvedApiKeyUser,
- ResolvedBotActingUser, ValidatedIdentity,
+ ResolvedBotActingUser, ValidatedCredential, ValidatedIdentity,
};
use uuid::Uuid;
@@ -166,8 +166,19 @@ impl HarnessAuthorizer for NoHarnessAuthorizer {
/// Implementations resolve any required secrets during startup, allowing this
/// operation to remain synchronous.
pub trait JwtValidator: Clone + Send + Sync + 'static {
+ /// Validate a credential and return its identity together with the kind
+ /// of credential it was, derived from the cryptographically validated
+ /// token, never from request hints.
+ fn validate_credential(
+ &self,
+ jwt: &str,
+ ) -> Result<ValidatedCredential, Report<MacroAuthorizationError>>;
+
/// Validate a credential and return its transport-independent identity.
- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>>;
+ fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
+ self.validate_credential(jwt)
+ .map(|credential| credential.identity)
+ }
}
/// Authorizes credentials and constructs application user contexts.
@@ -181,24 +192,13 @@ pub trait MacroAuthorizationService: Clone + Send + Sync + 'static {
jwt: &str,
) -> impl Future<Output = Result<UserContext, Report<MacroAuthorizationError>>> + Send;
- /// Authorize a user credential while retaining signed agent attribution.
- /// Context-only authorizers establish no agent identity.
+ /// Authorize a user credential while retaining its verified origin and
+ /// signed agent attribution. Every authorizer states the origin of the
+ /// credentials it accepts; there is no default that assumes a session.
fn authorize_identity(
&self,
jwt: &str,
- ) -> impl Future<Output = Result<ValidatedIdentity, Report<MacroAuthorizationError>>> + Send
- {
- async {
- let context = self.authorize(jwt).await?;
- Ok(ValidatedIdentity {
- agent_id: None,
- user_id: context.user_id,
- fusion_user_id: context.fusion_user_id,
- organization_id: context.organization_id,
- permissions: context.permissions,
- })
- }
- }
+ ) -> impl Future<Output = Result<ValidatedCredential, Report<MacroAuthorizationError>>> + Send;
/// Authorize a bot token, verifying any acting-user claims.
///
diff --git a/crates/macro_authorization/src/domain/service.rs b/crates/macro_authorization/src/domain/service.rs
index 0f4a5fef24..00a24290ae 100644
--- a/crates/macro_authorization/src/domain/service.rs
+++ b/crates/macro_authorization/src/domain/service.rs
@@ -11,7 +11,7 @@ use tracing::Level;
use super::{
models::{
BotActingUserClaims, BotAuthentication, BotScope, HarnessAuthentication,
- InternalAuthConfig, InternalIdentityClaims, MacroAuthorizationError, ValidatedIdentity,
+ InternalAuthConfig, InternalIdentityClaims, MacroAuthorizationError, ValidatedCredential,
},
ports::{
BotAuthorizer, HarnessAuthorizer, JwtValidator, MacroAuthorizationService,
@@ -159,8 +159,8 @@ where
async fn authorize_identity(
&self,
jwt: &str,
- ) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
- self.validator.validate(jwt)
+ ) -> Result<ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.validator.validate_credential(jwt)
}
#[tracing::instrument(
diff --git a/crates/macro_authorization/src/domain/service/test.rs b/crates/macro_authorization/src/domain/service/test.rs
index 587bc95802..e6bc014c39 100644
--- a/crates/macro_authorization/src/domain/service/test.rs
+++ b/crates/macro_authorization/src/domain/service/test.rs
@@ -12,9 +12,9 @@ use uuid::Uuid;
use super::MacroAuthorizationServiceImpl;
use crate::domain::{
models::{
- BotActingUserClaims, BotAuthentication, BotScope, InternalAuthConfig,
+ BotActingUserClaims, BotAuthentication, BotScope, CredentialOrigin, InternalAuthConfig,
InternalIdentityClaims, MacroAuthorizationError, MacroUserAuthentication,
- ValidatedIdentity,
+ ValidatedCredential, ValidatedIdentity,
},
ports::{
BotAuthorizer, JwtValidator, MacroAuthorizationService, NoBotAuthorizer,
@@ -24,11 +24,14 @@ use crate::domain::{
#[derive(Clone)]
struct FakeJwtValidator {
- result: Result<ValidatedIdentity, MacroAuthorizationError>,
+ result: Result<ValidatedCredential, MacroAuthorizationError>,
}
impl JwtValidator for FakeJwtValidator {
- fn validate(&self, _jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
+ fn validate_credential(
+ &self,
+ _jwt: &str,
+ ) -> Result<ValidatedCredential, Report<MacroAuthorizationError>> {
self.result.clone().map_err(Report::new)
}
}
@@ -120,6 +123,15 @@ impl MacroAuthorizationService for DefaultRejectingAuthorizationService {
Err(Report::new(MacroAuthorizationError::InvalidCredentials))
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(crate::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
_provided_key: &str,
@@ -161,6 +173,7 @@ fn bot_authentication() -> BotAuthentication {
bot_scope: BotScope::Team,
team_id: Some(TEAM_ID),
acting_user: Some(MacroUserAuthentication {
+ origin: crate::CredentialOrigin::Bot,
agent_id: None,
macro_user_id: MacroUserIdStr::try_from("macro|[email protected]".to_string())
.expect("valid Macro user id"),
@@ -308,12 +321,15 @@ async fn authorize_constructs_user_context_from_validated_identity() {
let permissions = HashSet::from(["documents:read".to_string(), "documents:write".to_string()]);
let service = MacroAuthorizationServiceImpl::new(
FakeJwtValidator {
- result: Ok(ValidatedIdentity {
- agent_id: None,
- user_id: "macro|[email protected]".to_string(),
- fusion_user_id: "fusion-user-id".to_string(),
- organization_id: Some(42),
- permissions: Some(permissions.clone()),
+ result: Ok(ValidatedCredential {
+ origin: CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: "macro|[email protected]".to_string(),
+ fusion_user_id: "fusion-user-id".to_string(),
+ organization_id: Some(42),
+ permissions: Some(permissions.clone()),
+ },
}),
},
internal_auth_config(None),
@@ -530,19 +546,24 @@ async fn authorize_user_api_key_passes_through_authorizer_errors() {
async fn authorize_identity_keeps_verified_agent_and_owner() {
let service = MacroAuthorizationServiceImpl::new(
FakeJwtValidator {
- result: Ok(ValidatedIdentity {
- agent_id: Some(bot_id::MACRO_NEW_BOT_ID),
- user_id: "macro|[email protected]".into(),
- fusion_user_id: "fusion-owner".into(),
- organization_id: Some(42),
- permissions: None,
+ result: Ok(ValidatedCredential {
+ origin: CredentialOrigin::MacroApiJwt,
+ identity: ValidatedIdentity {
+ agent_id: Some(bot_id::MACRO_NEW_BOT_ID),
+ user_id: "macro|[email protected]".into(),
+ fusion_user_id: "fusion-owner".into(),
+ organization_id: Some(42),
+ permissions: None,
+ },
}),
},
internal_auth_config(None),
NoBotAuthorizer,
NoUserApiKeyAuthorizer,
);
- let identity = service.authorize_identity("signed-token").await.unwrap();
+ let credential = service.authorize_identity("signed-token").await.unwrap();
+ assert_eq!(credential.origin, CredentialOrigin::MacroApiJwt);
+ let identity = credential.identity;
assert_eq!(identity.agent_id, Some(bot_id::MACRO_NEW_BOT_ID));
assert_eq!(identity.user_id, "macro|[email protected]");
assert_eq!(
diff --git a/crates/macro_authorization/src/inbound/axum.rs b/crates/macro_authorization/src/inbound/axum.rs
index a3dc6c2fbd..aa0093e5d3 100644
--- a/crates/macro_authorization/src/inbound/axum.rs
+++ b/crates/macro_authorization/src/inbound/axum.rs
@@ -24,7 +24,9 @@ use model_error_response::ErrorResponse;
use model_user::UserContext;
use rootcause::Report;
-use crate::{MacroAuthorization, MacroAuthorizationError, MacroUserAuthentication};
+use crate::{
+ CredentialOrigin, MacroAuthorization, MacroAuthorizationError, MacroUserAuthentication,
+};
pub use bot::{
BOT_FOR_FUSIONAUTH_USER_ID_HEADER, BOT_FOR_MACRO_USER_ID_HEADER,
@@ -134,6 +136,7 @@ impl<Svc> Clone for MacroAuthorizationState<Svc> {
pub(super) fn authenticated_user(
user_context: UserContext,
+ origin: CredentialOrigin,
) -> Result<MacroUserAuthentication, MacroAuthorizationRejection> {
let macro_user_id = MacroUserIdStr::parse_from_str(&user_context.user_id)
.map(CowLike::into_owned)
@@ -143,6 +146,7 @@ pub(super) fn authenticated_user(
})?;
Ok(MacroUserAuthentication {
+ origin,
agent_id: None,
macro_user_id,
user_context,
diff --git a/crates/macro_authorization/src/inbound/axum/internal.rs b/crates/macro_authorization/src/inbound/axum/internal.rs
index ec146a4196..5886a4b2f3 100644
--- a/crates/macro_authorization/src/inbound/axum/internal.rs
+++ b/crates/macro_authorization/src/inbound/axum/internal.rs
@@ -5,7 +5,8 @@ use ::axum::{
use rootcause::Report;
use crate::{
- InternalIdentityClaims, MacroAuthorization, MacroAuthorizationError, MacroAuthorizationService,
+ CredentialOrigin, InternalIdentityClaims, MacroAuthorization, MacroAuthorizationError,
+ MacroAuthorizationService,
};
use super::{
@@ -74,7 +75,9 @@ where
.authorize_internal(provided_key, claims)
.await
.map_err(internal_authorization_rejection)?;
- let acting_user = user_context.map(authenticated_user).transpose()?;
+ let acting_user = user_context
+ .map(|user_context| authenticated_user(user_context, CredentialOrigin::Internal))
+ .transpose()?;
Ok(Some(MacroAuthorization::Internal(acting_user)))
}
diff --git a/crates/macro_authorization/src/inbound/axum/test.rs b/crates/macro_authorization/src/inbound/axum/test.rs
index 655c4236cb..ad8a51c3d0 100644
--- a/crates/macro_authorization/src/inbound/axum/test.rs
+++ b/crates/macro_authorization/src/inbound/axum/test.rs
@@ -87,6 +87,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
}
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<crate::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(crate::ValidatedCredential::session)
+ }
+
async fn authorize_user_api_key(
&self,
api_key: &str,
@@ -179,6 +188,7 @@ fn bot_authentication(bot_scope: BotScope, acting_user_id: Option<&str>) -> BotA
bot_scope,
team_id: (bot_scope == BotScope::Team).then_some(BOT_TEAM_ID),
acting_user: acting_user_id.map(|user_id| MacroUserAuthentication {
+ origin: crate::CredentialOrigin::Bot,
agent_id: None,
macro_user_id: MacroUserIdStr::try_from(user_id.to_owned())
.expect("valid bot acting user id"),
@@ -276,6 +286,7 @@ async fn user_handler(
"acting_entity": acting_entity,
"macro_user_id": extractor.authorization.macro_user_id.to_string(),
"user_context": extractor.authorization.user_context,
+ "origin": format!("{:?}", extractor.authorization.origin),
}))
}
@@ -1337,6 +1348,9 @@ async fn user_api_key_authenticates_as_the_user() {
.await;
assert_eq!(status, StatusCode::OK, "path {path}");
assert_eq!(body["acting_entity"], API_KEY_USER_ID);
+ if path == "/user" {
+ assert_eq!(body["origin"], "UserApiKey");
+ }
if path != "/required/user-only" {
assert_eq!(body["macro_user_id"], API_KEY_USER_ID);
}
@@ -2203,6 +2217,7 @@ fn policies_report_typed_acting_entity_variants_with_display_parity() {
fn macro_user_authentication(user_id: &str) -> MacroUserAuthentication {
MacroUserAuthentication {
+ origin: crate::CredentialOrigin::Session,
agent_id: None,
macro_user_id: MacroUserIdStr::try_from(user_id.to_owned()).expect("valid Macro user ID"),
user_context: user_context(user_id, None),
diff --git a/crates/macro_authorization/src/inbound/axum/user.rs b/crates/macro_authorization/src/inbound/axum/user.rs
index 514a780fe0..d165ee0c9c 100644
--- a/crates/macro_authorization/src/inbound/axum/user.rs
+++ b/crates/macro_authorization/src/inbound/axum/user.rs
@@ -56,7 +56,7 @@ where
#[cfg(feature = "local_auth")]
if let Some(user_context) = local_user_context() {
- return authenticated_user(user_context).map(Some);
+ return authenticated_user(user_context, crate::CredentialOrigin::Session).map(Some);
}
let Some(token) = extract_ambient_user_token(parts, state).await else {
@@ -138,18 +138,22 @@ where
Svc: MacroAuthorizationService,
{
let authorization = MacroAuthorizationState::<Svc>::from_ref(state);
- let identity = authorization
+ let credential = authorization
.service
.authorize_identity(token)
.await
.map_err(authorization_rejection)?;
- let mut user = authenticated_user(model_user::UserContext {
- user_id: identity.user_id,
- fusion_user_id: identity.fusion_user_id,
- organization_id: identity.organization_id,
- permissions: identity.permissions,
- })?;
+ let identity = credential.identity;
+ let mut user = authenticated_user(
+ model_user::UserContext {
+ user_id: identity.user_id,
+ fusion_user_id: identity.fusion_user_id,
+ organization_id: identity.organization_id,
+ permissions: identity.permissions,
+ },
+ credential.origin,
+ )?;
user.agent_id = identity.agent_id;
Ok(user)
}
diff --git a/crates/macro_authorization/src/inbound/axum/user/test.rs b/crates/macro_authorization/src/inbound/axum/user/test.rs
index f4851525ac..65ebf1c764 100644
--- a/crates/macro_authorization/src/inbound/axum/user/test.rs
+++ b/crates/macro_authorization/src/inbound/axum/user/test.rs
@@ -1,17 +1,31 @@
use super::*;
use crate::{
- BotOnly, InternalAuthConfig, JwtValidator, MacroAuthorizationExtractor,
+ BotOnly, CredentialOrigin, InternalAuthConfig, JwtValidator, MacroAuthorizationExtractor,
MacroAuthorizationServiceImpl, NoBotAuthorizer, NoUserApiKeyAuthorizer, UserOnly,
- ValidatedIdentity,
+ ValidatedCredential, ValidatedIdentity,
};
use std::sync::Arc;
#[derive(Clone)]
struct Validator;
impl JwtValidator for Validator {
+ fn validate_credential(
+ &self,
+ jwt: &str,
+ ) -> Result<ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.validate(jwt).map(|identity| ValidatedCredential {
+ identity,
+ origin: if jwt == "user" {
+ CredentialOrigin::Session
+ } else {
+ CredentialOrigin::MacroApiJwt
+ },
+ })
+ }
+
fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
match jwt {
- "execution" | "user" => Ok(ValidatedIdentity {
+ "execution" | "api" | "user" => Ok(ValidatedIdentity {
agent_id: (jwt == "execution").then_some(bot_id::MACRO_NEW_BOT_ID),
user_id: "macro|[email protected]".into(),
fusion_user_id: "fusion-owner".into(),
@@ -38,6 +52,7 @@ async fn bearer_agent_attribution_survives_user_policy_without_becoming_bot_auth
)));
for (token, agent) in [
("execution", Some(bot_id::MACRO_NEW_BOT_ID)),
+ ("api", None),
("user", None),
] {
let (mut parts, _) = axum::http::Request::builder()
@@ -52,6 +67,14 @@ async fn bearer_agent_attribution_survives_user_policy_without_becoming_bot_auth
.await
.unwrap();
assert_eq!(caller.authorization.agent_id, agent);
+ assert_eq!(
+ caller.authorization.origin,
+ if token == "user" {
+ CredentialOrigin::Session
+ } else {
+ CredentialOrigin::MacroApiJwt
+ }
+ );
assert_eq!(
caller.authorization.macro_user_id.as_ref(),
diff --git a/crates/macro_authorization/src/inbound/axum/user_api_key.rs b/crates/macro_authorization/src/inbound/axum/user_api_key.rs
index 35c556a1df..b666630bfa 100644
--- a/crates/macro_authorization/src/inbound/axum/user_api_key.rs
+++ b/crates/macro_authorization/src/inbound/axum/user_api_key.rs
@@ -4,7 +4,9 @@ use ::axum::{
};
use rootcause::Report;
-use crate::{MacroAuthorizationError, MacroAuthorizationService, MacroUserAuthentication};
+use crate::{
+ CredentialOrigin, MacroAuthorizationError, MacroAuthorizationService, MacroUserAuthentication,
+};
use super::{
MacroAuthorizationRejection, MacroAuthorizationState, authenticated_user,
@@ -30,7 +32,7 @@ where
.await
.map_err(user_api_key_authorization_rejection)?;
- authenticated_user(user_context)
+ authenticated_user(user_context, CredentialOrigin::UserApiKey)
}
fn user_api_key(headers: &HeaderMap) -> Result<String, MacroAuthorizationRejection> {
diff --git a/crates/macro_authorization/src/lib.rs b/crates/macro_authorization/src/lib.rs
index 299783dbac..e76421e2c1 100644
--- a/crates/macro_authorization/src/lib.rs
+++ b/crates/macro_authorization/src/lib.rs
@@ -63,10 +63,10 @@ pub use domain::{
harness_authorizer::HarnessAuthorizerService,
models::{
BotActingUserClaims, BotAuthentication, BotAuthorizationOwner, BotScope,
- BotTokenAuthorization, HarnessAuthentication, HarnessAuthorizationOwner,
+ BotTokenAuthorization, CredentialOrigin, HarnessAuthentication, HarnessAuthorizationOwner,
HarnessTokenAuthorization, InternalAuthConfig, InternalIdentityClaims, MacroAuthorization,
MacroAuthorizationError, MacroUserAuthentication, ResolvedApiKeyUser,
- ResolvedBotActingUser, ValidatedIdentity,
+ ResolvedBotActingUser, ValidatedCredential, ValidatedIdentity,
},
ports::{
BotAuthorizationRepo, BotAuthorizer, HarnessAuthorizationRepo, HarnessAuthorizer,
diff --git a/crates/macro_authorization/src/outbound/macro_auth.rs b/crates/macro_authorization/src/outbound/macro_auth.rs
index 2ae838d900..d732bef7b1 100644
--- a/crates/macro_authorization/src/outbound/macro_auth.rs
+++ b/crates/macro_authorization/src/outbound/macro_auth.rs
@@ -9,7 +9,7 @@ use rootcause::Report;
use tracing::Level;
use crate::domain::{
- models::{MacroAuthorizationError, ValidatedIdentity},
+ models::{CredentialOrigin, MacroAuthorizationError, ValidatedCredential, ValidatedIdentity},
ports::JwtValidator,
};
@@ -34,14 +34,21 @@ impl MacroAuthJwtValidator {
impl JwtValidator for MacroAuthJwtValidator {
#[tracing::instrument(err(level = Level::DEBUG), skip(self, jwt))]
- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
+ fn validate_credential(
+ &self,
+ jwt: &str,
+ ) -> Result<ValidatedCredential, Report<MacroAuthorizationError>> {
decode_jwt::handler(&self.jwt_validation_args, jwt)
.map(identity_from_token)
.map_err(validation_error)
}
}
-fn identity_from_token(token: JwtToken) -> ValidatedIdentity {
+fn identity_from_token(token: JwtToken) -> ValidatedCredential {
+ let origin = match &token {
+ JwtToken::MacroAccessToken(_) => CredentialOrigin::Session,
+ JwtToken::MacroApiToken(_) => CredentialOrigin::MacroApiJwt,
+ };
let (user_id, fusion_user_id, organization_id, agent_id) = match token {
JwtToken::MacroAccessToken(token) => (
token.macro_user_id,
@@ -57,12 +64,15 @@ fn identity_from_token(token: JwtToken) -> ValidatedIdentity {
),
};
- ValidatedIdentity {
- agent_id,
- user_id,
- fusion_user_id,
- organization_id,
- permissions: None,
+ ValidatedCredential {
+ origin,
+ identity: ValidatedIdentity {
+ agent_id,
+ user_id,
+ fusion_user_id,
+ organization_id,
+ permissions: None,
+ },
}
}
diff --git a/crates/macro_authorization/src/outbound/macro_auth/test.rs b/crates/macro_authorization/src/outbound/macro_auth/test.rs
index 229004f710..53a005d2f6 100644
--- a/crates/macro_authorization/src/outbound/macro_auth/test.rs
+++ b/crates/macro_authorization/src/outbound/macro_auth/test.rs
@@ -63,7 +63,9 @@ fn macro_auth_cause(report: &Report<MacroAuthorizationError>) -> &MacroAuthError
fn validates_access_token() {
let token = access_token("", unix_timestamp() + 3_600, None, None);
- let identity = validator().validate(&token).unwrap();
+ let credential = validator().validate_credential(&token).unwrap();
+ assert_eq!(credential.origin, CredentialOrigin::Session);
+ let identity = credential.identity;
assert_eq!(identity.user_id, MACRO_USER_ID);
assert_eq!(identity.fusion_user_id, FUSION_USER_ID);
@@ -139,7 +141,7 @@ fn preserves_access_token_organization_id() {
#[test]
fn maps_macro_api_token_claims() {
- let identity = identity_from_token(JwtToken::MacroApiToken(MacroApiToken {
+ let credential = identity_from_token(JwtToken::MacroApiToken(MacroApiToken {
agent_id: None,
exp: unix_timestamp() + 3_600,
iss: String::new(),
@@ -148,6 +150,8 @@ fn maps_macro_api_token_claims() {
macro_organization_id: Some(84),
}));
+ assert_eq!(credential.origin, CredentialOrigin::MacroApiJwt);
+ let identity = credential.identity;
assert_eq!(identity.user_id, MACRO_USER_ID);
assert_eq!(identity.fusion_user_id, FUSION_USER_ID);
assert_eq!(identity.organization_id, Some(84));
@@ -158,7 +162,7 @@ fn maps_macro_api_token_claims() {
#[test]
fn maps_signed_agent_without_changing_owner_identity() {
let agent = bot_id::MACRO_NEW_BOT_ID;
- let identity = identity_from_token(JwtToken::MacroApiToken(MacroApiToken {
+ let credential = identity_from_token(JwtToken::MacroApiToken(MacroApiToken {
agent_id: Some(agent.as_uuid()),
exp: unix_timestamp() + 60,
iss: String::new(),
@@ -166,6 +170,8 @@ fn maps_signed_agent_without_changing_owner_identity() {
macro_user_id: MACRO_USER_ID.into(),
macro_organization_id: Some(42),
}));
+ assert_eq!(credential.origin, CredentialOrigin::MacroApiJwt);
+ let identity = credential.identity;
assert_eq!(identity.agent_id, Some(agent));
assert_eq!(identity.user_id, MACRO_USER_ID);
assert_eq!(identity.organization_id, Some(42));
diff --git a/crates/macro_authorization/src/outbound/noop.rs b/crates/macro_authorization/src/outbound/noop.rs
index 0450b5f427..5e5d431487 100644
--- a/crates/macro_authorization/src/outbound/noop.rs
+++ b/crates/macro_authorization/src/outbound/noop.rs
@@ -4,18 +4,21 @@ mod test;
use rootcause::Report;
use crate::domain::{
- models::{MacroAuthorizationError, ValidatedIdentity},
+ models::{MacroAuthorizationError, ValidatedCredential},
ports::JwtValidator,
};
/// JWT validator for services that only support internal authorization.
///
-/// Calling [`JwtValidator::validate`] is a configuration error and will panic.
+/// Calling [`JwtValidator::validate_credential`] is a configuration error and will panic.
#[derive(Clone, Copy, Debug, Default)]
pub struct NoopMacroAuthJwtValidator;
impl JwtValidator for NoopMacroAuthJwtValidator {
- fn validate(&self, _jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
+ fn validate_credential(
+ &self,
+ _jwt: &str,
+ ) -> Result<ValidatedCredential, Report<MacroAuthorizationError>> {
unimplemented!("NoopMacroAuthJwtValidator cannot validate JWTs")
}
}
diff --git a/crates/notification/src/inbound/http/test.rs b/crates/notification/src/inbound/http/test.rs
index 90c56dd24f..c2b42a8c02 100644
--- a/crates/notification/src/inbound/http/test.rs
+++ b/crates/notification/src/inbound/http/test.rs
@@ -76,6 +76,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
})
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
provided_key: &str,
diff --git a/crates/projects/src/inbound/axum_router/tests.rs b/crates/projects/src/inbound/axum_router/tests.rs
index 7bb59f2c94..fee5d05f8e 100644
--- a/crates/projects/src/inbound/axum_router/tests.rs
+++ b/crates/projects/src/inbound/axum_router/tests.rs
@@ -403,6 +403,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
Ok(user_context(USER_ID))
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
provided_key: &str,
@@ -431,6 +440,7 @@ impl MacroAuthorizationService for FakeAuthorizationService {
acting_user: acting_user
.and_then(|claims| claims.user_id)
.map(|user_id| MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::Bot,
agent_id: None,
macro_user_id: user(&user_id),
user_context: user_context(&user_id),
diff --git a/crates/properties/src/inbound/axum_router/test.rs b/crates/properties/src/inbound/axum_router/test.rs
index 3b7d529e34..6a7df38893 100644
--- a/crates/properties/src/inbound/axum_router/test.rs
+++ b/crates/properties/src/inbound/axum_router/test.rs
@@ -221,14 +221,20 @@ impl EntityAccessService for FakeEntityAccessService {
struct FakeJwtValidator;
impl JwtValidator for FakeJwtValidator {
- fn validate(&self, jwt: &str) -> Result<ValidatedIdentity, Report<MacroAuthorizationError>> {
+ fn validate_credential(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
match jwt {
- "valid" => Ok(ValidatedIdentity {
- agent_id: None,
- user_id: VALID_USER_ID.to_string(),
- fusion_user_id: "fusion-valid-user".to_string(),
- organization_id: Some(ORGANIZATION_ID),
- permissions: None,
+ "valid" => Ok(macro_authorization::ValidatedCredential {
+ origin: macro_authorization::CredentialOrigin::Session,
+ identity: ValidatedIdentity {
+ agent_id: None,
+ user_id: VALID_USER_ID.to_string(),
+ fusion_user_id: "fusion-valid-user".to_string(),
+ organization_id: Some(ORGANIZATION_ID),
+ permissions: None,
+ },
}),
"expired" => Err(Report::new(MacroAuthorizationError::CredentialsExpired)),
_ => Err(Report::new(MacroAuthorizationError::InvalidCredentials)),
diff --git a/crates/referral/src/inbound/axum_router/test.rs b/crates/referral/src/inbound/axum_router/test.rs
index 50398a0b74..7c1626f853 100644
--- a/crates/referral/src/inbound/axum_router/test.rs
+++ b/crates/referral/src/inbound/axum_router/test.rs
@@ -39,6 +39,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
Ok(test_user_context(TEST_USER_ID))
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
provided_key: &str,
diff --git a/crates/reminders/src/inbound/axum_router/test.rs b/crates/reminders/src/inbound/axum_router/test.rs
index 300b3e2ddb..81893bbf20 100644
--- a/crates/reminders/src/inbound/axum_router/test.rs
+++ b/crates/reminders/src/inbound/axum_router/test.rs
@@ -83,6 +83,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
Ok(user_context())
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
_provided_key: &str,
diff --git a/crates/scheduled_action/src/inbound/axum_router/test.rs b/crates/scheduled_action/src/inbound/axum_router/test.rs
index d30d2326a5..d74c918c7c 100644
--- a/crates/scheduled_action/src/inbound/axum_router/test.rs
+++ b/crates/scheduled_action/src/inbound/axum_router/test.rs
@@ -133,6 +133,15 @@ impl MacroAuthorizationService for FakeAuth {
}
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_bot(
&self,
bot_token: &str,
@@ -153,6 +162,7 @@ impl MacroAuthorizationService for FakeAuth {
let macro_user_id = MacroUserIdStr::try_from(user_id).expect("acting user id");
MacroUserAuthentication {
agent_id: None,
+ origin: macro_authorization::CredentialOrigin::Bot,
user_context: UserContext {
user_id: macro_user_id.to_string(),
..Default::default()
diff --git a/crates/scheduled_action/tests/event_routines.rs b/crates/scheduled_action/tests/event_routines.rs
index 74d01f1906..a16bc1b2d2 100644
--- a/crates/scheduled_action/tests/event_routines.rs
+++ b/crates/scheduled_action/tests/event_routines.rs
@@ -89,6 +89,15 @@ impl MacroAuthorizationService for FakeAuth {
..Default::default()
})
}
+
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
async fn authorize_internal(
&self,
_: &str,
diff --git a/crates/slack_integration/src/inbound/axum_router/test.rs b/crates/slack_integration/src/inbound/axum_router/test.rs
index 0dbead2e38..365ec484e8 100644
--- a/crates/slack_integration/src/inbound/axum_router/test.rs
+++ b/crates/slack_integration/src/inbound/axum_router/test.rs
@@ -40,6 +40,15 @@ impl MacroAuthorizationService for Auth {
organization_id: None,
})
}
+
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
async fn authorize_internal(
&self,
_: &str,
diff --git a/crates/soup/src/inbound/axum_router/tests.rs b/crates/soup/src/inbound/axum_router/tests.rs
index abc4ff4d40..f9f992b62d 100644
--- a/crates/soup/src/inbound/axum_router/tests.rs
+++ b/crates/soup/src/inbound/axum_router/tests.rs
@@ -597,6 +597,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
}
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
provided_key: &str,
diff --git a/crates/teams/src/inbound/axum_router/test.rs b/crates/teams/src/inbound/axum_router/test.rs
index 21b89df409..e809915ca4 100644
--- a/crates/teams/src/inbound/axum_router/test.rs
+++ b/crates/teams/src/inbound/axum_router/test.rs
@@ -667,6 +667,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
Err(Report::new(MacroAuthorizationError::InvalidCredentials))
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_internal(
&self,
provided_key: &str,
diff --git a/crates/webhook/src/inbound/axum_router/test.rs b/crates/webhook/src/inbound/axum_router/test.rs
index a3d714fa3a..e1977bfbed 100644
--- a/crates/webhook/src/inbound/axum_router/test.rs
+++ b/crates/webhook/src/inbound/axum_router/test.rs
@@ -102,6 +102,15 @@ impl MacroAuthorizationService for FakeAuthorizationService {
})
}
+ async fn authorize_identity(
+ &self,
+ jwt: &str,
+ ) -> Result<macro_authorization::ValidatedCredential, Report<MacroAuthorizationError>> {
+ self.authorize(jwt)
+ .await
+ .map(macro_authorization::ValidatedCredential::session)
+ }
+
async fn authorize_bot(
&self,
bot_token: &str,
@@ -114,6 +123,7 @@ impl MacroAuthorizationService for FakeAuthorizationService {
let acting_user = acting_user
.and_then(|claims| claims.user_id)
.map(|user_id| macro_authorization::MacroUserAuthentication {
+ origin: macro_authorization::CredentialOrigin::Bot,
agent_id: None,
macro_user_id: MacroUserIdStr::try_from(user_id).unwrap(),
user_context: UserContext::default(),