sharang/compliance-scanner-agent
1
0
Fork 0
Code Issues 51 Pull Requests 6 Actions Packages Projects Releases 1 Wiki Activity

fix(dashboard): attach Keycloak token on agent API calls
CI / Check (pull_request) Successful in 8m12s
Details
CI / Detect Changes (pull_request) Has been skipped
Details
CI / Deploy Agent (pull_request) Has been skipped
Details
CI / Deploy Dashboard (pull_request) Has been skipped
Details
CI / Deploy Docs (pull_request) Has been skipped
Details
CI / Deploy MCP (pull_request) Has been skipped
Details

Browse Source 
Symptom: "unable to load repositories" — agent returns
"Missing authorization header" 401 on every protected endpoint
because the dashboard's server functions were calling reqwest::get
without an Authorization header. The Keycloak OIDC flow
(auth_login / auth_callback) was already wired up and storing the
access_token in tower-sessions, but the access_token was never
threaded into outbound calls.

Fix
- New `infrastructure::agent_client` module exposes:
  - `agent_request(method, path) -> RequestBuilder`
  - `agent_get(path) -> RequestBuilder` (sugar for GET)
  Both pull the session's access_token (via FullstackContext extract)
  and attach `Authorization: Bearer <token>`. When Keycloak is not
  configured the helper short-circuits — matching the dashboard's
  require_auth middleware which short-circuits in the same state.
- Migrated every #[server] function in:
  - chat, dast, findings, graph, issues, notifications, pentest,
    repositories, sbom, scans, stats
  - 57 call sites total, all replaced.
- Left as-is:
  - `infrastructure::server::webhook_proxy` — forwards to the agent's
    separate webhook server (port 3002), which is HMAC-authenticated,
    not JWT-authenticated.
  - `infrastructure::auth::auth_callback` — performs the KC token
    exchange itself; bearer auth would be circular.

Test plan
- cargo fmt --all clean
- cargo clippy -p compliance-dashboard --features server -- -D warnings
  clean
- cargo check -p compliance-dashboard --features server clean
- cargo check -p compliance-dashboard (web target) implicit via build
- Manual: after deploy, dashboard's repositories page loads without
  401; calls now carry Authorization: Bearer header to the agent.

Co-Authored-By: Claude Opus 4.7 <noreply@anthropic.com>
This commit is contained in:
Sharang Parnerkar
2026-06-17 20:31:21 +02:00
parent 08c4ec4cff
commit dcec519565
13 changed files with 412 additions and 493 deletions
Download Patch File Download Diff File Expand all files Collapse all files
compliance-dashboard/src/infrastructure/agent_client.rs
+61
View File
@@ -0,0 +1,61 @@
//! Authenticated HTTP client for talking to the compliance-agent.
//!
//! Every dashboard server function that hits `comp-dev.meghsakha.com/api/v1/*`
//! must go through here so the Keycloak access token from the user's
//! session is attached as `Authorization: Bearer <token>`. Without it
//! the agent's M7.1 `require_jwt_auth` middleware rejects with 401
//! "Missing authorization header".
//!
//! When Keycloak is not configured (dev convenience), the helper
//! returns an unauthenticated builder — matching the agent's
//! pass-through behavior in the same state.
use dioxus::prelude::ServerFnError;
use dioxus_fullstack::FullstackContext;
use reqwest::Method;
use super::auth::LOGGED_IN_USER_SESS_KEY;
use super::server_state::ServerState;
use super::user_state::UserStateInner;
/// Build a `RequestBuilder` for `<agent_api_url><path>` with the
/// session's access token attached. `path` should include a leading
/// `/`, e.g. `"/api/v1/repositories"`.
pub async fn agent_request(
method: Method,
path: &str,
) -> Result<reqwest::RequestBuilder, ServerFnError> {
let state: ServerState = FullstackContext::extract().await?;
let url = format!("{}{}", state.agent_api_url, path);
let mut req = reqwest::Client::new().request(method, &url);
req = attach_token(req, &state).await?;
Ok(req)
}
/// Same as [`agent_request`] but for `GET`. Convenience for the common case.
pub async fn agent_get(path: &str) -> Result<reqwest::RequestBuilder, ServerFnError> {
agent_request(Method::GET, path).await
}
/// Attach the session's bearer token if Keycloak is configured AND the
/// session has a logged-in user. Otherwise leave the request as-is.
///
/// The Keycloak-disabled path mirrors the dashboard's `require_auth`
/// middleware, which short-circuits when `state.keycloak.is_none()`.
async fn attach_token(
req: reqwest::RequestBuilder,
state: &ServerState,
) -> Result<reqwest::RequestBuilder, ServerFnError> {
if state.keycloak.is_none() {
return Ok(req);
}
let session: tower_sessions::Session = FullstackContext::extract().await?;
let user: Option<UserStateInner> = session
.get(LOGGED_IN_USER_SESS_KEY)
.await
.map_err(|e| ServerFnError::new(format!("session read failed: {e}")))?;
Ok(match user {
Some(u) => req.bearer_auth(u.access_token),
None => req,
})
}
compliance-dashboard/src/infrastructure/chat.rs
+26 -35
View File
@@ -61,23 +61,21 @@ pub async fn send_chat_message(
message: String, message: String,
history: Vec<ChatHistoryMessage>, history: Vec<ChatHistoryMessage>,
) -> Result<ChatApiResponse, ServerFnError> { ) -> Result<ChatApiResponse, ServerFnError> {
let state: super::server_state::ServerState = // Chat uses a longer timeout because the LLM round-trip can be slow;
dioxus_fullstack::FullstackContext::extract().await?; // agent_request doesn't expose a per-call timeout so we layer one on.
let resp = super::agent_client::agent_request(
let url = format!("{}/api/v1/chat/{repo_id}", state.agent_api_url); reqwest::Method::POST,
let client = reqwest::Client::builder() &format!("/api/v1/chat/{repo_id}"),
.timeout(std::time::Duration::from_secs(120)) )
.build() .await?
.map_err(|e| ServerFnError::new(e.to_string()))?; .timeout(std::time::Duration::from_secs(120))
let resp = client .json(&serde_json::json!({
.post(&url) "message": message,
.json(&serde_json::json!({ "history": history,
"message": message, }))
"history": history, .send()
})) .await
.send() .map_err(|e| ServerFnError::new(format!("Request failed: {e}")))?;
.await
.map_err(|e| ServerFnError::new(format!("Request failed: {e}")))?;
let text = resp let text = resp
.text() .text()
@@ -91,19 +89,14 @@ pub async fn send_chat_message(
#[server] #[server]
pub async fn trigger_embedding_build(repo_id: String) -> Result<(), ServerFnError> { pub async fn trigger_embedding_build(repo_id: String) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState = super::agent_client::agent_request(
dioxus_fullstack::FullstackContext::extract().await?; reqwest::Method::POST,
&format!("/api/v1/chat/{repo_id}/build-embeddings"),
let url = format!( )
"{}/api/v1/chat/{repo_id}/build-embeddings", .await?
state.agent_api_url .send()
); .await
let client = reqwest::Client::new(); .map_err(|e| ServerFnError::new(e.to_string()))?;
client
.post(&url)
.send()
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
Ok(()) Ok(())
} }
@@ -111,11 +104,9 @@ pub async fn trigger_embedding_build(repo_id: String) -> Result<(), ServerFnErro
pub async fn fetch_embedding_status( pub async fn fetch_embedding_status(
repo_id: String, repo_id: String,
) -> Result<EmbeddingStatusResponse, ServerFnError> { ) -> Result<EmbeddingStatusResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get(&format!("/api/v1/chat/{repo_id}/status"))
dioxus_fullstack::FullstackContext::extract().await?; .await?
.send()
let url = format!("{}/api/v1/chat/{repo_id}/status", state.agent_api_url);
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: EmbeddingStatusResponse = resp let body: EmbeddingStatusResponse = resp
compliance-dashboard/src/infrastructure/dast.rs
+22 -34
View File
@@ -26,10 +26,9 @@ pub struct DastFindingDetailResponse {
#[server] #[server]
pub async fn fetch_dast_targets() -> Result<DastTargetsResponse, ServerFnError> { pub async fn fetch_dast_targets() -> Result<DastTargetsResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get("/api/v1/dast/targets")
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/dast/targets", state.agent_api_url); .send()
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: DastTargetsResponse = resp let body: DastTargetsResponse = resp
@@ -41,10 +40,9 @@ pub async fn fetch_dast_targets() -> Result<DastTargetsResponse, ServerFnError>
#[server] #[server]
pub async fn fetch_dast_scan_runs() -> Result<DastScanRunsResponse, ServerFnError> { pub async fn fetch_dast_scan_runs() -> Result<DastScanRunsResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get("/api/v1/dast/scan-runs")
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/dast/scan-runs", state.agent_api_url); .send()
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: DastScanRunsResponse = resp let body: DastScanRunsResponse = resp
@@ -56,10 +54,9 @@ pub async fn fetch_dast_scan_runs() -> Result<DastScanRunsResponse, ServerFnErro
#[server] #[server]
pub async fn fetch_dast_findings() -> Result<DastFindingsResponse, ServerFnError> { pub async fn fetch_dast_findings() -> Result<DastFindingsResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get("/api/v1/dast/findings")
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/dast/findings", state.agent_api_url); .send()
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: DastFindingsResponse = resp let body: DastFindingsResponse = resp
@@ -73,10 +70,9 @@ pub async fn fetch_dast_findings() -> Result<DastFindingsResponse, ServerFnError
pub async fn fetch_dast_finding_detail( pub async fn fetch_dast_finding_detail(
id: String, id: String,
) -> Result<DastFindingDetailResponse, ServerFnError> { ) -> Result<DastFindingDetailResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get(&format!("/api/v1/dast/findings/{id}"))
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/dast/findings/{id}", state.agent_api_url); .send()
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: DastFindingDetailResponse = resp let body: DastFindingDetailResponse = resp
@@ -88,12 +84,8 @@ pub async fn fetch_dast_finding_detail(
#[server] #[server]
pub async fn add_dast_target(name: String, base_url: String) -> Result<(), ServerFnError> { pub async fn add_dast_target(name: String, base_url: String) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState = super::agent_client::agent_request(reqwest::Method::POST, "/api/v1/dast/targets")
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/dast/targets", state.agent_api_url);
let client = reqwest::Client::new();
client
.post(&url)
.json(&serde_json::json!({ .json(&serde_json::json!({
"name": name, "name": name,
"base_url": base_url, "base_url": base_url,
@@ -106,17 +98,13 @@ pub async fn add_dast_target(name: String, base_url: String) -> Result<(), Serve
#[server] #[server]
pub async fn trigger_dast_scan(target_id: String) -> Result<(), ServerFnError> { pub async fn trigger_dast_scan(target_id: String) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState = super::agent_client::agent_request(
dioxus_fullstack::FullstackContext::extract().await?; reqwest::Method::POST,
let url = format!( &format!("/api/v1/dast/targets/{target_id}/scan"),
"{}/api/v1/dast/targets/{target_id}/scan", )
state.agent_api_url .await?
); .send()
let client = reqwest::Client::new(); .await
client .map_err(|e| ServerFnError::new(e.to_string()))?;
.post(&url)
.send()
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
Ok(()) Ok(())
} }
compliance-dashboard/src/infrastructure/findings.rs
+34 -52
View File
@@ -24,39 +24,35 @@ pub struct FindingsQuery {
#[server] #[server]
pub async fn fetch_findings(query: FindingsQuery) -> Result<FindingsListResponse, ServerFnError> { pub async fn fetch_findings(query: FindingsQuery) -> Result<FindingsListResponse, ServerFnError> {
let state: super::server_state::ServerState = let mut path = format!("/api/v1/findings?page={}&limit=20", query.page);
dioxus_fullstack::FullstackContext::extract().await?;
let mut url = format!(
"{}/api/v1/findings?page={}&limit=20",
state.agent_api_url, query.page
);
if !query.severity.is_empty() { if !query.severity.is_empty() {
url.push_str(&format!("&severity={}", query.severity)); path.push_str(&format!("&severity={}", query.severity));
} }
if !query.scan_type.is_empty() { if !query.scan_type.is_empty() {
url.push_str(&format!("&scan_type={}", query.scan_type)); path.push_str(&format!("&scan_type={}", query.scan_type));
} }
if !query.status.is_empty() { if !query.status.is_empty() {
url.push_str(&format!("&status={}", query.status)); path.push_str(&format!("&status={}", query.status));
} }
if !query.repo_id.is_empty() { if !query.repo_id.is_empty() {
url.push_str(&format!("&repo_id={}", query.repo_id)); path.push_str(&format!("&repo_id={}", query.repo_id));
} }
if !query.q.is_empty() { if !query.q.is_empty() {
url.push_str(&format!( path.push_str(&format!(
"&q={}", "&q={}",
url::form_urlencoded::byte_serialize(query.q.as_bytes()).collect::<String>() url::form_urlencoded::byte_serialize(query.q.as_bytes()).collect::<String>()
)); ));
} }
if !query.sort_by.is_empty() { if !query.sort_by.is_empty() {
url.push_str(&format!("&sort_by={}", query.sort_by)); path.push_str(&format!("&sort_by={}", query.sort_by));
} }
if !query.sort_order.is_empty() { if !query.sort_order.is_empty() {
url.push_str(&format!("&sort_order={}", query.sort_order)); path.push_str(&format!("&sort_order={}", query.sort_order));
} }
let resp = reqwest::get(&url) let resp = super::agent_client::agent_get(&path)
.await?
.send()
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: FindingsListResponse = resp let body: FindingsListResponse = resp
@@ -68,11 +64,9 @@ pub async fn fetch_findings(query: FindingsQuery) -> Result<FindingsListResponse
#[server] #[server]
pub async fn fetch_finding_detail(id: String) -> Result<Finding, ServerFnError> { pub async fn fetch_finding_detail(id: String) -> Result<Finding, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get(&format!("/api/v1/findings/{id}"))
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/findings/{id}", state.agent_api_url); .send()
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: serde_json::Value = resp let body: serde_json::Value = resp
@@ -86,18 +80,15 @@ pub async fn fetch_finding_detail(id: String) -> Result<Finding, ServerFnError>
#[server] #[server]
pub async fn update_finding_status(id: String, status: String) -> Result<(), ServerFnError> { pub async fn update_finding_status(id: String, status: String) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState = super::agent_client::agent_request(
dioxus_fullstack::FullstackContext::extract().await?; reqwest::Method::PATCH,
let url = format!("{}/api/v1/findings/{id}/status", state.agent_api_url); &format!("/api/v1/findings/{id}/status"),
)
let client = reqwest::Client::new(); .await?
client .json(&serde_json::json!({ "status": status }))
.patch(&url) .send()
.json(&serde_json::json!({ "status": status })) .await
.send() .map_err(|e| ServerFnError::new(e.to_string()))?;
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
Ok(()) Ok(())
} }
@@ -106,34 +97,25 @@ pub async fn bulk_update_finding_status(
ids: Vec<String>, ids: Vec<String>,
status: String, status: String,
) -> Result<(), ServerFnError> { ) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState = super::agent_client::agent_request(reqwest::Method::PATCH, "/api/v1/findings/bulk-status")
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/findings/bulk-status", state.agent_api_url);
let client = reqwest::Client::new();
client
.patch(&url)
.json(&serde_json::json!({ "ids": ids, "status": status })) .json(&serde_json::json!({ "ids": ids, "status": status }))
.send() .send()
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
Ok(()) Ok(())
} }
#[server] #[server]
pub async fn update_finding_feedback(id: String, feedback: String) -> Result<(), ServerFnError> { pub async fn update_finding_feedback(id: String, feedback: String) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState = super::agent_client::agent_request(
dioxus_fullstack::FullstackContext::extract().await?; reqwest::Method::PATCH,
let url = format!("{}/api/v1/findings/{id}/feedback", state.agent_api_url); &format!("/api/v1/findings/{id}/feedback"),
)
let client = reqwest::Client::new(); .await?
client .json(&serde_json::json!({ "feedback": feedback }))
.patch(&url) .send()
.json(&serde_json::json!({ "feedback": feedback })) .await
.send() .map_err(|e| ServerFnError::new(e.to_string()))?;
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
Ok(()) Ok(())
} }
compliance-dashboard/src/infrastructure/graph.rs
+34 -44
View File
@@ -50,10 +50,9 @@ pub struct SearchResponse {
#[server] #[server]
pub async fn fetch_graph(repo_id: String) -> Result<GraphDataResponse, ServerFnError> { pub async fn fetch_graph(repo_id: String) -> Result<GraphDataResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get(&format!("/api/v1/graph/{repo_id}"))
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/graph/{repo_id}", state.agent_api_url); .send()
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: GraphDataResponse = resp let body: GraphDataResponse = resp
@@ -68,15 +67,12 @@ pub async fn fetch_impact(
repo_id: String, repo_id: String,
finding_id: String, finding_id: String,
) -> Result<ImpactResponse, ServerFnError> { ) -> Result<ImpactResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp =
dioxus_fullstack::FullstackContext::extract().await?; super::agent_client::agent_get(&format!("/api/v1/graph/{repo_id}/impact/{finding_id}"))
let url = format!( .await?
"{}/api/v1/graph/{repo_id}/impact/{finding_id}", .send()
state.agent_api_url .await
); .map_err(|e| ServerFnError::new(e.to_string()))?;
let resp = reqwest::get(&url)
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
let body: ImpactResponse = resp let body: ImpactResponse = resp
.json() .json()
.await .await
@@ -86,10 +82,9 @@ pub async fn fetch_impact(
#[server] #[server]
pub async fn fetch_communities(repo_id: String) -> Result<CommunitiesResponse, ServerFnError> { pub async fn fetch_communities(repo_id: String) -> Result<CommunitiesResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get(&format!("/api/v1/graph/{repo_id}/communities"))
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/graph/{repo_id}/communities", state.agent_api_url); .send()
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: CommunitiesResponse = resp let body: CommunitiesResponse = resp
@@ -104,15 +99,13 @@ pub async fn fetch_file_content(
repo_id: String, repo_id: String,
file_path: String, file_path: String,
) -> Result<FileContentResponse, ServerFnError> { ) -> Result<FileContentResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get(&format!(
dioxus_fullstack::FullstackContext::extract().await?; "/api/v1/graph/{repo_id}/file-content?path={file_path}"
let url = format!( ))
"{}/api/v1/graph/{repo_id}/file-content?path={file_path}", .await?
state.agent_api_url .send()
); .await
let resp = reqwest::get(&url) .map_err(|e| ServerFnError::new(e.to_string()))?;
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
let body: FileContentResponse = resp let body: FileContentResponse = resp
.json() .json()
.await .await
@@ -122,15 +115,13 @@ pub async fn fetch_file_content(
#[server] #[server]
pub async fn search_nodes(repo_id: String, query: String) -> Result<SearchResponse, ServerFnError> { pub async fn search_nodes(repo_id: String, query: String) -> Result<SearchResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get(&format!(
dioxus_fullstack::FullstackContext::extract().await?; "/api/v1/graph/{repo_id}/search?q={query}&limit=50"
let url = format!( ))
"{}/api/v1/graph/{repo_id}/search?q={query}&limit=50", .await?
state.agent_api_url .send()
); .await
let resp = reqwest::get(&url) .map_err(|e| ServerFnError::new(e.to_string()))?;
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
let body: SearchResponse = resp let body: SearchResponse = resp
.json() .json()
.await .await
@@ -140,14 +131,13 @@ pub async fn search_nodes(repo_id: String, query: String) -> Result<SearchRespon
#[server] #[server]
pub async fn trigger_graph_build(repo_id: String) -> Result<(), ServerFnError> { pub async fn trigger_graph_build(repo_id: String) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState = super::agent_client::agent_request(
dioxus_fullstack::FullstackContext::extract().await?; reqwest::Method::POST,
let url = format!("{}/api/v1/graph/{repo_id}/build", state.agent_api_url); &format!("/api/v1/graph/{repo_id}/build"),
let client = reqwest::Client::new(); )
client .await?
.post(&url) .send()
.send() .await
.await .map_err(|e| ServerFnError::new(e.to_string()))?;
.map_err(|e| ServerFnError::new(e.to_string()))?;
Ok(()) Ok(())
} }
compliance-dashboard/src/infrastructure/issues.rs
+3 -5
View File
@@ -12,11 +12,9 @@ pub struct IssuesListResponse {
#[server] #[server]
pub async fn fetch_issues(page: u64) -> Result<IssuesListResponse, ServerFnError> { pub async fn fetch_issues(page: u64) -> Result<IssuesListResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get(&format!("/api/v1/issues?page={page}&limit=20"))
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/issues?page={page}&limit=20", state.agent_api_url); .send()
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: IssuesListResponse = resp let body: IssuesListResponse = resp
compliance-dashboard/src/infrastructure/mod.rs
+2
View File
@@ -18,6 +18,8 @@ pub mod stats;
// Server-only modules // Server-only modules
#[cfg(feature = "server")] #[cfg(feature = "server")]
mod agent_client;
#[cfg(feature = "server")]
mod auth; mod auth;
#[cfg(feature = "server")] #[cfg(feature = "server")]
mod auth_middleware; mod auth_middleware;
compliance-dashboard/src/infrastructure/notifications.rs
+16 -25
View File
@@ -32,11 +32,9 @@ pub struct NotificationCountResponse {
#[server] #[server]
pub async fn fetch_notification_count() -> Result<u64, ServerFnError> { pub async fn fetch_notification_count() -> Result<u64, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get("/api/v1/notifications/count")
dioxus_fullstack::FullstackContext::extract().await?; .await?
.send()
let url = format!("{}/api/v1/notifications/count", state.agent_api_url);
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: NotificationCountResponse = resp let body: NotificationCountResponse = resp
@@ -48,11 +46,9 @@ pub async fn fetch_notification_count() -> Result<u64, ServerFnError> {
#[server] #[server]
pub async fn fetch_notifications() -> Result<NotificationListResponse, ServerFnError> { pub async fn fetch_notifications() -> Result<NotificationListResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get("/api/v1/notifications?limit=20")
dioxus_fullstack::FullstackContext::extract().await?; .await?
.send()
let url = format!("{}/api/v1/notifications?limit=20", state.agent_api_url);
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: NotificationListResponse = resp let body: NotificationListResponse = resp
@@ -64,12 +60,8 @@ pub async fn fetch_notifications() -> Result<NotificationListResponse, ServerFnE
#[server] #[server]
pub async fn mark_all_notifications_read() -> Result<(), ServerFnError> { pub async fn mark_all_notifications_read() -> Result<(), ServerFnError> {
let state: super::server_state::ServerState = super::agent_client::agent_request(reqwest::Method::POST, "/api/v1/notifications/read-all")
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/notifications/read-all", state.agent_api_url);
reqwest::Client::new()
.post(&url)
.send() .send()
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
@@ -78,14 +70,13 @@ pub async fn mark_all_notifications_read() -> Result<(), ServerFnError> {
#[server] #[server]
pub async fn dismiss_notification(id: String) -> Result<(), ServerFnError> { pub async fn dismiss_notification(id: String) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState = super::agent_client::agent_request(
dioxus_fullstack::FullstackContext::extract().await?; reqwest::Method::PATCH,
&format!("/api/v1/notifications/{id}/dismiss"),
let url = format!("{}/api/v1/notifications/{id}/dismiss", state.agent_api_url); )
reqwest::Client::new() .await?
.patch(&url) .send()
.send() .await
.await .map_err(|e| ServerFnError::new(e.to_string()))?;
.map_err(|e| ServerFnError::new(e.to_string()))?;
Ok(()) Ok(())
} }
compliance-dashboard/src/infrastructure/pentest.rs
+145 -184
View File
@@ -32,12 +32,10 @@ pub struct AttackChainResponse {
#[server] #[server]
pub async fn fetch_pentest_sessions() -> Result<PentestSessionsResponse, ServerFnError> { pub async fn fetch_pentest_sessions() -> Result<PentestSessionsResponse, ServerFnError> {
let state: super::server_state::ServerState =
dioxus_fullstack::FullstackContext::extract().await?;
// Fetch sessions // Fetch sessions
let url = format!("{}/api/v1/pentest/sessions", state.agent_api_url); let resp = super::agent_client::agent_get("/api/v1/pentest/sessions")
let resp = reqwest::get(&url) .await?
.send()
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let mut body: PentestSessionsResponse = resp let mut body: PentestSessionsResponse = resp
@@ -46,31 +44,32 @@ pub async fn fetch_pentest_sessions() -> Result<PentestSessionsResponse, ServerF
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
// Fetch DAST targets to resolve target names // Fetch DAST targets to resolve target names
let targets_url = format!("{}/api/v1/dast/targets", state.agent_api_url); if let Ok(tresp_builder) = super::agent_client::agent_get("/api/v1/dast/targets").await {
if let Ok(tresp) = reqwest::get(&targets_url).await { if let Ok(tresp) = tresp_builder.send().await {
if let Ok(tbody) = tresp.json::<serde_json::Value>().await { if let Ok(tbody) = tresp.json::<serde_json::Value>().await {
let targets = tbody.get("data").and_then(|v| v.as_array()); let targets = tbody.get("data").and_then(|v| v.as_array());
if let Some(targets) = targets { if let Some(targets) = targets {
// Build target_id -> name lookup // Build target_id -> name lookup
let target_map: std::collections::HashMap<String, String> = targets let target_map: std::collections::HashMap<String, String> = targets
.iter() .iter()
.filter_map(|t| { .filter_map(|t| {
let id = t.get("_id")?.get("$oid")?.as_str()?.to_string(); let id = t.get("_id")?.get("$oid")?.as_str()?.to_string();
let name = t.get("name")?.as_str()?.to_string(); let name = t.get("name")?.as_str()?.to_string();
Some((id, name)) Some((id, name))
}) })
.collect(); .collect();
// Enrich sessions with target_name // Enrich sessions with target_name
for session in body.data.iter_mut() { for session in body.data.iter_mut() {
if let Some(tid) = session.get("target_id").and_then(|v| v.as_str()) { if let Some(tid) = session.get("target_id").and_then(|v| v.as_str()) {
if let Some(name) = target_map.get(tid) { if let Some(name) = target_map.get(tid) {
session.as_object_mut().map(|obj| { session.as_object_mut().map(|obj| {
obj.insert( obj.insert(
"target_name".to_string(), "target_name".to_string(),
serde_json::Value::String(name.clone()), serde_json::Value::String(name.clone()),
) )
}); });
}
} }
} }
} }
@@ -83,10 +82,9 @@ pub async fn fetch_pentest_sessions() -> Result<PentestSessionsResponse, ServerF
#[server] #[server]
pub async fn fetch_pentest_session(id: String) -> Result<PentestSessionResponse, ServerFnError> { pub async fn fetch_pentest_session(id: String) -> Result<PentestSessionResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get(&format!("/api/v1/pentest/sessions/{id}"))
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/pentest/sessions/{id}", state.agent_api_url); .send()
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let mut body: PentestSessionResponse = resp let mut body: PentestSessionResponse = resp
@@ -96,26 +94,27 @@ pub async fn fetch_pentest_session(id: String) -> Result<PentestSessionResponse,
// Resolve target name from targets list // Resolve target name from targets list
if let Some(tid) = body.data.get("target_id").and_then(|v| v.as_str()) { if let Some(tid) = body.data.get("target_id").and_then(|v| v.as_str()) {
let targets_url = format!("{}/api/v1/dast/targets", state.agent_api_url); if let Ok(tresp_builder) = super::agent_client::agent_get("/api/v1/dast/targets").await {
if let Ok(tresp) = reqwest::get(&targets_url).await { if let Ok(tresp) = tresp_builder.send().await {
if let Ok(tbody) = tresp.json::<serde_json::Value>().await { if let Ok(tbody) = tresp.json::<serde_json::Value>().await {
if let Some(targets) = tbody.get("data").and_then(|v| v.as_array()) { if let Some(targets) = tbody.get("data").and_then(|v| v.as_array()) {
for t in targets { for t in targets {
let t_id = t let t_id = t
.get("_id") .get("_id")
.and_then(|v| v.get("$oid")) .and_then(|v| v.get("$oid"))
.and_then(|v| v.as_str()) .and_then(|v| v.as_str())
.unwrap_or(""); .unwrap_or("");
if t_id == tid { if t_id == tid {
if let Some(name) = t.get("name").and_then(|v| v.as_str()) { if let Some(name) = t.get("name").and_then(|v| v.as_str()) {
body.data.as_object_mut().map(|obj| { body.data.as_object_mut().map(|obj| {
obj.insert( obj.insert(
"target_name".to_string(), "target_name".to_string(),
serde_json::Value::String(name.to_string()), serde_json::Value::String(name.to_string()),
) )
}); });
}
break;
} }
break;
} }
} }
} }
@@ -130,15 +129,12 @@ pub async fn fetch_pentest_session(id: String) -> Result<PentestSessionResponse,
pub async fn fetch_pentest_messages( pub async fn fetch_pentest_messages(
session_id: String, session_id: String,
) -> Result<PentestMessagesResponse, ServerFnError> { ) -> Result<PentestMessagesResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp =
dioxus_fullstack::FullstackContext::extract().await?; super::agent_client::agent_get(&format!("/api/v1/pentest/sessions/{session_id}/messages"))
let url = format!( .await?
"{}/api/v1/pentest/sessions/{session_id}/messages", .send()
state.agent_api_url .await
); .map_err(|e| ServerFnError::new(e.to_string()))?;
let resp = reqwest::get(&url)
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
let body: PentestMessagesResponse = resp let body: PentestMessagesResponse = resp
.json() .json()
.await .await
@@ -148,10 +144,9 @@ pub async fn fetch_pentest_messages(
#[server] #[server]
pub async fn fetch_pentest_stats() -> Result<PentestStatsResponse, ServerFnError> { pub async fn fetch_pentest_stats() -> Result<PentestStatsResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get("/api/v1/pentest/stats")
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/pentest/stats", state.agent_api_url); .send()
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: PentestStatsResponse = resp let body: PentestStatsResponse = resp
@@ -163,15 +158,13 @@ pub async fn fetch_pentest_stats() -> Result<PentestStatsResponse, ServerFnError
#[server] #[server]
pub async fn fetch_attack_chain(session_id: String) -> Result<AttackChainResponse, ServerFnError> { pub async fn fetch_attack_chain(session_id: String) -> Result<AttackChainResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get(&format!(
dioxus_fullstack::FullstackContext::extract().await?; "/api/v1/pentest/sessions/{session_id}/attack-chain"
let url = format!( ))
"{}/api/v1/pentest/sessions/{session_id}/attack-chain", .await?
state.agent_api_url .send()
); .await
let resp = reqwest::get(&url) .map_err(|e| ServerFnError::new(e.to_string()))?;
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
let body: AttackChainResponse = resp let body: AttackChainResponse = resp
.json() .json()
.await .await
@@ -185,20 +178,17 @@ pub async fn create_pentest_session(
strategy: String, strategy: String,
message: String, message: String,
) -> Result<PentestSessionResponse, ServerFnError> { ) -> Result<PentestSessionResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp =
dioxus_fullstack::FullstackContext::extract().await?; super::agent_client::agent_request(reqwest::Method::POST, "/api/v1/pentest/sessions")
let url = format!("{}/api/v1/pentest/sessions", state.agent_api_url); .await?
let client = reqwest::Client::new(); .json(&serde_json::json!({
let resp = client "target_id": target_id,
.post(&url) "strategy": strategy,
.json(&serde_json::json!({ "message": message,
"target_id": target_id, }))
"strategy": strategy, .send()
"message": message, .await
})) .map_err(|e| ServerFnError::new(e.to_string()))?;
.send()
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
let body: PentestSessionResponse = resp let body: PentestSessionResponse = resp
.json() .json()
.await .await
@@ -211,18 +201,15 @@ pub async fn create_pentest_session(
pub async fn create_pentest_session_wizard( pub async fn create_pentest_session_wizard(
config_json: String, config_json: String,
) -> Result<PentestSessionResponse, ServerFnError> { ) -> Result<PentestSessionResponse, ServerFnError> {
let state: super::server_state::ServerState =
dioxus_fullstack::FullstackContext::extract().await?;
let url = format!("{}/api/v1/pentest/sessions", state.agent_api_url);
let config: serde_json::Value = let config: serde_json::Value =
serde_json::from_str(&config_json).map_err(|e| ServerFnError::new(e.to_string()))?; serde_json::from_str(&config_json).map_err(|e| ServerFnError::new(e.to_string()))?;
let client = reqwest::Client::new(); let resp =
let resp = client super::agent_client::agent_request(reqwest::Method::POST, "/api/v1/pentest/sessions")
.post(&url) .await?
.json(&serde_json::json!({ "config": config })) .json(&serde_json::json!({ "config": config }))
.send() .send()
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
if !resp.status().is_success() { if !resp.status().is_success() {
let text = resp.text().await.unwrap_or_default(); let text = resp.text().await.unwrap_or_default();
return Err(ServerFnError::new(format!( return Err(ServerFnError::new(format!(
@@ -239,8 +226,6 @@ pub async fn create_pentest_session_wizard(
/// Look up a tracked repository by its git URL /// Look up a tracked repository by its git URL
#[server] #[server]
pub async fn lookup_repo_by_url(url: String) -> Result<serde_json::Value, ServerFnError> { pub async fn lookup_repo_by_url(url: String) -> Result<serde_json::Value, ServerFnError> {
let state: super::server_state::ServerState =
dioxus_fullstack::FullstackContext::extract().await?;
let encoded_url: String = url let encoded_url: String = url
.bytes() .bytes()
.flat_map(|b| { .flat_map(|b| {
@@ -251,13 +236,12 @@ pub async fn lookup_repo_by_url(url: String) -> Result<serde_json::Value, Server
} }
}) })
.collect(); .collect();
let api_url = format!( let resp =
"{}/api/v1/pentest/lookup-repo?url={}", super::agent_client::agent_get(&format!("/api/v1/pentest/lookup-repo?url={encoded_url}"))
state.agent_api_url, encoded_url .await?
); .send()
let resp = reqwest::get(&api_url) .await
.await .map_err(|e| ServerFnError::new(e.to_string()))?;
.map_err(|e| ServerFnError::new(e.to_string()))?;
let body: serde_json::Value = resp let body: serde_json::Value = resp
.json() .json()
.await .await
@@ -270,21 +254,17 @@ pub async fn send_pentest_message(
session_id: String, session_id: String,
message: String, message: String,
) -> Result<PentestMessagesResponse, ServerFnError> { ) -> Result<PentestMessagesResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_request(
dioxus_fullstack::FullstackContext::extract().await?; reqwest::Method::POST,
let url = format!( &format!("/api/v1/pentest/sessions/{session_id}/chat"),
"{}/api/v1/pentest/sessions/{session_id}/chat", )
state.agent_api_url .await?
); .json(&serde_json::json!({
let client = reqwest::Client::new(); "message": message,
let resp = client }))
.post(&url) .send()
.json(&serde_json::json!({ .await
"message": message, .map_err(|e| ServerFnError::new(e.to_string()))?;
}))
.send()
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
let body: PentestMessagesResponse = resp let body: PentestMessagesResponse = resp
.json() .json()
.await .await
@@ -294,35 +274,27 @@ pub async fn send_pentest_message(
#[server] #[server]
pub async fn stop_pentest_session(session_id: String) -> Result<(), ServerFnError> { pub async fn stop_pentest_session(session_id: String) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState = super::agent_client::agent_request(
dioxus_fullstack::FullstackContext::extract().await?; reqwest::Method::POST,
let url = format!( &format!("/api/v1/pentest/sessions/{session_id}/stop"),
"{}/api/v1/pentest/sessions/{session_id}/stop", )
state.agent_api_url .await?
); .send()
let client = reqwest::Client::new(); .await
client .map_err(|e| ServerFnError::new(e.to_string()))?;
.post(&url)
.send()
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
Ok(()) Ok(())
} }
#[server] #[server]
pub async fn pause_pentest_session(session_id: String) -> Result<(), ServerFnError> { pub async fn pause_pentest_session(session_id: String) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_request(
dioxus_fullstack::FullstackContext::extract().await?; reqwest::Method::POST,
let url = format!( &format!("/api/v1/pentest/sessions/{session_id}/pause"),
"{}/api/v1/pentest/sessions/{session_id}/pause", )
state.agent_api_url .await?
); .send()
let client = reqwest::Client::new(); .await
let resp = client .map_err(|e| ServerFnError::new(e.to_string()))?;
.post(&url)
.send()
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
if !resp.status().is_success() { if !resp.status().is_success() {
let text = resp.text().await.unwrap_or_default(); let text = resp.text().await.unwrap_or_default();
return Err(ServerFnError::new(format!("Pause failed: {text}"))); return Err(ServerFnError::new(format!("Pause failed: {text}")));
@@ -332,18 +304,14 @@ pub async fn pause_pentest_session(session_id: String) -> Result<(), ServerFnErr
#[server] #[server]
pub async fn resume_pentest_session(session_id: String) -> Result<(), ServerFnError> { pub async fn resume_pentest_session(session_id: String) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_request(
dioxus_fullstack::FullstackContext::extract().await?; reqwest::Method::POST,
let url = format!( &format!("/api/v1/pentest/sessions/{session_id}/resume"),
"{}/api/v1/pentest/sessions/{session_id}/resume", )
state.agent_api_url .await?
); .send()
let client = reqwest::Client::new(); .await
let resp = client .map_err(|e| ServerFnError::new(e.to_string()))?;
.post(&url)
.send()
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
if !resp.status().is_success() { if !resp.status().is_success() {
let text = resp.text().await.unwrap_or_default(); let text = resp.text().await.unwrap_or_default();
return Err(ServerFnError::new(format!("Resume failed: {text}"))); return Err(ServerFnError::new(format!("Resume failed: {text}")));
@@ -355,15 +323,12 @@ pub async fn resume_pentest_session(session_id: String) -> Result<(), ServerFnEr
pub async fn fetch_pentest_findings( pub async fn fetch_pentest_findings(
session_id: String, session_id: String,
) -> Result<DastFindingsResponse, ServerFnError> { ) -> Result<DastFindingsResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp =
dioxus_fullstack::FullstackContext::extract().await?; super::agent_client::agent_get(&format!("/api/v1/pentest/sessions/{session_id}/findings"))
let url = format!( .await?
"{}/api/v1/pentest/sessions/{session_id}/findings", .send()
state.agent_api_url .await
); .map_err(|e| ServerFnError::new(e.to_string()))?;
let resp = reqwest::get(&url)
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
let body: DastFindingsResponse = resp let body: DastFindingsResponse = resp
.json() .json()
.await .await
@@ -385,23 +350,19 @@ pub async fn export_pentest_report(
requester_name: String, requester_name: String,
requester_email: String, requester_email: String,
) -> Result<ExportReportResponse, ServerFnError> { ) -> Result<ExportReportResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_request(
dioxus_fullstack::FullstackContext::extract().await?; reqwest::Method::POST,
let url = format!( &format!("/api/v1/pentest/sessions/{session_id}/export"),
"{}/api/v1/pentest/sessions/{session_id}/export", )
state.agent_api_url .await?
); .json(&serde_json::json!({
let client = reqwest::Client::new(); "password": password,
let resp = client "requester_name": requester_name,
.post(&url) "requester_email": requester_email,
.json(&serde_json::json!({ }))
"password": password, .send()
"requester_name": requester_name, .await
"requester_email": requester_email, .map_err(|e| ServerFnError::new(e.to_string()))?;
}))
.send()
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
if !resp.status().is_success() { if !resp.status().is_success() {
let text = resp.text().await.unwrap_or_default(); let text = resp.text().await.unwrap_or_default();
return Err(ServerFnError::new(format!("Export failed: {text}"))); return Err(ServerFnError::new(format!("Export failed: {text}")));
compliance-dashboard/src/infrastructure/repositories.rs
+43 -66
View File
@@ -12,14 +12,10 @@ pub struct RepositoryListResponse {
#[server] #[server]
pub async fn fetch_repositories(page: u64) -> Result<RepositoryListResponse, ServerFnError> { pub async fn fetch_repositories(page: u64) -> Result<RepositoryListResponse, ServerFnError> {
let state: super::server_state::ServerState = let path = format!("/api/v1/repositories?page={page}&limit=20");
dioxus_fullstack::FullstackContext::extract().await?; let resp = super::agent_client::agent_get(&path)
let url = format!( .await?
"{}/api/v1/repositories?page={page}&limit=20", .send()
state.agent_api_url
);
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: RepositoryListResponse = resp let body: RepositoryListResponse = resp
@@ -41,10 +37,6 @@ pub async fn add_repository(
tracker_repo: Option<String>, tracker_repo: Option<String>,
tracker_token: Option<String>, tracker_token: Option<String>,
) -> Result<(), ServerFnError> { ) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState =
dioxus_fullstack::FullstackContext::extract().await?;
let url = format!("{}/api/v1/repositories", state.agent_api_url);
let mut body = serde_json::json!({ let mut body = serde_json::json!({
"name": name, "name": name,
"git_url": git_url, "git_url": git_url,
@@ -69,9 +61,8 @@ pub async fn add_repository(
body["tracker_token"] = serde_json::Value::String(tk); body["tracker_token"] = serde_json::Value::String(tk);
} }
let client = reqwest::Client::new(); let resp = super::agent_client::agent_request(reqwest::Method::POST, "/api/v1/repositories")
let resp = client .await?
.post(&url)
.json(&body) .json(&body)
.send() .send()
.await .await
@@ -100,10 +91,6 @@ pub async fn update_repository(
tracker_token: Option<String>, tracker_token: Option<String>,
scan_schedule: Option<String>, scan_schedule: Option<String>,
) -> Result<(), ServerFnError> { ) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState =
dioxus_fullstack::FullstackContext::extract().await?;
let url = format!("{}/api/v1/repositories/{repo_id}", state.agent_api_url);
let mut body = serde_json::Map::new(); let mut body = serde_json::Map::new();
if let Some(v) = name.filter(|s| !s.is_empty()) { if let Some(v) = name.filter(|s| !s.is_empty()) {
body.insert("name".into(), serde_json::Value::String(v)); body.insert("name".into(), serde_json::Value::String(v));
@@ -133,13 +120,15 @@ pub async fn update_repository(
body.insert("scan_schedule".into(), serde_json::Value::String(v)); body.insert("scan_schedule".into(), serde_json::Value::String(v));
} }
let client = reqwest::Client::new(); let resp = super::agent_client::agent_request(
let resp = client reqwest::Method::PATCH,
.patch(&url) &format!("/api/v1/repositories/{repo_id}"),
.json(&body) )
.send() .await?
.await .json(&body)
.map_err(|e| ServerFnError::new(e.to_string()))?; .send()
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
if !resp.status().is_success() { if !resp.status().is_success() {
let text = resp.text().await.unwrap_or_default(); let text = resp.text().await.unwrap_or_default();
@@ -153,11 +142,9 @@ pub async fn update_repository(
#[server] #[server]
pub async fn fetch_ssh_public_key() -> Result<String, ServerFnError> { pub async fn fetch_ssh_public_key() -> Result<String, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get("/api/v1/settings/ssh-public-key")
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/settings/ssh-public-key", state.agent_api_url); .send()
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
@@ -179,16 +166,14 @@ pub async fn fetch_ssh_public_key() -> Result<String, ServerFnError> {
#[server] #[server]
pub async fn delete_repository(repo_id: String) -> Result<(), ServerFnError> { pub async fn delete_repository(repo_id: String) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_request(
dioxus_fullstack::FullstackContext::extract().await?; reqwest::Method::DELETE,
let url = format!("{}/api/v1/repositories/{repo_id}", state.agent_api_url); &format!("/api/v1/repositories/{repo_id}"),
)
let client = reqwest::Client::new(); .await?
let resp = client .send()
.delete(&url) .await
.send() .map_err(|e| ServerFnError::new(e.to_string()))?;
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
if !resp.status().is_success() { if !resp.status().is_success() {
let body = resp.text().await.unwrap_or_default(); let body = resp.text().await.unwrap_or_default();
@@ -202,16 +187,14 @@ pub async fn delete_repository(repo_id: String) -> Result<(), ServerFnError> {
#[server] #[server]
pub async fn trigger_repo_scan(repo_id: String) -> Result<(), ServerFnError> { pub async fn trigger_repo_scan(repo_id: String) -> Result<(), ServerFnError> {
let state: super::server_state::ServerState = super::agent_client::agent_request(
dioxus_fullstack::FullstackContext::extract().await?; reqwest::Method::POST,
let url = format!("{}/api/v1/repositories/{repo_id}/scan", state.agent_api_url); &format!("/api/v1/repositories/{repo_id}/scan"),
)
let client = reqwest::Client::new(); .await?
client .send()
.post(&url) .await
.send() .map_err(|e| ServerFnError::new(e.to_string()))?;
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
Ok(()) Ok(())
} }
@@ -224,16 +207,12 @@ pub struct WebhookConfigResponse {
#[server] #[server]
pub async fn fetch_webhook_config(repo_id: String) -> Result<WebhookConfigResponse, ServerFnError> { pub async fn fetch_webhook_config(repo_id: String) -> Result<WebhookConfigResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp =
dioxus_fullstack::FullstackContext::extract().await?; super::agent_client::agent_get(&format!("/api/v1/repositories/{repo_id}/webhook-config"))
let url = format!( .await?
"{}/api/v1/repositories/{repo_id}/webhook-config", .send()
state.agent_api_url .await
); .map_err(|e| ServerFnError::new(e.to_string()))?;
let resp = reqwest::get(&url)
.await
.map_err(|e| ServerFnError::new(e.to_string()))?;
let body: WebhookConfigResponse = resp let body: WebhookConfigResponse = resp
.json() .json()
.await .await
@@ -244,11 +223,9 @@ pub async fn fetch_webhook_config(repo_id: String) -> Result<WebhookConfigRespon
/// Check if a repository has any running scans /// Check if a repository has any running scans
#[server] #[server]
pub async fn check_repo_scanning(repo_id: String) -> Result<bool, ServerFnError> { pub async fn check_repo_scanning(repo_id: String) -> Result<bool, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get("/api/v1/scan-runs?page=1&limit=1")
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/scan-runs?page=1&limit=1", state.agent_api_url); .send()
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: serde_json::Value = resp let body: serde_json::Value = resp
compliance-dashboard/src/infrastructure/sbom.rs
+20 -35
View File
@@ -87,11 +87,9 @@ pub struct SbomFiltersResponse {
#[server] #[server]
pub async fn fetch_sbom_filters() -> Result<SbomFiltersResponse, ServerFnError> { pub async fn fetch_sbom_filters() -> Result<SbomFiltersResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get("/api/v1/sbom/filters")
dioxus_fullstack::FullstackContext::extract().await?; .await?
.send()
let url = format!("{}/api/v1/sbom/filters", state.agent_api_url);
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let text = resp let text = resp
@@ -112,9 +110,6 @@ pub async fn fetch_sbom_filtered(
license: Option<String>, license: Option<String>,
page: u64, page: u64,
) -> Result<SbomListResponse, ServerFnError> { ) -> Result<SbomListResponse, ServerFnError> {
let state: super::server_state::ServerState =
dioxus_fullstack::FullstackContext::extract().await?;
let mut params = vec![format!("page={page}"), "limit=50".to_string()]; let mut params = vec![format!("page={page}"), "limit=50".to_string()];
if let Some(r) = &repo_id { if let Some(r) = &repo_id {
if !r.is_empty() { if !r.is_empty() {
@@ -140,9 +135,10 @@ pub async fn fetch_sbom_filtered(
} }
} }
let url = format!("{}/api/v1/sbom?{}", state.agent_api_url, params.join("&")); let path = format!("/api/v1/sbom?{}", params.join("&"));
let resp = super::agent_client::agent_get(&path)
let resp = reqwest::get(&url) .await?
.send()
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let text = resp let text = resp
@@ -156,15 +152,10 @@ pub async fn fetch_sbom_filtered(
#[server] #[server]
pub async fn fetch_sbom_export(repo_id: String, format: String) -> Result<String, ServerFnError> { pub async fn fetch_sbom_export(repo_id: String, format: String) -> Result<String, ServerFnError> {
let state: super::server_state::ServerState = let path = format!("/api/v1/sbom/export?repo_id={repo_id}&format={format}");
dioxus_fullstack::FullstackContext::extract().await?; let resp = super::agent_client::agent_get(&path)
.await?
let url = format!( .send()
"{}/api/v1/sbom/export?repo_id={}&format={}",
state.agent_api_url, repo_id, format
);
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let text = resp let text = resp
@@ -178,17 +169,16 @@ pub async fn fetch_sbom_export(repo_id: String, format: String) -> Result<String
pub async fn fetch_license_summary( pub async fn fetch_license_summary(
repo_id: Option<String>, repo_id: Option<String>,
) -> Result<LicenseSummaryResponse, ServerFnError> { ) -> Result<LicenseSummaryResponse, ServerFnError> {
let state: super::server_state::ServerState = let mut path = "/api/v1/sbom/licenses".to_string();
dioxus_fullstack::FullstackContext::extract().await?;
let mut url = format!("{}/api/v1/sbom/licenses", state.agent_api_url);
if let Some(r) = &repo_id { if let Some(r) = &repo_id {
if !r.is_empty() { if !r.is_empty() {
url = format!("{url}?repo_id={r}"); path = format!("{path}?repo_id={r}");
} }
} }
let resp = reqwest::get(&url) let resp = super::agent_client::agent_get(&path)
.await?
.send()
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let text = resp let text = resp
@@ -205,15 +195,10 @@ pub async fn fetch_sbom_diff(
repo_a: String, repo_a: String,
repo_b: String, repo_b: String,
) -> Result<SbomDiffResponse, ServerFnError> { ) -> Result<SbomDiffResponse, ServerFnError> {
let state: super::server_state::ServerState = let path = format!("/api/v1/sbom/diff?repo_a={repo_a}&repo_b={repo_b}");
dioxus_fullstack::FullstackContext::extract().await?; let resp = super::agent_client::agent_get(&path)
.await?
let url = format!( .send()
"{}/api/v1/sbom/diff?repo_a={}&repo_b={}",
state.agent_api_url, repo_a, repo_b
);
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let text = resp let text = resp
compliance-dashboard/src/infrastructure/scans.rs
+3 -8
View File
@@ -12,14 +12,9 @@ pub struct ScansListResponse {
#[server] #[server]
pub async fn fetch_scan_runs(page: u64) -> Result<ScansListResponse, ServerFnError> { pub async fn fetch_scan_runs(page: u64) -> Result<ScansListResponse, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get(&format!("/api/v1/scan-runs?page={page}&limit=20"))
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!( .send()
"{}/api/v1/scan-runs?page={page}&limit=20",
state.agent_api_url
);
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: ScansListResponse = resp let body: ScansListResponse = resp
compliance-dashboard/src/infrastructure/stats.rs
+3 -5
View File
@@ -16,11 +16,9 @@ pub struct OverviewStats {
#[server] #[server]
pub async fn fetch_overview_stats() -> Result<OverviewStats, ServerFnError> { pub async fn fetch_overview_stats() -> Result<OverviewStats, ServerFnError> {
let state: super::server_state::ServerState = let resp = super::agent_client::agent_get("/api/v1/stats/overview")
dioxus_fullstack::FullstackContext::extract().await?; .await?
let url = format!("{}/api/v1/stats/overview", state.agent_api_url); .send()
let resp = reqwest::get(&url)
.await .await
.map_err(|e| ServerFnError::new(e.to_string()))?; .map_err(|e| ServerFnError::new(e.to_string()))?;
let body: serde_json::Value = resp let body: serde_json::Value = resp