mirror of
https://github.com/outbackdingo/optimclaw.git
synced 2026-08-25 14:53:34 +00:00
fix: comprehensive multi-tenant isolation audit
Address all review findings from @serrrfirat plus 7 additional gaps found via full security audit: Reviewer findings (5): - WorkspacePool now applies search config, memory layers, embedding cache, identity read scopes, and global config scopes (was bare) - jobs_summary_handler uses per-user queries instead of global counters - jobs_prompt_handler restructured to not 404 agent jobs + ownership check - jobs_restart_handler agent branch now verifies user ownership - agent_job_summary_for_user added to Database trait + both backends Audit findings (7): - Delete dead handlers/memory.rs (stale copies with no auth) - Add AuthenticatedUser to logs_events, logs_level_get, logs_level_set - Add AuthenticatedUser to extensions_tools_handler, gateway_status_handler - Add auth + ownership checks to all 6 routines handlers - Add auth to all 4 skills handlers with audit logging on mutations - Scope extension setup SSE broadcast to user (broadcast_for_user) - Fix pre-existing test compilation errors in extensions/manager.rs 17 new multi-tenant isolation tests covering: - WorkspacePool config propagation and scope merging - Jobs handler per-user isolation (summary, restart, prompt, cancel) - Routines handler auth enforcement and cross-user rejection - Auth middleware enforcement on logs, skills, status endpoints Co-Authored-By: Claude Opus 4.6 (1M context) <[email protected]>
This commit is contained in:
Andrew Preece
co-authored by
Claude Opus 4.6
Claude Opus 4.6
parent
76431159c8
commit
9ac03c3e62
@@ -85,7 +85,7 @@ pub async fn jobs_list_handler(
|
||||
|
||||
pub async fn jobs_summary_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(_user): AuthenticatedUser,
|
||||
AuthenticatedUser(user): AuthenticatedUser,
|
||||
) -> Result<Json<JobSummaryResponse>, (StatusCode, String)> {
|
||||
let store = state.store.as_ref().ok_or((
|
||||
StatusCode::SERVICE_UNAVAILABLE,
|
||||
@@ -99,8 +99,8 @@ pub async fn jobs_summary_handler(
|
||||
let mut failed = 0;
|
||||
let mut stuck = 0;
|
||||
|
||||
// Sandbox job counts.
|
||||
match store.sandbox_job_summary().await {
|
||||
// Sandbox job counts scoped to this user.
|
||||
match store.sandbox_job_summary_for_user(&user.user_id).await {
|
||||
Ok(s) => {
|
||||
total += s.total;
|
||||
pending += s.creating;
|
||||
@@ -113,8 +113,8 @@ pub async fn jobs_summary_handler(
|
||||
}
|
||||
}
|
||||
|
||||
// Agent job counts.
|
||||
match store.agent_job_summary().await {
|
||||
// Agent job counts scoped to this user.
|
||||
match store.agent_job_summary_for_user(&user.user_id).await {
|
||||
Ok(s) => {
|
||||
total += s.total;
|
||||
pending += s.pending;
|
||||
@@ -474,6 +474,9 @@ pub async fn jobs_restart_handler(
|
||||
|
||||
// Try agent job restart: dispatch a new job via the scheduler.
|
||||
if let Ok(Some(old_job)) = store.get_job(old_job_id).await {
|
||||
if old_job.user_id != user.user_id {
|
||||
return Err((StatusCode::NOT_FOUND, "Job not found".to_string()));
|
||||
}
|
||||
if old_job.state.is_active() {
|
||||
return Err((
|
||||
StatusCode::CONFLICT,
|
||||
@@ -539,26 +542,6 @@ pub async fn jobs_prompt_handler(
|
||||
.parse()
|
||||
.map_err(|_| (StatusCode::BAD_REQUEST, "Invalid job ID".to_string()))?;
|
||||
|
||||
// Verify ownership before queuing a prompt.
|
||||
if let Some(ref store) = state.store {
|
||||
match store.get_sandbox_job(job_id).await {
|
||||
Ok(Some(job)) => {
|
||||
if job.user_id != user.user_id {
|
||||
return Err((StatusCode::NOT_FOUND, "Job not found".to_string()));
|
||||
}
|
||||
}
|
||||
Ok(None) => {
|
||||
return Err((StatusCode::NOT_FOUND, "Job not found".to_string()));
|
||||
}
|
||||
Err(e) => {
|
||||
return Err((
|
||||
StatusCode::INTERNAL_SERVER_ERROR,
|
||||
format!("Database error: {}", e),
|
||||
));
|
||||
}
|
||||
}
|
||||
}
|
||||
|
||||
let content = body
|
||||
.get("content")
|
||||
.and_then(|v| v.as_str())
|
||||
@@ -570,10 +553,15 @@ pub async fn jobs_prompt_handler(
|
||||
|
||||
let done = body.get("done").and_then(|v| v.as_bool()).unwrap_or(false);
|
||||
|
||||
// Try sandbox job path: check if we have a sandbox record for this ID.
|
||||
// Try sandbox job path first: verify ownership, then route to Claude Code or reject.
|
||||
if let Some(ref s) = state.store
|
||||
&& let Ok(Some(_)) = s.get_sandbox_job(job_id).await
|
||||
&& let Ok(Some(sandbox_job)) = s.get_sandbox_job(job_id).await
|
||||
{
|
||||
// Verify ownership.
|
||||
if sandbox_job.user_id != user.user_id {
|
||||
return Err((StatusCode::NOT_FOUND, "Job not found".to_string()));
|
||||
}
|
||||
|
||||
// It's a sandbox job. Check if Claude Code mode.
|
||||
let mode = s.get_sandbox_job_mode(job_id).await.ok().flatten();
|
||||
if mode.as_deref() == Some("claude_code") {
|
||||
@@ -598,7 +586,14 @@ pub async fn jobs_prompt_handler(
|
||||
}
|
||||
}
|
||||
|
||||
// Try agent job path: send via scheduler.
|
||||
// Try agent job path: verify ownership, then send via scheduler.
|
||||
if let Some(ref store) = state.store
|
||||
&& let Ok(Some(agent_job)) = store.get_job(job_id).await
|
||||
&& agent_job.user_id != user.user_id
|
||||
{
|
||||
return Err((StatusCode::NOT_FOUND, "Job not found".to_string()));
|
||||
}
|
||||
|
||||
let slot = state.scheduler.as_ref().ok_or((
|
||||
StatusCode::NOT_IMPLEMENTED,
|
||||
"Agent job prompts require the scheduler to be configured".to_string(),
|
||||
|
||||
@@ -1,154 +0,0 @@
|
||||
//! Memory/workspace API handlers.
|
||||
|
||||
use std::sync::Arc;
|
||||
|
||||
use axum::{
|
||||
Json,
|
||||
extract::{Query, State},
|
||||
http::StatusCode,
|
||||
};
|
||||
use serde::Deserialize;
|
||||
|
||||
use crate::channels::web::server::GatewayState;
|
||||
use crate::channels::web::types::*;
|
||||
|
||||
#[derive(Deserialize)]
|
||||
pub struct TreeQuery {
|
||||
#[allow(dead_code)]
|
||||
pub depth: Option<usize>,
|
||||
}
|
||||
|
||||
pub async fn memory_tree_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
Query(_query): Query<TreeQuery>,
|
||||
) -> Result<Json<MemoryTreeResponse>, (StatusCode, String)> {
|
||||
let workspace = state.workspace.as_ref().ok_or((
|
||||
StatusCode::SERVICE_UNAVAILABLE,
|
||||
"Workspace not available".to_string(),
|
||||
))?;
|
||||
|
||||
// Build tree from list_all (flat list of all paths)
|
||||
let all_paths = workspace
|
||||
.list_all()
|
||||
.await
|
||||
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
|
||||
|
||||
// Collect unique directories and files
|
||||
let mut entries: Vec<TreeEntry> = Vec::new();
|
||||
let mut seen_dirs: std::collections::HashSet<String> = std::collections::HashSet::new();
|
||||
|
||||
for path in &all_paths {
|
||||
// Add parent directories
|
||||
let parts: Vec<&str> = path.split('/').collect();
|
||||
for i in 0..parts.len().saturating_sub(1) {
|
||||
let dir_path = parts[..=i].join("/");
|
||||
if seen_dirs.insert(dir_path.clone()) {
|
||||
entries.push(TreeEntry {
|
||||
path: dir_path,
|
||||
is_dir: true,
|
||||
});
|
||||
}
|
||||
}
|
||||
// Add the file itself
|
||||
entries.push(TreeEntry {
|
||||
path: path.clone(),
|
||||
is_dir: false,
|
||||
});
|
||||
}
|
||||
|
||||
entries.sort_by(|a, b| a.path.cmp(&b.path));
|
||||
|
||||
Ok(Json(MemoryTreeResponse { entries }))
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
pub struct ListQuery {
|
||||
pub path: Option<String>,
|
||||
}
|
||||
|
||||
pub async fn memory_list_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
Query(query): Query<ListQuery>,
|
||||
) -> Result<Json<MemoryListResponse>, (StatusCode, String)> {
|
||||
let workspace = state.workspace.as_ref().ok_or((
|
||||
StatusCode::SERVICE_UNAVAILABLE,
|
||||
"Workspace not available".to_string(),
|
||||
))?;
|
||||
|
||||
let path = query.path.as_deref().unwrap_or("");
|
||||
let entries = workspace
|
||||
.list(path)
|
||||
.await
|
||||
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
|
||||
|
||||
let list_entries: Vec<ListEntry> = entries
|
||||
.iter()
|
||||
.map(|e| ListEntry {
|
||||
name: e.path.rsplit('/').next().unwrap_or(&e.path).to_string(),
|
||||
path: e.path.clone(),
|
||||
is_dir: e.is_directory,
|
||||
updated_at: e.updated_at.map(|dt| dt.to_rfc3339()),
|
||||
})
|
||||
.collect();
|
||||
|
||||
Ok(Json(MemoryListResponse {
|
||||
path: path.to_string(),
|
||||
entries: list_entries,
|
||||
}))
|
||||
}
|
||||
|
||||
#[derive(Deserialize)]
|
||||
pub struct ReadQuery {
|
||||
pub path: String,
|
||||
}
|
||||
|
||||
pub async fn memory_read_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
Query(query): Query<ReadQuery>,
|
||||
) -> Result<Json<MemoryReadResponse>, (StatusCode, String)> {
|
||||
let workspace = state.workspace.as_ref().ok_or((
|
||||
StatusCode::SERVICE_UNAVAILABLE,
|
||||
"Workspace not available".to_string(),
|
||||
))?;
|
||||
|
||||
let doc = workspace
|
||||
.read(&query.path)
|
||||
.await
|
||||
.map_err(|e| (StatusCode::NOT_FOUND, e.to_string()))?;
|
||||
|
||||
Ok(Json(MemoryReadResponse {
|
||||
path: query.path,
|
||||
content: doc.content,
|
||||
updated_at: Some(doc.updated_at.to_rfc3339()),
|
||||
}))
|
||||
}
|
||||
|
||||
// memory_write_handler lives in server.rs (layer-aware version with append,
|
||||
// privacy redirect, and proper error status codes).
|
||||
|
||||
pub async fn memory_search_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
Json(req): Json<MemorySearchRequest>,
|
||||
) -> Result<Json<MemorySearchResponse>, (StatusCode, String)> {
|
||||
let workspace = state.workspace.as_ref().ok_or((
|
||||
StatusCode::SERVICE_UNAVAILABLE,
|
||||
"Workspace not available".to_string(),
|
||||
))?;
|
||||
|
||||
let limit = req.limit.unwrap_or(10);
|
||||
let results = workspace
|
||||
.search(&req.query, limit)
|
||||
.await
|
||||
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
|
||||
|
||||
let hits: Vec<SearchHit> = results
|
||||
.into_iter()
|
||||
.map(|r| SearchHit {
|
||||
path: r.document_path,
|
||||
content: r.content,
|
||||
score: r.score as f64,
|
||||
})
|
||||
.collect();
|
||||
|
||||
Ok(Json(MemorySearchResponse { results: hits }))
|
||||
}
|
||||
@@ -1,14 +1,9 @@
|
||||
//! Handler modules for the web gateway API.
|
||||
//!
|
||||
//! Each module groups related endpoint handlers by domain.
|
||||
//!
|
||||
//! # Migration status
|
||||
//!
|
||||
//! `skills` is the canonical implementation used by `server.rs`.
|
||||
//! The remaining modules are in-progress migrations from inline server.rs
|
||||
//! handlers; their functions are not yet wired up, hence the `dead_code` allow.
|
||||
|
||||
pub mod jobs;
|
||||
pub mod routines;
|
||||
pub mod skills;
|
||||
|
||||
// Modules not yet wired into server.rs router -- suppress dead_code until
|
||||
@@ -18,10 +13,6 @@ pub mod chat;
|
||||
#[allow(dead_code)]
|
||||
pub mod extensions;
|
||||
#[allow(dead_code)]
|
||||
pub mod memory;
|
||||
#[allow(dead_code)]
|
||||
pub mod routines;
|
||||
#[allow(dead_code)]
|
||||
pub mod settings;
|
||||
#[allow(dead_code)]
|
||||
pub mod static_files;
|
||||
|
||||
@@ -11,12 +11,14 @@ use serde::Deserialize;
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::agent::routine::{Trigger, next_cron_fire};
|
||||
use crate::channels::web::auth::AuthenticatedUser;
|
||||
use crate::channels::web::server::GatewayState;
|
||||
use crate::channels::web::types::*;
|
||||
use crate::error::RoutineError;
|
||||
|
||||
pub async fn routines_list_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(user): AuthenticatedUser,
|
||||
) -> Result<Json<RoutineListResponse>, (StatusCode, String)> {
|
||||
let store = state.store.as_ref().ok_or((
|
||||
StatusCode::SERVICE_UNAVAILABLE,
|
||||
@@ -24,7 +26,7 @@ pub async fn routines_list_handler(
|
||||
))?;
|
||||
|
||||
let routines = store
|
||||
.list_all_routines()
|
||||
.list_routines(&user.user_id)
|
||||
.await
|
||||
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
|
||||
|
||||
@@ -35,6 +37,7 @@ pub async fn routines_list_handler(
|
||||
|
||||
pub async fn routines_summary_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(user): AuthenticatedUser,
|
||||
) -> Result<Json<RoutineSummaryResponse>, (StatusCode, String)> {
|
||||
let store = state.store.as_ref().ok_or((
|
||||
StatusCode::SERVICE_UNAVAILABLE,
|
||||
@@ -42,7 +45,7 @@ pub async fn routines_summary_handler(
|
||||
))?;
|
||||
|
||||
let routines = store
|
||||
.list_all_routines()
|
||||
.list_routines(&user.user_id)
|
||||
.await
|
||||
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?;
|
||||
|
||||
@@ -78,6 +81,7 @@ pub async fn routines_summary_handler(
|
||||
|
||||
pub async fn routines_detail_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(user): AuthenticatedUser,
|
||||
Path(id): Path<String>,
|
||||
) -> Result<Json<RoutineDetailResponse>, (StatusCode, String)> {
|
||||
let store = state.store.as_ref().ok_or((
|
||||
@@ -94,6 +98,10 @@ pub async fn routines_detail_handler(
|
||||
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?
|
||||
.ok_or((StatusCode::NOT_FOUND, "Routine not found".to_string()))?;
|
||||
|
||||
if routine.user_id != user.user_id {
|
||||
return Err((StatusCode::NOT_FOUND, "Routine not found".to_string()));
|
||||
}
|
||||
|
||||
let runs = store
|
||||
.list_routine_runs(routine_id, 20)
|
||||
.await
|
||||
@@ -137,7 +145,7 @@ pub async fn routines_detail_handler(
|
||||
|
||||
pub async fn routines_trigger_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
crate::channels::web::auth::AuthenticatedUser(user): crate::channels::web::auth::AuthenticatedUser,
|
||||
AuthenticatedUser(user): AuthenticatedUser,
|
||||
Path(id): Path<String>,
|
||||
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
|
||||
// Clone the Arc out of the lock to avoid holding the RwLock across .await.
|
||||
@@ -171,6 +179,7 @@ pub struct ToggleRequest {
|
||||
|
||||
pub async fn routines_toggle_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(user): AuthenticatedUser,
|
||||
Path(id): Path<String>,
|
||||
body: Option<Json<ToggleRequest>>,
|
||||
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
|
||||
@@ -188,6 +197,10 @@ pub async fn routines_toggle_handler(
|
||||
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?
|
||||
.ok_or((StatusCode::NOT_FOUND, "Routine not found".to_string()))?;
|
||||
|
||||
if routine.user_id != user.user_id {
|
||||
return Err((StatusCode::NOT_FOUND, "Routine not found".to_string()));
|
||||
}
|
||||
|
||||
let was_enabled = routine.enabled;
|
||||
// If a specific value was provided, use it; otherwise toggle.
|
||||
routine.enabled = match body {
|
||||
@@ -231,6 +244,7 @@ pub async fn routines_toggle_handler(
|
||||
|
||||
pub async fn routines_delete_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(user): AuthenticatedUser,
|
||||
Path(id): Path<String>,
|
||||
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
|
||||
let store = state.store.as_ref().ok_or((
|
||||
@@ -241,6 +255,17 @@ pub async fn routines_delete_handler(
|
||||
let routine_id = Uuid::parse_str(&id)
|
||||
.map_err(|_| (StatusCode::BAD_REQUEST, "Invalid routine ID".to_string()))?;
|
||||
|
||||
// Verify ownership before deleting.
|
||||
let routine = store
|
||||
.get_routine(routine_id)
|
||||
.await
|
||||
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?
|
||||
.ok_or((StatusCode::NOT_FOUND, "Routine not found".to_string()))?;
|
||||
|
||||
if routine.user_id != user.user_id {
|
||||
return Err((StatusCode::NOT_FOUND, "Routine not found".to_string()));
|
||||
}
|
||||
|
||||
let deleted = store
|
||||
.delete_routine(routine_id)
|
||||
.await
|
||||
@@ -262,8 +287,10 @@ pub async fn routines_delete_handler(
|
||||
}
|
||||
}
|
||||
|
||||
#[allow(dead_code)] // Used by server.rs inline version; kept in sync here for future migration.
|
||||
pub async fn routines_runs_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(user): AuthenticatedUser,
|
||||
Path(id): Path<String>,
|
||||
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
|
||||
let store = state.store.as_ref().ok_or((
|
||||
@@ -274,6 +301,17 @@ pub async fn routines_runs_handler(
|
||||
let routine_id = Uuid::parse_str(&id)
|
||||
.map_err(|_| (StatusCode::BAD_REQUEST, "Invalid routine ID".to_string()))?;
|
||||
|
||||
// Verify ownership before listing runs.
|
||||
let routine = store
|
||||
.get_routine(routine_id)
|
||||
.await
|
||||
.map_err(|e| (StatusCode::INTERNAL_SERVER_ERROR, e.to_string()))?
|
||||
.ok_or((StatusCode::NOT_FOUND, "Routine not found".to_string()))?;
|
||||
|
||||
if routine.user_id != user.user_id {
|
||||
return Err((StatusCode::NOT_FOUND, "Routine not found".to_string()));
|
||||
}
|
||||
|
||||
let runs = store
|
||||
.list_routine_runs(routine_id, 50)
|
||||
.await
|
||||
|
||||
@@ -8,11 +8,13 @@ use axum::{
|
||||
http::StatusCode,
|
||||
};
|
||||
|
||||
use crate::channels::web::auth::AuthenticatedUser;
|
||||
use crate::channels::web::server::GatewayState;
|
||||
use crate::channels::web::types::*;
|
||||
|
||||
pub async fn skills_list_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(_user): AuthenticatedUser,
|
||||
) -> Result<Json<SkillListResponse>, (StatusCode, String)> {
|
||||
let registry = state.skill_registry.as_ref().ok_or((
|
||||
StatusCode::NOT_IMPLEMENTED,
|
||||
@@ -45,6 +47,7 @@ pub async fn skills_list_handler(
|
||||
|
||||
pub async fn skills_search_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(_user): AuthenticatedUser,
|
||||
Json(req): Json<SkillSearchRequest>,
|
||||
) -> Result<Json<SkillSearchResponse>, (StatusCode, String)> {
|
||||
let registry = state.skill_registry.as_ref().ok_or((
|
||||
@@ -119,6 +122,7 @@ pub async fn skills_search_handler(
|
||||
|
||||
pub async fn skills_install_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(user): AuthenticatedUser,
|
||||
headers: axum::http::HeaderMap,
|
||||
Json(req): Json<SkillInstallRequest>,
|
||||
) -> Result<Json<ActionResponse>, (StatusCode, String)> {
|
||||
@@ -135,6 +139,8 @@ pub async fn skills_install_handler(
|
||||
));
|
||||
}
|
||||
|
||||
tracing::info!(user_id = %user.user_id, skill = %req.name, "skill install requested");
|
||||
|
||||
let registry = state.skill_registry.as_ref().ok_or((
|
||||
StatusCode::NOT_IMPLEMENTED,
|
||||
"Skills system not enabled".to_string(),
|
||||
@@ -219,6 +225,7 @@ pub async fn skills_install_handler(
|
||||
|
||||
pub async fn skills_remove_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(user): AuthenticatedUser,
|
||||
headers: axum::http::HeaderMap,
|
||||
Path(name): Path<String>,
|
||||
) -> Result<Json<ActionResponse>, (StatusCode, String)> {
|
||||
@@ -234,6 +241,8 @@ pub async fn skills_remove_handler(
|
||||
));
|
||||
}
|
||||
|
||||
tracing::info!(user_id = %user.user_id, skill = %name, "skill remove requested");
|
||||
|
||||
let registry = state.skill_registry.as_ref().ok_or((
|
||||
StatusCode::NOT_IMPLEMENTED,
|
||||
"Skills system not enabled".to_string(),
|
||||
|
||||
@@ -31,6 +31,9 @@ pub mod ws;
|
||||
/// [`TestGatewayBuilder`](test_helpers::TestGatewayBuilder).
|
||||
pub mod test_helpers;
|
||||
|
||||
#[cfg(test)]
|
||||
mod tests;
|
||||
|
||||
use std::net::SocketAddr;
|
||||
use std::sync::Arc;
|
||||
|
||||
|
||||
@@ -206,10 +206,14 @@ impl PerUserRateLimiter {
|
||||
/// Per-user workspace pool: lazily creates and caches workspaces keyed by user_id.
|
||||
///
|
||||
/// In single-user mode, exactly one workspace is cached. In multi-user mode,
|
||||
/// each authenticated user gets their own workspace with appropriate scopes.
|
||||
/// each authenticated user gets their own workspace with appropriate scopes,
|
||||
/// search config, memory layers, and embedding cache settings.
|
||||
pub struct WorkspacePool {
|
||||
db: Arc<dyn Database>,
|
||||
embeddings: Option<Arc<dyn crate::workspace::EmbeddingProvider>>,
|
||||
embedding_cache_config: crate::workspace::EmbeddingCacheConfig,
|
||||
search_config: crate::config::WorkspaceSearchConfig,
|
||||
workspace_config: crate::config::WorkspaceConfig,
|
||||
cache: tokio::sync::RwLock<std::collections::HashMap<String, Arc<Workspace>>>,
|
||||
}
|
||||
|
||||
@@ -217,15 +221,24 @@ impl WorkspacePool {
|
||||
pub fn new(
|
||||
db: Arc<dyn Database>,
|
||||
embeddings: Option<Arc<dyn crate::workspace::EmbeddingProvider>>,
|
||||
embedding_cache_config: crate::workspace::EmbeddingCacheConfig,
|
||||
search_config: crate::config::WorkspaceSearchConfig,
|
||||
workspace_config: crate::config::WorkspaceConfig,
|
||||
) -> Self {
|
||||
Self {
|
||||
db,
|
||||
embeddings,
|
||||
embedding_cache_config,
|
||||
search_config,
|
||||
workspace_config,
|
||||
cache: tokio::sync::RwLock::new(std::collections::HashMap::new()),
|
||||
}
|
||||
}
|
||||
|
||||
/// Get or create a workspace for the given user identity.
|
||||
///
|
||||
/// Applies search config, memory layers, embedding cache, and read scopes
|
||||
/// (both from global config and from the token's `workspace_read_scopes`).
|
||||
pub async fn get_or_create(&self, identity: &UserIdentity) -> Arc<Workspace> {
|
||||
// Fast path: check read lock
|
||||
{
|
||||
@@ -242,11 +255,25 @@ impl WorkspacePool {
|
||||
return Arc::clone(ws);
|
||||
}
|
||||
|
||||
let mut ws = Workspace::new_with_db(&identity.user_id, Arc::clone(&self.db));
|
||||
let mut ws = Workspace::new_with_db(&identity.user_id, Arc::clone(&self.db))
|
||||
.with_search_config(&self.search_config);
|
||||
|
||||
if let Some(ref emb) = self.embeddings {
|
||||
ws = ws.with_embeddings(Arc::clone(emb));
|
||||
ws = ws.with_embeddings_cached(Arc::clone(emb), self.embedding_cache_config.clone());
|
||||
}
|
||||
|
||||
// Apply global read scopes from config.
|
||||
if !self.workspace_config.read_scopes.is_empty() {
|
||||
ws = ws.with_additional_read_scopes(self.workspace_config.read_scopes.clone());
|
||||
}
|
||||
|
||||
// Apply per-token read scopes from identity.
|
||||
if !identity.workspace_read_scopes.is_empty() {
|
||||
ws = ws.with_additional_read_scopes(identity.workspace_read_scopes.clone());
|
||||
}
|
||||
|
||||
ws = ws.with_memory_layers(self.workspace_config.memory_layers.clone());
|
||||
|
||||
let ws = Arc::new(ws);
|
||||
cache.insert(identity.user_id.clone(), Arc::clone(&ws));
|
||||
ws
|
||||
@@ -2071,6 +2098,7 @@ async fn memory_search_handler(
|
||||
|
||||
async fn logs_events_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(_user): AuthenticatedUser,
|
||||
) -> Result<impl IntoResponse, (StatusCode, String)> {
|
||||
let broadcaster = state.log_broadcaster.as_ref().ok_or((
|
||||
StatusCode::SERVICE_UNAVAILABLE,
|
||||
@@ -2108,6 +2136,7 @@ async fn logs_events_handler(
|
||||
|
||||
async fn logs_level_get_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(_user): AuthenticatedUser,
|
||||
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
|
||||
let handle = state.log_level_handle.as_ref().ok_or((
|
||||
StatusCode::SERVICE_UNAVAILABLE,
|
||||
@@ -2118,6 +2147,7 @@ async fn logs_level_get_handler(
|
||||
|
||||
async fn logs_level_set_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(user): AuthenticatedUser,
|
||||
Json(body): Json<serde_json::Value>,
|
||||
) -> Result<Json<serde_json::Value>, (StatusCode, String)> {
|
||||
let handle = state.log_level_handle.as_ref().ok_or((
|
||||
@@ -2134,7 +2164,7 @@ async fn logs_level_set_handler(
|
||||
.set_level(level)
|
||||
.map_err(|e| (StatusCode::BAD_REQUEST, e))?;
|
||||
|
||||
tracing::info!("Log level changed to '{}'", handle.current_level());
|
||||
tracing::info!(user_id = %user.user_id, "Log level changed to '{}'", handle.current_level());
|
||||
Ok(Json(serde_json::json!({ "level": handle.current_level() })))
|
||||
}
|
||||
|
||||
@@ -2210,6 +2240,7 @@ async fn extensions_list_handler(
|
||||
|
||||
async fn extensions_tools_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(_user): AuthenticatedUser,
|
||||
) -> Result<Json<ToolListResponse>, (StatusCode, String)> {
|
||||
let registry = state.tool_registry.as_ref().ok_or((
|
||||
StatusCode::SERVICE_UNAVAILABLE,
|
||||
@@ -2604,7 +2635,7 @@ async fn extensions_setup_submit_handler(
|
||||
if result.verification.is_none() {
|
||||
// Broadcast auth_completed so the chat UI can dismiss any in-progress
|
||||
// auth card or setup modal that was triggered by tool_auth/tool_activate.
|
||||
state.sse.broadcast(SseEvent::AuthCompleted {
|
||||
state.sse.broadcast_for_user(&user.user_id, SseEvent::AuthCompleted {
|
||||
extension_name: name.clone(),
|
||||
success: result.activated,
|
||||
message: resp.message.clone(),
|
||||
@@ -2845,6 +2876,7 @@ async fn settings_import_handler(
|
||||
|
||||
async fn gateway_status_handler(
|
||||
State(state): State<Arc<GatewayState>>,
|
||||
AuthenticatedUser(_user): AuthenticatedUser,
|
||||
) -> Json<GatewayStatusResponse> {
|
||||
let sse_connections = state.sse.connection_count();
|
||||
let ws_connections = state
|
||||
|
||||
@@ -0,0 +1,3 @@
|
||||
//! Integration tests for the web gateway module.
|
||||
|
||||
mod multi_tenant;
|
||||
@@ -0,0 +1,798 @@
|
||||
//! Multi-tenant isolation tests for the web gateway.
|
||||
//!
|
||||
//! Tests cover workspace pool scoping, job handler isolation, and auth
|
||||
//! enforcement on protected endpoints. Uses `LibSqlBackend::new_local()`
|
||||
//! with a temporary directory for a real (but ephemeral) database.
|
||||
|
||||
use std::collections::HashMap;
|
||||
use std::sync::Arc;
|
||||
use std::time::Duration;
|
||||
|
||||
use axum::body::Body;
|
||||
use axum::http::{Method, Request, StatusCode};
|
||||
use axum::middleware;
|
||||
use axum::routing::{delete, get, post};
|
||||
use axum::Router;
|
||||
use tower::ServiceExt;
|
||||
use uuid::Uuid;
|
||||
|
||||
use crate::channels::web::auth::{auth_middleware, AuthenticatedUser, MultiAuthState, UserIdentity};
|
||||
use crate::channels::web::server::{
|
||||
ActiveConfigSnapshot, GatewayState, PerUserRateLimiter, PromptQueue, RateLimiter,
|
||||
WorkspacePool,
|
||||
};
|
||||
use crate::channels::web::sse::SseManager;
|
||||
|
||||
// ── Helpers ────────────────────────────────────────────────────────────
|
||||
|
||||
/// Create a two-user `MultiAuthState` for alice and bob.
|
||||
fn two_user_auth() -> MultiAuthState {
|
||||
let mut tokens = HashMap::new();
|
||||
tokens.insert(
|
||||
"tok-alice".to_string(),
|
||||
UserIdentity {
|
||||
user_id: "alice".to_string(),
|
||||
workspace_read_scopes: vec!["shared".to_string()],
|
||||
},
|
||||
);
|
||||
tokens.insert(
|
||||
"tok-bob".to_string(),
|
||||
UserIdentity {
|
||||
user_id: "bob".to_string(),
|
||||
workspace_read_scopes: vec!["shared".to_string(), "alice".to_string()],
|
||||
},
|
||||
);
|
||||
MultiAuthState::multi(tokens)
|
||||
}
|
||||
|
||||
/// Build a `GatewayState` with configurable store and prompt queue.
|
||||
fn build_state(
|
||||
store: Option<Arc<dyn crate::db::Database>>,
|
||||
prompt_queue: Option<PromptQueue>,
|
||||
) -> Arc<GatewayState> {
|
||||
Arc::new(GatewayState {
|
||||
msg_tx: tokio::sync::RwLock::new(None),
|
||||
sse: Arc::new(SseManager::new()),
|
||||
workspace: None,
|
||||
workspace_pool: None,
|
||||
session_manager: None,
|
||||
log_broadcaster: None,
|
||||
log_level_handle: None,
|
||||
extension_manager: None,
|
||||
tool_registry: None,
|
||||
store,
|
||||
job_manager: None,
|
||||
prompt_queue,
|
||||
default_user_id: "test".to_string(),
|
||||
shutdown_tx: tokio::sync::RwLock::new(None),
|
||||
ws_tracker: None,
|
||||
llm_provider: None,
|
||||
skill_registry: None,
|
||||
skill_catalog: None,
|
||||
scheduler: None,
|
||||
chat_rate_limiter: PerUserRateLimiter::new(30, 60),
|
||||
oauth_rate_limiter: RateLimiter::new(10, 60),
|
||||
webhook_rate_limiter: RateLimiter::new(10, 60),
|
||||
registry_entries: Vec::new(),
|
||||
cost_guard: None,
|
||||
routine_engine: Arc::new(tokio::sync::RwLock::new(None)),
|
||||
startup_time: std::time::Instant::now(),
|
||||
active_config: ActiveConfigSnapshot::default(),
|
||||
})
|
||||
}
|
||||
|
||||
/// Create a libSQL-backed test database in a temporary directory.
|
||||
///
|
||||
/// Returns the database and a `TempDir` guard — the database file is
|
||||
/// deleted when the guard is dropped.
|
||||
#[cfg(feature = "libsql")]
|
||||
async fn test_db() -> (Arc<dyn crate::db::Database>, tempfile::TempDir) {
|
||||
use crate::db::Database;
|
||||
let dir = tempfile::tempdir().expect("failed to create temp dir");
|
||||
let path = dir.path().join("test.db");
|
||||
let backend = crate::db::libsql::LibSqlBackend::new_local(&path)
|
||||
.await
|
||||
.expect("failed to create test LibSqlBackend");
|
||||
backend
|
||||
.run_migrations()
|
||||
.await
|
||||
.expect("failed to run migrations");
|
||||
(
|
||||
Arc::new(backend) as Arc<dyn crate::db::Database>,
|
||||
dir,
|
||||
)
|
||||
}
|
||||
|
||||
/// Build a minimal Routine for testing.
|
||||
fn make_routine(user_id: &str, name: &str) -> crate::agent::routine::Routine {
|
||||
let now = chrono::Utc::now();
|
||||
crate::agent::routine::Routine {
|
||||
id: Uuid::new_v4(),
|
||||
name: name.to_string(),
|
||||
description: format!("Test routine: {name}"),
|
||||
user_id: user_id.to_string(),
|
||||
enabled: true,
|
||||
trigger: crate::agent::routine::Trigger::Cron {
|
||||
schedule: "0 9 * * *".to_string(),
|
||||
timezone: None,
|
||||
},
|
||||
action: crate::agent::routine::RoutineAction::Lightweight {
|
||||
prompt: "hello".to_string(),
|
||||
context_paths: vec![],
|
||||
max_tokens: 1024,
|
||||
use_tools: false,
|
||||
max_tool_rounds: 3,
|
||||
},
|
||||
guardrails: crate::agent::routine::RoutineGuardrails {
|
||||
cooldown: Duration::from_secs(60),
|
||||
max_concurrent: 1,
|
||||
dedup_window: None,
|
||||
},
|
||||
notify: crate::agent::routine::NotifyConfig {
|
||||
channel: None,
|
||||
user: None,
|
||||
on_success: false,
|
||||
on_failure: true,
|
||||
on_attention: true,
|
||||
},
|
||||
last_run_at: None,
|
||||
next_fire_at: None,
|
||||
run_count: 0,
|
||||
consecutive_failures: 0,
|
||||
state: serde_json::json!({}),
|
||||
created_at: now,
|
||||
updated_at: now,
|
||||
}
|
||||
}
|
||||
|
||||
/// Build a minimal SandboxJobRecord for testing.
|
||||
fn make_sandbox_job(user_id: &str, task: &str) -> crate::history::SandboxJobRecord {
|
||||
let now = chrono::Utc::now();
|
||||
crate::history::SandboxJobRecord {
|
||||
id: Uuid::new_v4(),
|
||||
task: task.to_string(),
|
||||
status: "completed".to_string(),
|
||||
user_id: user_id.to_string(),
|
||||
project_dir: format!("/tmp/test-{}", Uuid::new_v4()),
|
||||
success: Some(true),
|
||||
failure_reason: None,
|
||||
created_at: now,
|
||||
started_at: Some(now),
|
||||
completed_at: Some(now),
|
||||
credential_grants_json: "[]".to_string(),
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
// WorkspacePool Tests
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
|
||||
#[cfg(feature = "libsql")]
|
||||
mod workspace_pool {
|
||||
use super::*;
|
||||
use crate::config::{WorkspaceConfig, WorkspaceSearchConfig};
|
||||
use crate::workspace::EmbeddingCacheConfig;
|
||||
use crate::workspace::layer::MemoryLayer;
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_workspace_pool_applies_search_config() {
|
||||
let (db, _dir) = test_db().await;
|
||||
let search_config = WorkspaceSearchConfig {
|
||||
rrf_k: 42,
|
||||
..Default::default()
|
||||
};
|
||||
let pool = WorkspacePool::new(
|
||||
db,
|
||||
None,
|
||||
EmbeddingCacheConfig::default(),
|
||||
search_config,
|
||||
WorkspaceConfig::default(),
|
||||
);
|
||||
let identity = UserIdentity {
|
||||
user_id: "alice".to_string(),
|
||||
workspace_read_scopes: vec![],
|
||||
};
|
||||
let ws = pool.get_or_create(&identity).await;
|
||||
assert_eq!(ws.user_id(), "alice");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_workspace_pool_applies_memory_layers() {
|
||||
let (db, _dir) = test_db().await;
|
||||
let layers = vec![MemoryLayer {
|
||||
name: "shared-layer".to_string(),
|
||||
scope: "shared".to_string(),
|
||||
writable: false,
|
||||
sensitivity: Default::default(),
|
||||
}];
|
||||
let ws_config = WorkspaceConfig {
|
||||
memory_layers: layers,
|
||||
read_scopes: vec![],
|
||||
};
|
||||
let pool = WorkspacePool::new(
|
||||
db,
|
||||
None,
|
||||
EmbeddingCacheConfig::default(),
|
||||
WorkspaceSearchConfig::default(),
|
||||
ws_config,
|
||||
);
|
||||
let identity = UserIdentity {
|
||||
user_id: "alice".to_string(),
|
||||
workspace_read_scopes: vec![],
|
||||
};
|
||||
let ws = pool.get_or_create(&identity).await;
|
||||
// Memory layer scope "shared" should appear in read_user_ids.
|
||||
assert!(
|
||||
ws.read_user_ids().contains(&"shared".to_string()),
|
||||
"expected 'shared' in read_user_ids, got {:?}",
|
||||
ws.read_user_ids()
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_workspace_pool_applies_identity_read_scopes() {
|
||||
let (db, _dir) = test_db().await;
|
||||
let pool = WorkspacePool::new(
|
||||
db,
|
||||
None,
|
||||
EmbeddingCacheConfig::default(),
|
||||
WorkspaceSearchConfig::default(),
|
||||
WorkspaceConfig::default(),
|
||||
);
|
||||
let identity = UserIdentity {
|
||||
user_id: "bob".to_string(),
|
||||
workspace_read_scopes: vec!["alice".to_string(), "shared".to_string()],
|
||||
};
|
||||
let ws = pool.get_or_create(&identity).await;
|
||||
assert_eq!(ws.user_id(), "bob");
|
||||
assert!(
|
||||
ws.read_user_ids().contains(&"alice".to_string()),
|
||||
"expected 'alice' in read_user_ids from identity scopes"
|
||||
);
|
||||
assert!(
|
||||
ws.read_user_ids().contains(&"shared".to_string()),
|
||||
"expected 'shared' in read_user_ids from identity scopes"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_workspace_pool_caches_per_user() {
|
||||
let (db, _dir) = test_db().await;
|
||||
let pool = WorkspacePool::new(
|
||||
db,
|
||||
None,
|
||||
EmbeddingCacheConfig::default(),
|
||||
WorkspaceSearchConfig::default(),
|
||||
WorkspaceConfig::default(),
|
||||
);
|
||||
let alice_id = UserIdentity {
|
||||
user_id: "alice".to_string(),
|
||||
workspace_read_scopes: vec![],
|
||||
};
|
||||
let bob_id = UserIdentity {
|
||||
user_id: "bob".to_string(),
|
||||
workspace_read_scopes: vec![],
|
||||
};
|
||||
|
||||
let alice_ws1 = pool.get_or_create(&alice_id).await;
|
||||
let alice_ws2 = pool.get_or_create(&alice_id).await;
|
||||
let bob_ws = pool.get_or_create(&bob_id).await;
|
||||
|
||||
// Same user gets the same Arc.
|
||||
assert!(Arc::ptr_eq(&alice_ws1, &alice_ws2));
|
||||
// Different users get different instances.
|
||||
assert!(!Arc::ptr_eq(&alice_ws1, &bob_ws));
|
||||
assert_eq!(alice_ws1.user_id(), "alice");
|
||||
assert_eq!(bob_ws.user_id(), "bob");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_workspace_pool_combines_global_and_identity_scopes() {
|
||||
let (db, _dir) = test_db().await;
|
||||
let ws_config = WorkspaceConfig {
|
||||
memory_layers: vec![],
|
||||
read_scopes: vec!["global-shared".to_string()],
|
||||
};
|
||||
let pool = WorkspacePool::new(
|
||||
db,
|
||||
None,
|
||||
EmbeddingCacheConfig::default(),
|
||||
WorkspaceSearchConfig::default(),
|
||||
ws_config,
|
||||
);
|
||||
let identity = UserIdentity {
|
||||
user_id: "alice".to_string(),
|
||||
workspace_read_scopes: vec!["token-scope".to_string()],
|
||||
};
|
||||
let ws = pool.get_or_create(&identity).await;
|
||||
let scopes = ws.read_user_ids();
|
||||
// Primary scope
|
||||
assert!(scopes.contains(&"alice".to_string()));
|
||||
// Global config scope
|
||||
assert!(
|
||||
scopes.contains(&"global-shared".to_string()),
|
||||
"expected global scope 'global-shared', got {:?}",
|
||||
scopes
|
||||
);
|
||||
// Token identity scope
|
||||
assert!(
|
||||
scopes.contains(&"token-scope".to_string()),
|
||||
"expected token scope 'token-scope', got {:?}",
|
||||
scopes
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
// Jobs Handler Isolation Tests
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
|
||||
#[cfg(feature = "libsql")]
|
||||
mod jobs_isolation {
|
||||
use super::*;
|
||||
use crate::channels::web::handlers::jobs::{
|
||||
jobs_cancel_handler, jobs_prompt_handler, jobs_restart_handler, jobs_summary_handler,
|
||||
};
|
||||
// SandboxStore methods are accessed through the Database supertrait.
|
||||
|
||||
/// Build a router with job endpoints behind multi-user auth.
|
||||
fn jobs_router(state: Arc<GatewayState>, auth: MultiAuthState) -> Router {
|
||||
Router::new()
|
||||
.route("/api/jobs/summary", get(jobs_summary_handler))
|
||||
.route("/api/jobs/{id}/cancel", post(jobs_cancel_handler))
|
||||
.route("/api/jobs/{id}/restart", post(jobs_restart_handler))
|
||||
.route("/api/jobs/{id}/prompt", post(jobs_prompt_handler))
|
||||
.layer(middleware::from_fn_with_state(auth, auth_middleware))
|
||||
.with_state(state)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_jobs_summary_scoped_to_user() {
|
||||
let (db, _dir) = test_db().await;
|
||||
|
||||
// Insert sandbox jobs for alice and bob.
|
||||
let alice_job = make_sandbox_job("alice", "alice task");
|
||||
let bob_job = make_sandbox_job("bob", "bob task");
|
||||
db.save_sandbox_job(&alice_job).await.unwrap();
|
||||
db.save_sandbox_job(&bob_job).await.unwrap();
|
||||
|
||||
let state = build_state(Some(db), None);
|
||||
let auth = two_user_auth();
|
||||
let app = jobs_router(state, auth);
|
||||
|
||||
// Alice should see 1 job.
|
||||
let req = Request::builder()
|
||||
.uri("/api/jobs/summary")
|
||||
.header("Authorization", "Bearer tok-alice")
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let resp = app.clone().oneshot(req).await.unwrap();
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
let body: serde_json::Value =
|
||||
serde_json::from_slice(&axum::body::to_bytes(resp.into_body(), 4096).await.unwrap())
|
||||
.unwrap();
|
||||
assert_eq!(body["total"], 1, "alice should see only her own jobs");
|
||||
|
||||
// Bob should see 1 job.
|
||||
let req = Request::builder()
|
||||
.uri("/api/jobs/summary")
|
||||
.header("Authorization", "Bearer tok-bob")
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let resp = app.oneshot(req).await.unwrap();
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
let body: serde_json::Value =
|
||||
serde_json::from_slice(&axum::body::to_bytes(resp.into_body(), 4096).await.unwrap())
|
||||
.unwrap();
|
||||
assert_eq!(body["total"], 1, "bob should see only his own jobs");
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_jobs_restart_rejects_other_user() {
|
||||
let (db, _dir) = test_db().await;
|
||||
|
||||
// Insert a failed sandbox job owned by alice.
|
||||
let mut alice_job = make_sandbox_job("alice", "alice task");
|
||||
alice_job.status = "failed".to_string();
|
||||
alice_job.success = Some(false);
|
||||
db.save_sandbox_job(&alice_job).await.unwrap();
|
||||
|
||||
let state = build_state(Some(db), None);
|
||||
let auth = two_user_auth();
|
||||
let app = jobs_router(state, auth);
|
||||
|
||||
// Bob tries to restart alice's job.
|
||||
let req = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri(format!("/api/jobs/{}/restart", alice_job.id))
|
||||
.header("Authorization", "Bearer tok-bob")
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let resp = app.oneshot(req).await.unwrap();
|
||||
assert_eq!(
|
||||
resp.status(),
|
||||
StatusCode::NOT_FOUND,
|
||||
"bob should not be able to restart alice's job"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_jobs_prompt_works_for_agent_jobs() {
|
||||
let (db, _dir) = test_db().await;
|
||||
|
||||
// Insert a running sandbox job owned by alice in claude_code mode.
|
||||
let mut alice_job = make_sandbox_job("alice", "prompt test");
|
||||
alice_job.status = "running".to_string();
|
||||
alice_job.success = None;
|
||||
alice_job.completed_at = None;
|
||||
db.save_sandbox_job(&alice_job).await.unwrap();
|
||||
db.update_sandbox_job_mode(alice_job.id, "claude_code")
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let prompt_queue: PromptQueue =
|
||||
Arc::new(tokio::sync::Mutex::new(std::collections::HashMap::new()));
|
||||
let state = build_state(Some(db), Some(prompt_queue.clone()));
|
||||
let auth = two_user_auth();
|
||||
let app = jobs_router(state, auth);
|
||||
|
||||
// Alice prompts her own job.
|
||||
let req = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri(format!("/api/jobs/{}/prompt", alice_job.id))
|
||||
.header("Authorization", "Bearer tok-alice")
|
||||
.header("Content-Type", "application/json")
|
||||
.body(Body::from(
|
||||
serde_json::to_string(&serde_json::json!({"content": "hello"})).unwrap(),
|
||||
))
|
||||
.unwrap();
|
||||
let resp = app.oneshot(req).await.unwrap();
|
||||
assert_eq!(
|
||||
resp.status(),
|
||||
StatusCode::OK,
|
||||
"alice should be able to prompt her own job"
|
||||
);
|
||||
|
||||
// Verify prompt was enqueued.
|
||||
let queue = prompt_queue.lock().await;
|
||||
assert!(
|
||||
queue.contains_key(&alice_job.id),
|
||||
"prompt queue should contain alice's job"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_jobs_prompt_rejects_other_user() {
|
||||
let (db, _dir) = test_db().await;
|
||||
|
||||
let mut alice_job = make_sandbox_job("alice", "alice task");
|
||||
alice_job.status = "running".to_string();
|
||||
alice_job.success = None;
|
||||
alice_job.completed_at = None;
|
||||
db.save_sandbox_job(&alice_job).await.unwrap();
|
||||
db.update_sandbox_job_mode(alice_job.id, "claude_code")
|
||||
.await
|
||||
.unwrap();
|
||||
|
||||
let prompt_queue: PromptQueue =
|
||||
Arc::new(tokio::sync::Mutex::new(std::collections::HashMap::new()));
|
||||
let state = build_state(Some(db), Some(prompt_queue));
|
||||
let auth = two_user_auth();
|
||||
let app = jobs_router(state, auth);
|
||||
|
||||
// Bob tries to prompt alice's job.
|
||||
let req = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri(format!("/api/jobs/{}/prompt", alice_job.id))
|
||||
.header("Authorization", "Bearer tok-bob")
|
||||
.header("Content-Type", "application/json")
|
||||
.body(Body::from(
|
||||
serde_json::to_string(&serde_json::json!({"content": "sneaky"})).unwrap(),
|
||||
))
|
||||
.unwrap();
|
||||
let resp = app.oneshot(req).await.unwrap();
|
||||
assert_eq!(
|
||||
resp.status(),
|
||||
StatusCode::NOT_FOUND,
|
||||
"bob should not be able to prompt alice's job"
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_jobs_cancel_rejects_other_user() {
|
||||
let (db, _dir) = test_db().await;
|
||||
|
||||
let mut alice_job = make_sandbox_job("alice", "alice running");
|
||||
alice_job.status = "running".to_string();
|
||||
alice_job.success = None;
|
||||
alice_job.completed_at = None;
|
||||
db.save_sandbox_job(&alice_job).await.unwrap();
|
||||
|
||||
let state = build_state(Some(db), None);
|
||||
let auth = two_user_auth();
|
||||
let app = jobs_router(state, auth);
|
||||
|
||||
// Bob tries to cancel alice's job.
|
||||
let req = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri(format!("/api/jobs/{}/cancel", alice_job.id))
|
||||
.header("Authorization", "Bearer tok-bob")
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let resp = app.oneshot(req).await.unwrap();
|
||||
assert_eq!(
|
||||
resp.status(),
|
||||
StatusCode::NOT_FOUND,
|
||||
"bob should not be able to cancel alice's job"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
// Routines Isolation Tests
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
|
||||
#[cfg(feature = "libsql")]
|
||||
mod routines_isolation {
|
||||
use super::*;
|
||||
use crate::channels::web::handlers::routines::{
|
||||
routines_delete_handler, routines_detail_handler, routines_list_handler,
|
||||
routines_summary_handler, routines_toggle_handler,
|
||||
};
|
||||
// RoutineStore methods are accessed through the Database supertrait.
|
||||
|
||||
fn routines_router(state: Arc<GatewayState>, auth: MultiAuthState) -> Router {
|
||||
Router::new()
|
||||
.route("/api/routines", get(routines_list_handler))
|
||||
.route("/api/routines/summary", get(routines_summary_handler))
|
||||
.route("/api/routines/{id}", get(routines_detail_handler))
|
||||
.route("/api/routines/{id}/toggle", post(routines_toggle_handler))
|
||||
.route("/api/routines/{id}", delete(routines_delete_handler))
|
||||
.layer(middleware::from_fn_with_state(auth, auth_middleware))
|
||||
.with_state(state)
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_routines_isolation() {
|
||||
let (db, _dir) = test_db().await;
|
||||
|
||||
// Create routines for alice and bob.
|
||||
let alice_routine = make_routine("alice", "alice-daily");
|
||||
let bob_routine = make_routine("bob", "bob-daily");
|
||||
db.create_routine(&alice_routine).await.unwrap();
|
||||
db.create_routine(&bob_routine).await.unwrap();
|
||||
|
||||
let state = build_state(Some(db), None);
|
||||
let auth = two_user_auth();
|
||||
let app = routines_router(state, auth);
|
||||
|
||||
// Alice sees only her routine in the list.
|
||||
let req = Request::builder()
|
||||
.uri("/api/routines")
|
||||
.header("Authorization", "Bearer tok-alice")
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let resp = app.clone().oneshot(req).await.unwrap();
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
let body: serde_json::Value =
|
||||
serde_json::from_slice(&axum::body::to_bytes(resp.into_body(), 8192).await.unwrap())
|
||||
.unwrap();
|
||||
let routines = body["routines"].as_array().unwrap();
|
||||
assert_eq!(routines.len(), 1, "alice should see only her routines");
|
||||
assert_eq!(routines[0]["name"], "alice-daily");
|
||||
|
||||
// Bob sees only his routine.
|
||||
let req = Request::builder()
|
||||
.uri("/api/routines")
|
||||
.header("Authorization", "Bearer tok-bob")
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let resp = app.clone().oneshot(req).await.unwrap();
|
||||
assert_eq!(resp.status(), StatusCode::OK);
|
||||
let body: serde_json::Value =
|
||||
serde_json::from_slice(&axum::body::to_bytes(resp.into_body(), 8192).await.unwrap())
|
||||
.unwrap();
|
||||
let routines = body["routines"].as_array().unwrap();
|
||||
assert_eq!(routines.len(), 1, "bob should see only his routines");
|
||||
assert_eq!(routines[0]["name"], "bob-daily");
|
||||
|
||||
// Bob cannot view alice's routine detail.
|
||||
let req = Request::builder()
|
||||
.uri(format!("/api/routines/{}", alice_routine.id))
|
||||
.header("Authorization", "Bearer tok-bob")
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let resp = app.clone().oneshot(req).await.unwrap();
|
||||
assert_eq!(
|
||||
resp.status(),
|
||||
StatusCode::NOT_FOUND,
|
||||
"bob should not see alice's routine detail"
|
||||
);
|
||||
|
||||
// Bob cannot toggle alice's routine.
|
||||
let req = Request::builder()
|
||||
.method(Method::POST)
|
||||
.uri(format!("/api/routines/{}/toggle", alice_routine.id))
|
||||
.header("Authorization", "Bearer tok-bob")
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let resp = app.clone().oneshot(req).await.unwrap();
|
||||
assert_eq!(
|
||||
resp.status(),
|
||||
StatusCode::NOT_FOUND,
|
||||
"bob should not toggle alice's routine"
|
||||
);
|
||||
|
||||
// Bob cannot delete alice's routine.
|
||||
let req = Request::builder()
|
||||
.method(Method::DELETE)
|
||||
.uri(format!("/api/routines/{}", alice_routine.id))
|
||||
.header("Authorization", "Bearer tok-bob")
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let resp = app.oneshot(req).await.unwrap();
|
||||
assert_eq!(
|
||||
resp.status(),
|
||||
StatusCode::NOT_FOUND,
|
||||
"bob should not delete alice's routine"
|
||||
);
|
||||
}
|
||||
}
|
||||
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
// Handler Auth Enforcement Tests
|
||||
// ═══════════════════════════════════════════════════════════════════════
|
||||
|
||||
mod auth_enforcement {
|
||||
use super::*;
|
||||
|
||||
/// Dummy handler that extracts `AuthenticatedUser` — if the auth middleware
|
||||
/// rejects the request, this handler is never reached.
|
||||
async fn authed_handler(AuthenticatedUser(_user): AuthenticatedUser) -> &'static str {
|
||||
"ok"
|
||||
}
|
||||
|
||||
/// Build a router with the real auth middleware and dummy handlers at all
|
||||
/// the paths we want to verify require authentication.
|
||||
fn auth_test_router(auth: MultiAuthState) -> Router {
|
||||
let state = build_state(None, None);
|
||||
Router::new()
|
||||
// Routines
|
||||
.route("/api/routines", get(authed_handler))
|
||||
.route("/api/routines/summary", get(authed_handler))
|
||||
.route("/api/routines/{id}", get(authed_handler))
|
||||
.route("/api/routines/{id}/toggle", post(authed_handler))
|
||||
.route("/api/routines/{id}", delete(authed_handler))
|
||||
// Skills
|
||||
.route("/api/skills", get(authed_handler))
|
||||
.route("/api/skills/search", post(authed_handler))
|
||||
.route("/api/skills/install", post(authed_handler))
|
||||
.route("/api/skills/{name}", delete(authed_handler))
|
||||
// Logs
|
||||
.route("/api/logs/events", get(authed_handler))
|
||||
.route("/api/logs/level", get(authed_handler).put(authed_handler))
|
||||
// Gateway status
|
||||
.route("/api/gateway/status", get(authed_handler))
|
||||
.layer(middleware::from_fn_with_state(auth, auth_middleware))
|
||||
.with_state(state)
|
||||
}
|
||||
|
||||
/// Send a request without auth and assert it returns UNAUTHORIZED.
|
||||
async fn assert_requires_auth(app: &Router, method: Method, uri: &str) {
|
||||
let req = Request::builder()
|
||||
.method(method.clone())
|
||||
.uri(uri)
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let resp = app.clone().oneshot(req).await.unwrap();
|
||||
assert_eq!(
|
||||
resp.status(),
|
||||
StatusCode::UNAUTHORIZED,
|
||||
"{} {} should require auth",
|
||||
method,
|
||||
uri
|
||||
);
|
||||
}
|
||||
|
||||
/// Send a request with a valid token and assert it succeeds.
|
||||
async fn assert_passes_with_token(app: &Router, method: Method, uri: &str, token: &str) {
|
||||
let req = Request::builder()
|
||||
.method(method.clone())
|
||||
.uri(uri)
|
||||
.header("Authorization", format!("Bearer {token}"))
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let resp = app.clone().oneshot(req).await.unwrap();
|
||||
assert_eq!(
|
||||
resp.status(),
|
||||
StatusCode::OK,
|
||||
"{} {} should pass with valid token",
|
||||
method,
|
||||
uri
|
||||
);
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_routines_handlers_require_auth() {
|
||||
let auth = MultiAuthState::single("secret-tok".to_string(), "user".to_string());
|
||||
let app = auth_test_router(auth);
|
||||
let id = Uuid::new_v4();
|
||||
|
||||
assert_requires_auth(&app, Method::GET, "/api/routines").await;
|
||||
assert_requires_auth(&app, Method::GET, "/api/routines/summary").await;
|
||||
assert_requires_auth(&app, Method::GET, &format!("/api/routines/{id}")).await;
|
||||
assert_requires_auth(&app, Method::POST, &format!("/api/routines/{id}/toggle")).await;
|
||||
assert_requires_auth(&app, Method::DELETE, &format!("/api/routines/{id}")).await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_skills_handlers_require_auth() {
|
||||
let auth = MultiAuthState::single("secret-tok".to_string(), "user".to_string());
|
||||
let app = auth_test_router(auth);
|
||||
|
||||
assert_requires_auth(&app, Method::GET, "/api/skills").await;
|
||||
assert_requires_auth(&app, Method::POST, "/api/skills/search").await;
|
||||
assert_requires_auth(&app, Method::POST, "/api/skills/install").await;
|
||||
assert_requires_auth(&app, Method::DELETE, "/api/skills/test-skill").await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_logs_handlers_require_auth() {
|
||||
let auth = MultiAuthState::single("secret-tok".to_string(), "user".to_string());
|
||||
let app = auth_test_router(auth);
|
||||
|
||||
assert_requires_auth(&app, Method::GET, "/api/logs/events").await;
|
||||
assert_requires_auth(&app, Method::GET, "/api/logs/level").await;
|
||||
assert_requires_auth(&app, Method::PUT, "/api/logs/level").await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_gateway_status_requires_auth() {
|
||||
let auth = MultiAuthState::single("secret-tok".to_string(), "user".to_string());
|
||||
let app = auth_test_router(auth);
|
||||
|
||||
assert_requires_auth(&app, Method::GET, "/api/gateway/status").await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_valid_token_passes_all_endpoints() {
|
||||
let auth = MultiAuthState::single("secret-tok".to_string(), "user".to_string());
|
||||
let app = auth_test_router(auth);
|
||||
let id = Uuid::new_v4();
|
||||
|
||||
assert_passes_with_token(&app, Method::GET, "/api/routines", "secret-tok").await;
|
||||
assert_passes_with_token(&app, Method::GET, "/api/skills", "secret-tok").await;
|
||||
assert_passes_with_token(&app, Method::GET, "/api/logs/events", "secret-tok").await;
|
||||
assert_passes_with_token(&app, Method::GET, "/api/gateway/status", "secret-tok").await;
|
||||
assert_passes_with_token(
|
||||
&app,
|
||||
Method::GET,
|
||||
&format!("/api/routines/{id}"),
|
||||
"secret-tok",
|
||||
)
|
||||
.await;
|
||||
}
|
||||
|
||||
#[tokio::test]
|
||||
async fn test_wrong_token_rejected_on_all_endpoints() {
|
||||
let auth = MultiAuthState::single("secret-tok".to_string(), "user".to_string());
|
||||
let app = auth_test_router(auth);
|
||||
|
||||
// Wrong token should be rejected.
|
||||
let req = Request::builder()
|
||||
.uri("/api/routines")
|
||||
.header("Authorization", "Bearer wrong-tok")
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let resp = app.clone().oneshot(req).await.unwrap();
|
||||
assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
|
||||
|
||||
let req = Request::builder()
|
||||
.uri("/api/gateway/status")
|
||||
.header("Authorization", "Bearer wrong-tok")
|
||||
.body(Body::empty())
|
||||
.unwrap();
|
||||
let resp = app.oneshot(req).await.unwrap();
|
||||
assert_eq!(resp.status(), StatusCode::UNAUTHORIZED);
|
||||
}
|
||||
}
|
||||
@@ -277,6 +277,32 @@ impl JobStore for LibSqlBackend {
|
||||
Ok(summary)
|
||||
}
|
||||
|
||||
async fn agent_job_summary_for_user(
|
||||
&self,
|
||||
user_id: &str,
|
||||
) -> Result<AgentJobSummary, DatabaseError> {
|
||||
let conn = self.connect().await?;
|
||||
let mut rows = conn
|
||||
.query(
|
||||
"SELECT status, COUNT(*) as cnt FROM agent_jobs WHERE source = 'direct' AND user_id = ?1 GROUP BY status",
|
||||
params![user_id],
|
||||
)
|
||||
.await
|
||||
.map_err(|e| DatabaseError::Query(e.to_string()))?;
|
||||
|
||||
let mut summary = AgentJobSummary::default();
|
||||
while let Some(row) = rows
|
||||
.next()
|
||||
.await
|
||||
.map_err(|e| DatabaseError::Query(e.to_string()))?
|
||||
{
|
||||
let status = get_text(&row, 0);
|
||||
let count = get_i64(&row, 1) as usize;
|
||||
summary.add_count(&status, count);
|
||||
}
|
||||
Ok(summary)
|
||||
}
|
||||
|
||||
async fn save_action(&self, job_id: Uuid, action: &ActionRecord) -> Result<(), DatabaseError> {
|
||||
let conn = self.connect().await?;
|
||||
let duration_ms = action.duration.as_millis() as i64;
|
||||
|
||||
@@ -410,6 +410,10 @@ pub trait JobStore: Send + Sync {
|
||||
async fn get_stuck_jobs(&self) -> Result<Vec<Uuid>, DatabaseError>;
|
||||
async fn list_agent_jobs(&self) -> Result<Vec<AgentJobRecord>, DatabaseError>;
|
||||
async fn agent_job_summary(&self) -> Result<AgentJobSummary, DatabaseError>;
|
||||
async fn agent_job_summary_for_user(
|
||||
&self,
|
||||
user_id: &str,
|
||||
) -> Result<AgentJobSummary, DatabaseError>;
|
||||
/// Get the failure reason for a single agent job (O(1) lookup).
|
||||
async fn get_agent_job_failure_reason(&self, id: Uuid)
|
||||
-> Result<Option<String>, DatabaseError>;
|
||||
|
||||
@@ -253,6 +253,13 @@ impl JobStore for PgBackend {
|
||||
self.store.agent_job_summary().await
|
||||
}
|
||||
|
||||
async fn agent_job_summary_for_user(
|
||||
&self,
|
||||
user_id: &str,
|
||||
) -> Result<AgentJobSummary, DatabaseError> {
|
||||
self.store.agent_job_summary_for_user(user_id).await
|
||||
}
|
||||
|
||||
async fn get_agent_job_failure_reason(
|
||||
&self,
|
||||
id: Uuid,
|
||||
|
||||
@@ -6057,7 +6057,7 @@ mod tests {
|
||||
fields.insert("llm_backend".to_string(), "openai".to_string());
|
||||
|
||||
let result = mgr
|
||||
.configure("switch-llm", &std::collections::HashMap::new(), &fields)
|
||||
.configure("switch-llm", &std::collections::HashMap::new(), &fields, "test-user")
|
||||
.await
|
||||
.expect("save configuration");
|
||||
|
||||
@@ -6105,7 +6105,7 @@ mod tests {
|
||||
fields.insert("session".to_string(), "overwrite".to_string());
|
||||
|
||||
let err = match mgr
|
||||
.configure("evil-tool", &std::collections::HashMap::new(), &fields)
|
||||
.configure("evil-tool", &std::collections::HashMap::new(), &fields, "test-user")
|
||||
.await
|
||||
{
|
||||
Ok(_) => panic!("disallowed setting_path should fail"),
|
||||
|
||||
@@ -875,6 +875,27 @@ impl Store {
|
||||
}
|
||||
Ok(summary)
|
||||
}
|
||||
|
||||
pub async fn agent_job_summary_for_user(
|
||||
&self,
|
||||
user_id: &str,
|
||||
) -> Result<AgentJobSummary, DatabaseError> {
|
||||
let conn = self.conn().await?;
|
||||
let rows = conn
|
||||
.query(
|
||||
"SELECT status, COUNT(*) as cnt FROM agent_jobs WHERE source = 'direct' AND user_id = $1 GROUP BY status",
|
||||
&[&user_id],
|
||||
)
|
||||
.await?;
|
||||
|
||||
let mut summary = AgentJobSummary::default();
|
||||
for row in &rows {
|
||||
let status: String = row.get("status");
|
||||
let count: i64 = row.get("cnt");
|
||||
summary.add_count(&status, count as usize);
|
||||
}
|
||||
Ok(summary)
|
||||
}
|
||||
}
|
||||
|
||||
// ==================== Job Events ====================
|
||||
|
||||
@@ -619,9 +619,15 @@ async fn async_main() -> anyhow::Result<()> {
|
||||
}
|
||||
// Create per-user workspace pool for multi-user mode.
|
||||
if let Some(ref db) = components.db {
|
||||
let emb_cache_config = ironclaw::workspace::EmbeddingCacheConfig {
|
||||
max_entries: config.embeddings.cache_size,
|
||||
};
|
||||
let pool = Arc::new(ironclaw::channels::web::server::WorkspacePool::new(
|
||||
Arc::clone(db),
|
||||
components.embeddings.clone(),
|
||||
emb_cache_config,
|
||||
config.search.clone(),
|
||||
config.workspace.clone(),
|
||||
));
|
||||
gw = gw.with_workspace_pool(pool);
|
||||
}
|
||||
|
||||
Reference in New Issue
Block a user